From 8bf34019a6dd4b4f69bbcf9b186d58788c927b03 Mon Sep 17 00:00:00 2001 From: Akashdeep Bansal Date: Tue, 12 Nov 2019 14:42:11 +0000 Subject: [PATCH 1/6] init --- src/speech_rules/clearspeak_rules.js | 2 + src/speech_rules/clearspeak_util.js | 157 +++++++++++++++++++++++++++ 2 files changed, 159 insertions(+) diff --git a/src/speech_rules/clearspeak_rules.js b/src/speech_rules/clearspeak_rules.js index b8fe72e2e..40c0de8ef 100644 --- a/src/speech_rules/clearspeak_rules.js +++ b/src/speech_rules/clearspeak_rules.js @@ -100,6 +100,8 @@ var addCTXF = sre.ClearspeakRules.addContextFunction_; sre.ClearspeakRules.addAnnotators_ = function() { sre.SemanticAnnotations.getInstance().register( sre.ClearspeakUtil.simpleExpression()); + sre.SemanticAnnotations.getInstance().register( + sre.ClearspeakUtil.aakash()); sre.SemanticAnnotations.getInstance().register( sre.ClearspeakUtil.unitExpression()); }; diff --git a/src/speech_rules/clearspeak_util.js b/src/speech_rules/clearspeak_util.js index 69b848f8e..3863e9f90 100644 --- a/src/speech_rules/clearspeak_util.js +++ b/src/speech_rules/clearspeak_util.js @@ -98,6 +98,154 @@ sre.ClearspeakUtil.isSimpleExpression = function(node) { sre.ClearspeakUtil.isSimpleFunction_(node); }; +sre.ClearspeakUtil.complexity = function(node) { + let complexity = 0; + switch (node.type) { + case sre.SemanticAttr.Type.INFIXOP: + for (var i=0; i Date: Mon, 16 Dec 2019 20:56:34 +0000 Subject: [PATCH 2/6] Created SemanticComplexity module and added streeDepth --- sample.mml | 27 +++ src/semantic_tree/semantic_complexity.js | 201 +++++++++++++++++++++++ src/speech_rules/clearspeak_rules.js | 6 +- src/speech_rules/clearspeak_util.js | 158 ------------------ 4 files changed, 232 insertions(+), 160 deletions(-) create mode 100644 sample.mml create mode 100644 src/semantic_tree/semantic_complexity.js diff --git a/sample.mml b/sample.mml new file mode 100644 index 000000000..854ec245e --- /dev/null +++ b/sample.mml @@ -0,0 +1,27 @@ + + + x + = + + + - + b + ± + + + b + 2 + + - + 4 + a + c + + + + 2 + a + + + + \ No newline at end of file diff --git a/src/semantic_tree/semantic_complexity.js b/src/semantic_tree/semantic_complexity.js new file mode 100644 index 000000000..d021e4076 --- /dev/null +++ b/src/semantic_tree/semantic_complexity.js @@ -0,0 +1,201 @@ +// Copyright 2019 Akashdeep Bansal +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @fileoverview complexity on the basis of the semantic tree. + * + * @author akashdeep.bansal4@gmail.com (Akashdeep Bansal) + */ + +goog.provide('sre.SemanticComplexity'); + +goog.require('sre.SemanticAnnotator') + +sre.SemanticComplexity.complexity = function(node) { + let complexity = 0; + switch (node.type) { + case sre.SemanticAttr.Type.INFIXOP: + for (var i=0; i streeDepth) + streeDepth = depth+1; + }}; + return streeDepth; +}; + +sre.SemanticComplexity.streeDepth = function() { + return new sre.SemanticAnnotator( + 'streeDepth', + function(node) { + return sre.SemanticComplexity.depth(node);}); +}; \ No newline at end of file diff --git a/src/speech_rules/clearspeak_rules.js b/src/speech_rules/clearspeak_rules.js index 40c0de8ef..eae4b2807 100644 --- a/src/speech_rules/clearspeak_rules.js +++ b/src/speech_rules/clearspeak_rules.js @@ -26,7 +26,7 @@ goog.require('sre.Grammar'); goog.require('sre.MathStore'); goog.require('sre.MathspeakUtil'); goog.require('sre.StoreUtil'); - +goog.require('sre.SemanticComplexity'); /** @@ -101,7 +101,9 @@ sre.ClearspeakRules.addAnnotators_ = function() { sre.SemanticAnnotations.getInstance().register( sre.ClearspeakUtil.simpleExpression()); sre.SemanticAnnotations.getInstance().register( - sre.ClearspeakUtil.aakash()); + sre.SemanticComplexity.streeComplexity()); + sre.SemanticAnnotations.getInstance().register( + sre.SemanticComplexity.streeDepth()); sre.SemanticAnnotations.getInstance().register( sre.ClearspeakUtil.unitExpression()); }; diff --git a/src/speech_rules/clearspeak_util.js b/src/speech_rules/clearspeak_util.js index 3863e9f90..d177db266 100644 --- a/src/speech_rules/clearspeak_util.js +++ b/src/speech_rules/clearspeak_util.js @@ -98,154 +98,6 @@ sre.ClearspeakUtil.isSimpleExpression = function(node) { sre.ClearspeakUtil.isSimpleFunction_(node); }; -sre.ClearspeakUtil.complexity = function(node) { - let complexity = 0; - switch (node.type) { - case sre.SemanticAttr.Type.INFIXOP: - for (var i=0; i Date: Tue, 17 Dec 2019 17:56:49 +0000 Subject: [PATCH 3/6] added subtreeNodeCount, subtreeTermsHeight, and subtreeTermsNodeCount --- src/semantic_tree/semantic_complexity.js | 89 +++++++++++++++++++++--- src/speech_rules/clearspeak_rules.js | 8 ++- 2 files changed, 85 insertions(+), 12 deletions(-) diff --git a/src/semantic_tree/semantic_complexity.js b/src/semantic_tree/semantic_complexity.js index d021e4076..56d1c98d4 100644 --- a/src/semantic_tree/semantic_complexity.js +++ b/src/semantic_tree/semantic_complexity.js @@ -179,23 +179,90 @@ sre.SemanticComplexity.streeComplexity = function() { return sre.SemanticComplexity.complexity(node);}); }; -sre.SemanticComplexity.depth = function(node) { - let streeDepth = 0; - var depth = 0; +sre.SemanticComplexity.height = function(node) { + let subtreeHeight = 0; + var height = 0; if (node.childNodes.length < 1) - streeDepth = 1; + subtreeHeight = 1; else { for (var i=0; i streeDepth) - streeDepth = depth+1; + height = node.childNodes[i].annotation.subtreeHeight[0]; + if (height > subtreeHeight) + subtreeHeight = height+1; }}; - return streeDepth; + return subtreeHeight; }; -sre.SemanticComplexity.streeDepth = function() { +sre.SemanticComplexity.subtreeHeight = function() { return new sre.SemanticAnnotator( - 'streeDepth', + 'subtreeHeight', function(node) { - return sre.SemanticComplexity.depth(node);}); + return sre.SemanticComplexity.height(node);}); +}; + +sre.SemanticComplexity.nodeCount = function(node) { + var subtreeNodeCount = 0; + var nodeCount = 0; + if (node.childNodes.length < 1) + subtreeNodeCount = 1; + else { + for (var i=0; i subtreeTermsHeight) { + if (node.type === sre.SemanticAttr.Type.INFIXOP && node.role === 'implicit') + subtreeTermsHeight = termsHeight; + else + subtreeTermsHeight = termsHeight+1; + }; + }}; + return subtreeTermsHeight; +}; + +sre.SemanticComplexity.subtreeTermsHeight = function() { + return new sre.SemanticAnnotator( + 'subtreeTermsHeight', + function(node) { + return sre.SemanticComplexity.termsHeight(node);}); +}; + +sre.SemanticComplexity.termsNodeCount = function(node) { + var subtreeTermsNodeCount = 0; + var termsNodeCount = 0; + if (node.childNodes.length < 1) + subtreeTermsNodeCount = 1; + else if (node.type === sre.SemanticAttr.Type.INFIXOP && node.role === 'implicit') + subtreeTermsNodeCount = 1; + else { + for (var i=0; i Date: Wed, 18 Dec 2019 23:47:58 +0000 Subject: [PATCH 4/6] Adds speech output to semantic tree --- src/semantic_tree/semantic_complexity.js | 15 ++++++++++++++- src/speech_rules/clearspeak_rules.js | 2 ++ 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/src/semantic_tree/semantic_complexity.js b/src/semantic_tree/semantic_complexity.js index 56d1c98d4..8a214dc28 100644 --- a/src/semantic_tree/semantic_complexity.js +++ b/src/semantic_tree/semantic_complexity.js @@ -265,4 +265,17 @@ sre.SemanticComplexity.subtreeTermsNodeCount = function() { 'subtreeTermsNodeCount', function(node) { return sre.SemanticComplexity.termsNodeCount(node);}); -}; \ No newline at end of file +}; + +sre.SemanticComplexity.speech = function() { + return new sre.SemanticAnnotator( + 'MathSpeakSpeech', + function(node) { + var xml = sre.DomUtil.parseInput(''); + var xmlRoot = node.xml(xml.ownerDocument); + var descrs = sre.SpeechGeneratorUtil.computeSpeech(/**@type{!Node}*/(xmlRoot)); + var aural = sre.AuralRendering.getInstance(); + var text = aural.finalize(aural.markup(descrs)); + console.log(text); + return text; + })}; \ No newline at end of file diff --git a/src/speech_rules/clearspeak_rules.js b/src/speech_rules/clearspeak_rules.js index 50a0cb806..6dad82556 100644 --- a/src/speech_rules/clearspeak_rules.js +++ b/src/speech_rules/clearspeak_rules.js @@ -102,6 +102,8 @@ sre.ClearspeakRules.addAnnotators_ = function() { sre.ClearspeakUtil.simpleExpression()); sre.SemanticAnnotations.getInstance().register( sre.SemanticComplexity.streeComplexity()); + sre.SemanticAnnotations.getInstance().register( + sre.SemanticComplexity.speech()); sre.SemanticAnnotations.getInstance().register( sre.SemanticComplexity.subtreeHeight()); sre.SemanticAnnotations.getInstance().register( From f11b2340c5c746714be1a7f0ad71771b1aeabcb1 Mon Sep 17 00:00:00 2001 From: Akashdeep Bansal Date: Fri, 27 Dec 2019 11:44:14 +0000 Subject: [PATCH 5/6] Adds different operator counters --- src/semantic_tree/semantic_complexity.js | 135 ++++++++++++++++++++++- src/speech_rules/clearspeak_rules.js | 4 + 2 files changed, 135 insertions(+), 4 deletions(-) diff --git a/src/semantic_tree/semantic_complexity.js b/src/semantic_tree/semantic_complexity.js index 8a214dc28..5ce52d73a 100644 --- a/src/semantic_tree/semantic_complexity.js +++ b/src/semantic_tree/semantic_complexity.js @@ -22,13 +22,22 @@ goog.provide('sre.SemanticComplexity'); goog.require('sre.SemanticAnnotator') +///** +// * A function which computes the complexity at a node on the basis of the //various +// * parameters such as nodeType, nodeHeight, nodeCount, nodeTermsHeight, +// * nodeTermsCount, speechLegth, No. of different types of operators in the +// * subtree, etc. +// * @param (sre.SemanticNode) node The semantic node. +// * @return (Integer) A numerical value representing the relative complexity at +// * the given node. +// */ + sre.SemanticComplexity.complexity = function(node) { let complexity = 0; switch (node.type) { case sre.SemanticAttr.Type.INFIXOP: for (var i=0; i'); var xmlRoot = node.xml(xml.ownerDocument); var descrs = sre.SpeechGeneratorUtil.computeSpeech(/**@type{!Node}*/(xmlRoot)); var aural = sre.AuralRendering.getInstance(); var text = aural.finalize(aural.markup(descrs)); - console.log(text); return text; - })}; \ No newline at end of file + })}; + +/** + * @return {sre.SemanticAnnotator} A semantic annotator for word count in the + * speech string. + */ + +sre.SemanticComplexity.speechWordCount = function() { + return new sre.SemanticAnnotator( + 'SpeechWordCount', + function(node) { + const len = node.annotation.speech[0].split(' ').length; + return len; + }) +}; + +/** + * @return {sre.SemanticAnnotator} A semantic annotator for word count in the + * speech string. + */ + +sre.SemanticComplexity.speechOperatorCounter = function() { + return new sre.SemanticAnnotator( + 'OperatorCounters', + function(node) { + const words = node.annotation.speech[0].split(' '); + var PlusCounter = 0; + var MinusCounter = 0; + var SupCounter = 0; + var SquCounter = 0; + var CubeCounter = 0; + var FracCounter = 0; + var RootCounter = 0; + var BracketCounter = 0; + var BraceCounter = 0; + var ParenthesisCounter = 0; + var ImplicitMultiCounter = 0; + var ExplicitMultiCounter = 0; + var ChancesOfError = 0; + for(var i=0; i < words.length; i++){ + switch (words[i]){ + case 'plus': + PlusCounter += 1; + break; + case 'minus': + MinusCounter += 1; + break; + case 'negative': + MinusCounter += 1; + break; + case 'StartFraction': + FracCounter += 1; + break; + case 'StartRoot': + RootCounter += 1; + break; + case 'Baseline': + ChancesOfError += 1; + break; + case 'Superscript': + SupCounter += 1; + break; + case 'squared': + SquCounter += 1; + break; + case 'cubed': + CubeCounter += 1; + break; + case 'left-bracket': + BracketCounter += 1; + break; + case 'left-brace': + BraceCounter += 1; + break; + case 'left-parenthesis': + ParenthesisCounter += 1; + break; + case 'times': + ExplicitMultiCounter += 1; + break; + default: + if (i < (words.length)-1){ + if ((words[i]).length === 1){ + if ((words[i+1]).length === 1) + ImplicitMultiCounter += 1; + }}};// ExplicitMulti, and paranthesis + }; + return [PlusCounter, MinusCounter, FracCounter, RootCounter, ChancesOfError, SupCounter, SquCounter, CubeCounter, ExplicitMultiCounter, BracketCounter, BraceCounter, ParenthesisCounter, ImplicitMultiCounter]; + }) +}; \ No newline at end of file diff --git a/src/speech_rules/clearspeak_rules.js b/src/speech_rules/clearspeak_rules.js index 6dad82556..4b1dbda97 100644 --- a/src/speech_rules/clearspeak_rules.js +++ b/src/speech_rules/clearspeak_rules.js @@ -112,6 +112,10 @@ sre.ClearspeakRules.addAnnotators_ = function() { sre.SemanticComplexity.subtreeTermsHeight()); sre.SemanticAnnotations.getInstance().register( sre.SemanticComplexity.subtreeTermsNodeCount()); + sre.SemanticAnnotations.getInstance().register( + sre.SemanticComplexity.speechWordCount()); + sre.SemanticAnnotations.getInstance().register( + sre.SemanticComplexity.speechOperatorCounter()); sre.SemanticAnnotations.getInstance().register( sre.ClearspeakUtil.unitExpression()); }; From 4d7ba31742f591a903c44b85b39ea64666a35537 Mon Sep 17 00:00:00 2001 From: Akashdeep Bansal Date: Wed, 11 Mar 2020 18:49:50 +0530 Subject: [PATCH 6/6] Slash fraction handling --- src/common/system_external.js | 2 +- src/semantic_tree/semantic_complexity.js | 8 ++++++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/common/system_external.js b/src/common/system_external.js index ec005a502..aba13688a 100644 --- a/src/common/system_external.js +++ b/src/common/system_external.js @@ -92,7 +92,7 @@ sre.SystemExternal.xpath = sre.SystemExternal.documentSupported() ? var wgx = sre.SystemExternal.require('wicked-good-xpath'); wgx.install(window); window.document.XPathResult = window.XPathResult; - return window.document; + return window.document; }(); diff --git a/src/semantic_tree/semantic_complexity.js b/src/semantic_tree/semantic_complexity.js index 5ce52d73a..bb41d21c1 100644 --- a/src/semantic_tree/semantic_complexity.js +++ b/src/semantic_tree/semantic_complexity.js @@ -348,6 +348,7 @@ sre.SemanticComplexity.speechOperatorCounter = function() { var SquCounter = 0; var CubeCounter = 0; var FracCounter = 0; + var SlashCounter = 0; var RootCounter = 0; var BracketCounter = 0; var BraceCounter = 0; @@ -369,6 +370,9 @@ sre.SemanticComplexity.speechOperatorCounter = function() { case 'StartFraction': FracCounter += 1; break; + case 'slash': + SlashCounter += 1; + break; case 'StartRoot': RootCounter += 1; break; @@ -401,8 +405,8 @@ sre.SemanticComplexity.speechOperatorCounter = function() { if ((words[i]).length === 1){ if ((words[i+1]).length === 1) ImplicitMultiCounter += 1; - }}};// ExplicitMulti, and paranthesis + }}};//paranthesis and Chances of Errors }; - return [PlusCounter, MinusCounter, FracCounter, RootCounter, ChancesOfError, SupCounter, SquCounter, CubeCounter, ExplicitMultiCounter, BracketCounter, BraceCounter, ParenthesisCounter, ImplicitMultiCounter]; + return [PlusCounter, MinusCounter, FracCounter, RootCounter, ChancesOfError, SupCounter, SquCounter+CubeCounter, ExplicitMultiCounter, BracketCounter, BraceCounter, ParenthesisCounter, ImplicitMultiCounter, SlashCounter, FracCounter+SlashCounter]; }) }; \ No newline at end of file