diff --git a/sample.mml b/sample.mml
new file mode 100644
index 000000000..854ec245e
--- /dev/null
+++ b/sample.mml
@@ -0,0 +1,27 @@
+
\ No newline at end of file
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
new file mode 100644
index 000000000..bb41d21c1
--- /dev/null
+++ b/src/semantic_tree/semantic_complexity.js
@@ -0,0 +1,412 @@
+// 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')
+
+///**
+// * 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 subtreeHeight)
+ subtreeHeight = height+1;
+ }};
+ return subtreeHeight;
+};
+
+/**
+ * @return {sre.SemanticAnnotator} A semantic annotator for height function.
+ */
+
+sre.SemanticComplexity.subtreeHeight = function() {
+ return new sre.SemanticAnnotator(
+ 'subtreeHeight',
+ function(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;
+};
+
+/**
+ * @return {sre.SemanticAnnotator} A semantic annotator for termsHeight function.
+ */
+
+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');
+ 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));
+ return text;
+ })};
+
+/**
+ * @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 SlashCounter = 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 'slash':
+ SlashCounter += 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;
+ }}};//paranthesis and Chances of Errors
+ };
+ return [PlusCounter, MinusCounter, FracCounter, RootCounter, ChancesOfError, SupCounter, SquCounter+CubeCounter, ExplicitMultiCounter, BracketCounter, BraceCounter, ParenthesisCounter, ImplicitMultiCounter, SlashCounter, FracCounter+SlashCounter];
+ })
+};
\ No newline at end of file
diff --git a/src/speech_rules/clearspeak_rules.js b/src/speech_rules/clearspeak_rules.js
index b8fe72e2e..4b1dbda97 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');
/**
@@ -100,6 +100,22 @@ var addCTXF = sre.ClearspeakRules.addContextFunction_;
sre.ClearspeakRules.addAnnotators_ = function() {
sre.SemanticAnnotations.getInstance().register(
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(
+ sre.SemanticComplexity.subtreeNodeCount());
+ sre.SemanticAnnotations.getInstance().register(
+ 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());
};
diff --git a/src/speech_rules/clearspeak_util.js b/src/speech_rules/clearspeak_util.js
index 69b848f8e..d177db266 100644
--- a/src/speech_rules/clearspeak_util.js
+++ b/src/speech_rules/clearspeak_util.js
@@ -289,7 +289,6 @@ sre.ClearspeakUtil.simpleExpression = function() {
return sre.ClearspeakUtil.isSimpleExpression(node) ? 'simple' : ''; });
};
-
/**
* Decides if node has markup of simple node in clearspeak.
* @param {Node} node The node in question.