math-exercises 1.1.0 → 1.2.0

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;

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

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

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

@@ -1,2 +1,37 @@
 "use strict";
 exports.__esModule = true;
+exports.OperatorNode = exports.OperatorIds = void 0;
+var coin_1 = require("../../../utils/coin");
+var node_1 = require("../node");
+var OperatorIds;
+(function (OperatorIds) {
+    OperatorIds[OperatorIds["add"] = 0] = "add";
+    OperatorIds[OperatorIds["substract"] = 1] = "substract";
+    OperatorIds[OperatorIds["multiply"] = 2] = "multiply";
+    OperatorIds[OperatorIds["fraction"] = 3] = "fraction";
+    OperatorIds[OperatorIds["divide"] = 4] = "divide";
+    OperatorIds[OperatorIds["power"] = 5] = "power";
+    OperatorIds[OperatorIds["equal"] = 6] = "equal";
+})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
+var OperatorNode = /** @class */ (function () {
+    function OperatorNode(id, leftChild, rightChild, isCommutative, tex) {
+        this.type = node_1.NodeType.operator;
+        this.id = id;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.isCommutative = isCommutative;
+        this.tex = tex;
+    }
+    /**shuffles in place */
+    OperatorNode.prototype.shuffle = function () {
+        var _a;
+        if (!this.isCommutative)
+            return this;
+        if ((0, coin_1.coin)())
+            return this;
+        _a = [this.rightChild, this.leftChild], this.leftChild = _a[0], this.rightChild = _a[1];
+        return this;
+    };
+    return OperatorNode;
+}());
+exports.OperatorNode = OperatorNode;

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

@@ -1,3 +1,36 @@
-export interface OperatorNode {
-  id: string;
+import { coin } from "../../../utils/coin";
+import { Node, NodeType } from "../node";
+
+export enum OperatorIds {
+  add,
+  substract,
+  multiply,
+  fraction,
+  divide,
+  power,
+  equal,
+}
+
+export abstract class OperatorNode implements Node {
+  id: OperatorIds;
+  leftChild: Node;
+  rightChild: Node;
+  isCommutative: boolean;
+  type = NodeType.operator;
+  tex: string;
+  constructor(id: OperatorIds, leftChild: Node, rightChild: Node, isCommutative: boolean, tex: string) {
+    this.id = id;
+    this.leftChild = leftChild;
+    this.rightChild = rightChild;
+    this.isCommutative = isCommutative;
+    this.tex = tex;
+  }
+
+  /**shuffles in place */
+  shuffle(): Node {
+    if (!this.isCommutative) return this;
+    if (coin()) return this;
+    [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+    return this;
+  }
 }

package/src/tree/nodes/operators/powerNode.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.PowerNode = void 0;
-var node_1 = require("../node");
-var PowerNode = /** @class */ (function () {
+var operatorNode_1 = require("./operatorNode");
+var PowerNode = /** @class */ (function (_super) {
+    __extends(PowerNode, _super);
     function PowerNode(leftChild, rightChild) {
-        this.tex = "^";
-        this.type = node_1.NodeType.operator;
-        this.id = "power";
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
+        return _super.call(this, operatorNode_1.OperatorIds.power, leftChild, rightChild, false, "^") || this;
     }
     PowerNode.prototype.toString = function () {
         return "(".concat(this.leftChild, ")^{").concat(this.rightChild, "}");
     };
     return PowerNode;
-}());
+}(operatorNode_1.OperatorNode));
 exports.PowerNode = PowerNode;

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

@@ -1,14 +1,9 @@
 import { Node, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
 
-export class PowerNode implements Node {
-  tex = "^";
-  type = NodeType.operator;
-  id = "power";
-  leftChild: Node;
-  rightChild: Node;
+export class PowerNode extends OperatorNode {
   constructor(leftChild: Node, rightChild: Node) {
-    this.leftChild = leftChild;
-    this.rightChild = rightChild;
+    super(OperatorIds.power, leftChild, rightChild, false, "^");
   }
 
   toString(): string {