math-exercises 1.1.1 → 1.2.0

package/src/tree/latexParser/latexParse.ts

@@ -1,7 +1,8 @@
+import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
 import { Node, NodeType } from "../nodes/node";
-import { OperatorNode } from "../nodes/operators/operatorNode";
+import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
 
-export function latexParse(node: Node | null): string {
+export function latexParse(node: Node): string {
   if (!node) {
     console.log("parsing a null node ???");
     return "";
@@ -12,67 +13,112 @@ export function latexParse(node: Node | null): string {
     case NodeType.number:
       return node.tex;
     case NodeType.operator:
-      let rightTex = latexParse(node.rightChild);
-      let leftTex = latexParse(node.leftChild);
-      const { leftChild, rightChild } = node;
-      switch (node.id) {
-        case "add":
+      const operatorNode = node as OperatorNode;
+      let rightTex = latexParse(operatorNode.rightChild);
+      let leftTex = latexParse(operatorNode.leftChild);
+      const { leftChild, rightChild } = operatorNode;
+      switch (operatorNode.id) {
+        case OperatorIds.add:
           return `${leftTex} ${rightTex[0] === "-" ? "" : "+ "}${rightTex}`;
 
-        case "opposite":
+        case OperatorIds.substract: {
           const needBrackets =
-            leftChild!.id === "add" ||
-            leftChild!.id === "substract" ||
-            leftTex[0] === "-";
-          if (needBrackets) leftTex = `(${leftTex})`;
-          return `-${leftTex}`;
-
-        case "substract": {
-          const needBrackets =
-            rightChild!.id === "add" ||
-            rightChild!.id === "substract" ||
+            (rightChild.type === NodeType.operator &&
+              [OperatorIds.add, OperatorIds.substract].includes((rightChild as OperatorNode).id)) ||
             rightTex[0] === "-";
+
           if (needBrackets) rightTex = `(${rightTex})`;
+
           return `${leftTex} - ${rightTex}`;
         }
 
-        case "multiply": {
-          if (leftChild!.id === "add" || leftChild!.id === "substract")
-            leftTex = `(${leftTex})`;
-          const needBrackets =
-            rightChild!.id === "add" ||
-            rightChild!.id === "substract" ||
-            rightTex[0] === "-";
+        case OperatorIds.multiply: {
+          if (leftChild.type === NodeType.operator) {
+            if ([OperatorIds.add, OperatorIds.substract, OperatorIds.divide].includes((leftChild as OperatorNode).id))
+              leftTex = `(${leftTex})`;
+          }
+          let needBrackets = rightTex[0] === "-";
+          if (rightChild.type === NodeType.operator) {
+            const operatorRightChild = rightChild as OperatorNode;
+            needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
+          }
           if (needBrackets) rightTex = `(${rightTex})`;
-          const showTimesSign = !isNaN(+rightTex[0]); //permet de gérer le cas 3*2^x
+
+          //  permet de gérer le cas 3*2^x
+          let showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === NodeType.number;
+          if (rightChild.type === NodeType.operator) {
+            const operatorRightChild = rightChild as OperatorNode;
+            showTimesSign ||= [OperatorIds.fraction].includes(operatorRightChild.id);
+          }
           return `${leftTex}${showTimesSign ? "\\times " : ""}${rightTex}`;
         }
 
-        case "divide": {
+        case OperatorIds.divide: {
+          if (leftChild.type === NodeType.operator) {
+            if ([OperatorIds.add, OperatorIds.substract, OperatorIds.multiply].includes((leftChild as OperatorNode).id))
+              leftTex = `(${leftTex})`;
+          }
+          let needBrackets = rightTex[0] === "-";
+          if (rightChild.type === NodeType.operator) {
+            const operatorRightChild = rightChild as OperatorNode;
+            needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
+          }
+          if (needBrackets) rightTex = `(${rightTex})`;
+
+          //  permet de gérer le cas 3*2^x
+          let showTimesSign = !isNaN(+rightTex[0]);
+          if (rightChild.type === NodeType.operator) {
+            const operatorRightChild = rightChild as OperatorNode;
+            showTimesSign ||= [OperatorIds.fraction].includes(operatorRightChild.id);
+          }
+          return `${leftTex}${showTimesSign ? "\\div " : ""}${rightTex}`;
+        }
+
+        case OperatorIds.fraction: {
           return `\\frac{${leftTex}}{${rightTex}}`;
         }
 
-        case "power": {
-          if (
-            leftChild!.id === "add" ||
-            leftChild!.id === "substract" ||
-            leftChild!.id === "multiply"
-          )
-            leftTex = `(${leftTex})`;
+        case OperatorIds.power: {
+          let needBrackets = leftTex[0] === "-";
+          if (leftChild.type === NodeType.operator) {
+            const childOperator = leftChild as OperatorNode;
+            needBrackets ||= [
+              OperatorIds.add,
+              OperatorIds.substract,
+              OperatorIds.multiply,
+              OperatorIds.divide,
+              OperatorIds.fraction,
+              OperatorIds.power,
+            ].includes(childOperator.id);
+          }
+          if (needBrackets) leftTex = `(${leftTex})`;
           return `${leftTex}^{${rightTex}}`;
         }
 
-        case "equal": {
+        case OperatorIds.equal: {
           return `${leftTex} = ${rightTex}`;
         }
         default:
           return node.tex;
       }
+
     case NodeType.function: {
-      let leftTex = latexParse(node.leftChild);
-      switch (node.id) {
-        case "sqrt": {
-          return `\\sqrt{${leftTex}}`;
+      const functionNode = node as FunctionNode;
+      const child = functionNode.child;
+      let childTex = latexParse(functionNode.child);
+      switch (functionNode.id) {
+        case FunctionsIds.sqrt: {
+          return `\\sqrt{${childTex}}`;
+        }
+
+        case FunctionsIds.opposite: {
+          let needBrackets = childTex[0] === "-";
+          if (child.type === NodeType.operator) {
+            const operatorChild = child as OperatorNode;
+            needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorChild.id);
+          }
+          if (needBrackets) childTex = `(${childTex})`;
+          return `-${childTex}`;
         }
       }
     }

package/src/tree/nodes/functions/functionNode.js

@@ -0,0 +1,19 @@
+"use strict";
+exports.__esModule = true;
+exports.FunctionNode = exports.FunctionsIds = void 0;
+var node_1 = require("../node");
+var FunctionsIds;
+(function (FunctionsIds) {
+    FunctionsIds[FunctionsIds["opposite"] = 0] = "opposite";
+    FunctionsIds[FunctionsIds["sqrt"] = 1] = "sqrt";
+})(FunctionsIds = exports.FunctionsIds || (exports.FunctionsIds = {}));
+var FunctionNode = /** @class */ (function () {
+    function FunctionNode(id, child, tex) {
+        this.type = node_1.NodeType["function"];
+        this.id = id;
+        this.child = child;
+        this.tex = tex;
+    }
+    return FunctionNode;
+}());
+exports.FunctionNode = FunctionNode;

package/src/tree/nodes/functions/functionNode.ts

@@ -0,0 +1,18 @@
+import { Node, NodeType } from "../node";
+
+export enum FunctionsIds {
+  opposite,
+  sqrt,
+}
+
+export abstract class FunctionNode implements Node {
+  id: FunctionsIds;
+  child: Node;
+  type = NodeType.function;
+  tex: string;
+  constructor(id: FunctionsIds, child: Node, tex: string) {
+    this.id = id;
+    this.child = child;
+    this.tex = tex;
+  }
+}

package/src/tree/nodes/functions/oppositeNode.js

@@ -0,0 +1,30 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.OppositeNode = void 0;
+var functionNode_1 = require("./functionNode");
+var OppositeNode = /** @class */ (function (_super) {
+    __extends(OppositeNode, _super);
+    function OppositeNode(child) {
+        return _super.call(this, functionNode_1.FunctionsIds.opposite, child, "-") || this;
+    }
+    OppositeNode.prototype.toString = function () {
+        return "-(".concat(this.child, ")");
+    };
+    return OppositeNode;
+}(functionNode_1.FunctionNode));
+exports.OppositeNode = OppositeNode;

package/src/tree/nodes/functions/oppositeNode.ts

@@ -0,0 +1,12 @@
+import { Node, NodeType } from "../node";
+import { OperatorNode } from "../operators/operatorNode";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+
+export class OppositeNode extends FunctionNode {
+  constructor(child: Node) {
+    super(FunctionsIds.opposite, child, "-");
+  }
+  toString(): string {
+    return `-(${this.child})`;
+  }
+}

package/src/tree/nodes/functions/sqrtNode.js

@@ -1,18 +1,33 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 exports.__esModule = true;
 exports.SqrtNode = void 0;
 var node_1 = require("../node");
-var SqrtNode = /** @class */ (function () {
-    function SqrtNode(leftChild) {
-        this.type = node_1.NodeType["function"];
-        this.id = "sqrt";
-        this.tex = "\\sqrt";
-        this.leftChild = leftChild;
-        this.rightChild = null;
+var functionNode_1 = require("./functionNode");
+var SqrtNode = /** @class */ (function (_super) {
+    __extends(SqrtNode, _super);
+    function SqrtNode(child) {
+        var _this = _super.call(this, functionNode_1.FunctionsIds.sqrt, child, "\\sqrt") || this;
+        _this.type = node_1.NodeType["function"];
+        return _this;
     }
     SqrtNode.prototype.toString = function () {
-        return "sqrt(".concat(this.leftChild, ")");
+        return "sqrt(".concat(this.child, ")");
     };
     return SqrtNode;
-}());
+}(functionNode_1.FunctionNode));
 exports.SqrtNode = SqrtNode;

package/src/tree/nodes/functions/sqrtNode.ts

@@ -1,16 +1,12 @@
 import { Node, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
 
-export class SqrtNode implements Node {
-  leftChild: Node;
-  rightChild: null;
+export class SqrtNode extends FunctionNode {
   type: NodeType = NodeType.function;
-  id: string = "sqrt";
-  tex = "\\sqrt";
-  constructor(leftChild: Node) {
-    this.leftChild = leftChild;
-    this.rightChild = null;
+  constructor(child: Node) {
+    super(FunctionsIds.sqrt, child, "\\sqrt");
   }
   toString(): string {
-    return `sqrt(${this.leftChild})`;
+    return `sqrt(${this.child})`;
   }
 }

package/src/tree/nodes/node.ts

@@ -8,7 +8,5 @@ export enum NodeType {
 export interface Node {
   type: NodeType;
   tex: string;
-  id: string;
-  leftChild: Node | null;
-  rightChild: Node | null;
+  toString: () => string;
 }

package/src/tree/nodes/numbers/numberNode.js

@@ -3,13 +3,10 @@ exports.__esModule = true;
 exports.NumberNode = void 0;
 var node_1 = require("../node");
 var NumberNode = /** @class */ (function () {
-    function NumberNode(value) {
-        this.id = "number";
-        this.leftChild = null;
-        this.rightChild = null;
-        this.value = value;
-        this.tex = value + "";
+    function NumberNode(value, tex) {
         this.type = node_1.NodeType.number;
+        this.value = value;
+        this.tex = tex || value + "";
     }
     NumberNode.prototype.toString = function () {
         return "".concat(this.tex);

package/src/tree/nodes/numbers/numberNode.ts

@@ -3,14 +3,11 @@ import { Node, NodeType } from "../node";
 export class NumberNode implements Node {
   tex: string;
   value: number;
-  type: NodeType;
-  id = "number";
-  leftChild = null;
-  rightChild = null;
-  constructor(value: number) {
+  type: NodeType = NodeType.number;
+
+  constructor(value: number, tex?: string) {
     this.value = value;
-    this.tex = value + "";
-    this.type = NodeType.number;
+    this.tex = tex || value + "";
   }
 
   toString(): string {

package/src/tree/nodes/operators/addNode.js

@@ -1,18 +1,33 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 exports.__esModule = true;
 exports.AddNode = void 0;
-var node_1 = require("../node");
-var AddNode = /** @class */ (function () {
+var operatorNode_1 = require("./operatorNode");
+var AddNode = /** @class */ (function (_super) {
+    __extends(AddNode, _super);
     function AddNode(leftChild, rightChild) {
-        this.type = node_1.NodeType.operator;
-        this.id = "add";
-        this.tex = "+";
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
+        var _this = _super.call(this, operatorNode_1.OperatorIds.add, leftChild, rightChild, true, "+") || this;
+        _this.leftChild = leftChild;
+        _this.rightChild = rightChild;
+        return _this;
     }
     AddNode.prototype.toString = function () {
         return "".concat(this.leftChild, " + ").concat(this.rightChild);
     };
     return AddNode;
-}());
+}(operatorNode_1.OperatorNode));
 exports.AddNode = AddNode;

package/src/tree/nodes/operators/addNode.ts

@@ -1,13 +1,9 @@
 import { Node, NodeType } from "../node";
-import { OperatorNode } from "./operatorNode";
+import { OperatorIds, OperatorNode } from "./operatorNode";
 
-export class AddNode implements Node, OperatorNode {
-  leftChild: Node;
-  rightChild: Node;
-  type: NodeType = NodeType.operator;
-  id: string = "add";
-  tex = "+";
+export class AddNode extends OperatorNode {
   constructor(leftChild: Node, rightChild: Node) {
+    super(OperatorIds.add, leftChild, rightChild, true, "+");
     this.leftChild = leftChild;
     this.rightChild = rightChild;
   }

package/src/tree/nodes/operators/divideNode.js

@@ -1,22 +1,34 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 exports.__esModule = true;
 exports.DivideNode = void 0;
-var node_1 = require("../node");
-var DivideNode = /** @class */ (function () {
+var operatorNode_1 = require("./operatorNode");
+var DivideNode = /** @class */ (function (_super) {
+    __extends(DivideNode, _super);
     /**
      * @param leftChild num
      * @param rightChild denum
      */
     function DivideNode(leftChild, rightChild) {
-        this.type = node_1.NodeType.operator;
-        this.id = "divide";
-        this.tex = "\\frac";
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
+        return _super.call(this, operatorNode_1.OperatorIds.divide, leftChild, rightChild, false, "\\div") || this;
     }
     DivideNode.prototype.toString = function () {
-        return "\\frac{".concat(this.leftChild, "}{").concat(this.rightChild, "}");
+        return "(".concat(this.leftChild, ") \\div (").concat(this.rightChild, ")");
     };
     return DivideNode;
-}());
+}(operatorNode_1.OperatorNode));
 exports.DivideNode = DivideNode;

package/src/tree/nodes/operators/divideNode.ts

@@ -1,23 +1,16 @@
 import { Node, NodeType } from "../node";
-import { OperatorNode } from "./operatorNode";
-
-export class DivideNode implements Node, OperatorNode {
-  leftChild: Node;
-  rightChild: Node;
-  type: NodeType = NodeType.operator;
-  id: string = "divide";
-  tex = "\\frac";
+import { OperatorIds, OperatorNode } from "./operatorNode";
 
+export class DivideNode extends OperatorNode {
   /**
    * @param leftChild num
    * @param rightChild denum
    */
   constructor(leftChild: Node, rightChild: Node) {
-    this.leftChild = leftChild;
-    this.rightChild = rightChild;
+    super(OperatorIds.divide, leftChild, rightChild, false, "\\div");
   }
 
   toString(): string {
-    return `\\frac{${this.leftChild}}{${this.rightChild}}`;
+    return `(${this.leftChild}) \\div (${this.rightChild})`;
   }
 }

package/src/tree/nodes/operators/equalNode.js

@@ -1,18 +1,30 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 exports.__esModule = true;
 exports.EqualNode = void 0;
-var node_1 = require("../node");
-var EqualNode = /** @class */ (function () {
+var operatorNode_1 = require("./operatorNode");
+var EqualNode = /** @class */ (function (_super) {
+    __extends(EqualNode, _super);
     function EqualNode(leftChild, rightChild) {
-        this.type = node_1.NodeType.operator;
-        this.id = "equal";
-        this.tex = "=";
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
+        return _super.call(this, operatorNode_1.OperatorIds.equal, leftChild, rightChild, true, "=") || this;
     }
     EqualNode.prototype.toString = function () {
         return "".concat(this.leftChild, " = ").concat(this.rightChild);
     };
     return EqualNode;
-}());
+}(operatorNode_1.OperatorNode));
 exports.EqualNode = EqualNode;

package/src/tree/nodes/operators/equalNode.ts

@@ -1,15 +1,9 @@
 import { Node, NodeType } from "../node";
-import { OperatorNode } from "./operatorNode";
+import { OperatorIds, OperatorNode } from "./operatorNode";
 
-export class EqualNode implements Node, OperatorNode {
-  leftChild: Node;
-  rightChild: Node;
-  type: NodeType = NodeType.operator;
-  id: string = "equal";
-  tex = "=";
+export class EqualNode extends OperatorNode {
   constructor(leftChild: Node, rightChild: Node) {
-    this.leftChild = leftChild;
-    this.rightChild = rightChild;
+    super(OperatorIds.equal, leftChild, rightChild, true, "=");
   }
   toString(): string {
     return `${this.leftChild} = ${this.rightChild}`;

package/src/tree/nodes/operators/fractionNode.js

@@ -0,0 +1,34 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.FractionNode = void 0;
+var operatorNode_1 = require("./operatorNode");
+var FractionNode = /** @class */ (function (_super) {
+    __extends(FractionNode, _super);
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    function FractionNode(leftChild, rightChild) {
+        return _super.call(this, operatorNode_1.OperatorIds.fraction, leftChild, rightChild, false, "\\frac") || this;
+    }
+    FractionNode.prototype.toString = function () {
+        return "\\frac{".concat(this.leftChild, "}{").concat(this.rightChild, "}");
+    };
+    return FractionNode;
+}(operatorNode_1.OperatorNode));
+exports.FractionNode = FractionNode;

package/src/tree/nodes/operators/fractionNode.ts

@@ -0,0 +1,16 @@
+import { Node, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
+
+export class FractionNode extends OperatorNode {
+  /**
+   * @param leftChild num
+   * @param rightChild denum
+   */
+  constructor(leftChild: Node, rightChild: Node) {
+    super(OperatorIds.fraction, leftChild, rightChild, false, "\\frac");
+  }
+
+  toString(): string {
+    return `\\frac{${this.leftChild}}{${this.rightChild}}`;
+  }
+}

package/src/tree/nodes/operators/multiplyNode.js

@@ -1,18 +1,30 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 exports.__esModule = true;
 exports.MultiplyNode = void 0;
-var node_1 = require("../node");
-var MultiplyNode = /** @class */ (function () {
+var operatorNode_1 = require("./operatorNode");
+var MultiplyNode = /** @class */ (function (_super) {
+    __extends(MultiplyNode, _super);
     function MultiplyNode(leftChild, rightChild) {
-        this.type = node_1.NodeType.operator;
-        this.id = "multiply";
-        this.tex = "\\times";
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
+        return _super.call(this, operatorNode_1.OperatorIds.multiply, leftChild, rightChild, true, "\\times") || this;
     }
     MultiplyNode.prototype.toString = function () {
         return "(".concat(this.leftChild, ")*(").concat(this.rightChild, ")");
     };
     return MultiplyNode;
-}());
+}(operatorNode_1.OperatorNode));
 exports.MultiplyNode = MultiplyNode;