math-exercises 2.0.1 → 2.0.2

package/lib/tree/nodes/functions/cosNode.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CosNode = void 0;
+exports.CosNode = exports.isCosNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
-class CosNode extends functionNode_1.FunctionNode {
+function isCosNode(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.cos;
+}
+exports.isCosNode = isCosNode;
+class CosNode {
     constructor(child) {
-        super(functionNode_1.FunctionsIds.cos, child, '\\cos');
+        this.id = functionNode_1.FunctionsIds.opposite;
+        this.child = child;
         this.type = node_1.NodeType.function;
     }
     toMathString() {

package/lib/tree/nodes/functions/expNode.d.ts

@@ -1,12 +1,13 @@
-import { Node, NodeType } from '../node';
-import { FunctionNode } from './functionNode';
-type ExpNodeOptions = {
-    useExpNotation: boolean;
-};
-export declare class ExpNode extends FunctionNode implements Node {
-    opts?: ExpNodeOptions;
+import { Node, NodeOptions, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isExpNode(a: Node): a is ExpNode;
+export declare class ExpNode implements FunctionNode {
+    opts?: NodeOptions;
+    id: FunctionsIds;
+    child: AlgebraicNode;
     type: NodeType;
-    constructor(child: Node, opts?: ExpNodeOptions);
+    constructor(child: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toTex(): string;
     toMathjs(): number;
@@ -14,5 +15,4 @@ export declare class ExpNode extends FunctionNode implements Node {
     toAllValidTexs(): string[];
     simplify(): Node;
 }
-export {};
 //# sourceMappingURL=expNode.d.ts.map

package/lib/tree/nodes/functions/expNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/expNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAE5D,KAAK,cAAc,GAAG;IACpB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,qBAAa,OAAQ,SAAQ,YAAa,YAAW,IAAI;IACvD,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,IAAI,EAAE,QAAQ,CAAqB;gBAEvB,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,cAAc;IAK9C,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IASf,QAAQ;IAIR,iBAAiB,IAAI,IAAI,EAAE;IAU3B,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,IAAI,IAAI;CAGjB"}
+{"version":3,"file":"expNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/expNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;gBACH,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAYf,QAAQ;IAIR,iBAAiB,IAAI,IAAI,EAAE;IAU3B,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,IAAI,IAAI;CAGjB"}

package/lib/tree/nodes/functions/expNode.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpNode = void 0;
+exports.ExpNode = exports.isExpNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
-class ExpNode extends functionNode_1.FunctionNode {
+function isExpNode(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.exp;
+}
+exports.isExpNode = isExpNode;
+class ExpNode {
     constructor(child, opts) {
-        super(functionNode_1.FunctionsIds.exp, child, '\\exp');
+        this.id = functionNode_1.FunctionsIds.exp;
+        this.child = child;
         this.type = node_1.NodeType.function;
         this.opts = opts;
     }
@@ -15,12 +20,15 @@ class ExpNode extends functionNode_1.FunctionNode {
     }
     toTex() {
         const tex = this.child.toTex();
+        if (!this.opts?.allowPowerOne && tex === "1") {
+            return "e";
+        }
         if (this.opts?.useExpNotation) {
-            return `exp\\left(${this.child.toTex}\\right)`;
+            return `\\exp\\left(${tex}\\right)`;
         }
         const needBraces = tex.length > 1;
         if (needBraces)
-            return `e^{${this.child.toTex()}}`;
+            return `e^{${tex}}`;
         return `e^${tex}`;
     }
     toMathjs() {

package/lib/tree/nodes/functions/functionNode.d.ts

@@ -1,17 +1,17 @@
-import { Node, NodeType } from '../node';
+import { AlgebraicNode } from "../algebraicNode";
+import { Node } from "../node";
+export declare function isFunctionNode(a: Node): a is FunctionNode;
 export declare enum FunctionsIds {
     opposite = 0,
     sqrt = 1,
     cos = 2,
     sin = 3,
     log = 4,
-    exp = 5
+    exp = 5,
+    abs = 6
 }
-export declare abstract class FunctionNode {
+export interface FunctionNode extends AlgebraicNode {
     id: FunctionsIds;
-    child: Node;
-    type: NodeType;
-    tex: string;
-    constructor(id: FunctionsIds, child: Node, tex: string);
+    child: AlgebraicNode;
 }
 //# sourceMappingURL=functionNode.d.ts.map

package/lib/tree/nodes/functions/functionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/functionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzC,oBAAY,YAAY;IACtB,QAAQ,IAAA;IACR,IAAI,IAAA;IACJ,GAAG,IAAA;IACH,GAAG,IAAA;IACH,GAAG,IAAA;IACH,GAAG,IAAA;CACJ;AAED,8BAAsB,YAAY;IAChC,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,IAAI,CAAC;IACZ,IAAI,WAAqB;IACzB,GAAG,EAAE,MAAM,CAAC;gBACA,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM;CAKvD"}
+{"version":3,"file":"functionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/functionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AAEzC,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,oBAAY,YAAY;IACtB,QAAQ,IAAA;IACR,IAAI,IAAA;IACJ,GAAG,IAAA;IACH,GAAG,IAAA;IACH,GAAG,IAAA;IACH,GAAG,IAAA;IACH,GAAG,IAAA;CACJ;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;CAOtB"}

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

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionNode = exports.FunctionsIds = void 0;
+exports.FunctionsIds = exports.isFunctionNode = void 0;
 const node_1 = require("../node");
+function isFunctionNode(a) {
+    return a.type === node_1.NodeType.function;
+}
+exports.isFunctionNode = isFunctionNode;
 var FunctionsIds;
 (function (FunctionsIds) {
     FunctionsIds[FunctionsIds["opposite"] = 0] = "opposite";
@@ -10,13 +14,5 @@ var FunctionsIds;
     FunctionsIds[FunctionsIds["sin"] = 3] = "sin";
     FunctionsIds[FunctionsIds["log"] = 4] = "log";
     FunctionsIds[FunctionsIds["exp"] = 5] = "exp";
+    FunctionsIds[FunctionsIds["abs"] = 6] = "abs";
 })(FunctionsIds = exports.FunctionsIds || (exports.FunctionsIds = {}));
-class FunctionNode {
-    constructor(id, child, tex) {
-        this.type = node_1.NodeType.function;
-        this.id = id;
-        this.child = child;
-        this.tex = tex;
-    }
-}
-exports.FunctionNode = FunctionNode;

package/lib/tree/nodes/functions/logNode.d.ts

@@ -1,8 +1,13 @@
-import { Node, NodeType } from '../node';
-import { FunctionNode } from './functionNode';
-export declare class LogNode extends FunctionNode implements Node {
+import { Node, NodeOptions, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isLogNode(a: Node): a is LogNode;
+export declare class LogNode implements FunctionNode {
+    id: FunctionsIds;
+    child: AlgebraicNode;
     type: NodeType;
-    constructor(child: Node);
+    opts?: NodeOptions;
+    constructor(child: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toTex(): string;
     toMathjs(): any;

package/lib/tree/nodes/functions/logNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/logNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAE5D,qBAAa,OAAQ,SAAQ,YAAa,YAAW,IAAI;IACvD,IAAI,EAAE,QAAQ,CAAqB;gBAEvB,KAAK,EAAE,IAAI;IAIvB,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAIR,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,IAAI;CAGjB"}
+{"version":3,"file":"logNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/logNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IASf,QAAQ;IAIR,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,IAAI,IAAI;CAGjB"}

package/lib/tree/nodes/functions/logNode.js

@@ -1,19 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogNode = void 0;
+exports.LogNode = exports.isLogNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
-class LogNode extends functionNode_1.FunctionNode {
-    constructor(child) {
-        super(functionNode_1.FunctionsIds.log, child, '\\ln');
+const absNode_1 = require("./absNode");
+function isLogNode(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.log;
+}
+exports.isLogNode = isLogNode;
+class LogNode {
+    constructor(child, opts) {
+        this.id = functionNode_1.FunctionsIds.opposite;
+        this.child = child;
         this.type = node_1.NodeType.function;
+        this.opts = opts;
     }
     toMathString() {
         return `log(${this.child.toMathString()})`;
     }
     toTex() {
-        return `\\ln\\left(${this.child.toTex()}\\right)`;
+        const tex = this.child.toTex();
+        if (!this.opts?.allowLnOfOne && tex === "1") {
+            return "0";
+        }
+        const shouldntUseBrackets = (0, absNode_1.isAbsNode)(this.child);
+        if (shouldntUseBrackets)
+            return `\\ln${tex}`;
+        else
+            return `\\ln\\left(${tex}\\right)`;
     }
     toMathjs() {
         return (0, mathjs_1.log)(this.child.toMathjs());

package/lib/tree/nodes/functions/oppositeNode.d.ts

@@ -1,11 +1,22 @@
-import { Node } from '../node';
-import { FunctionNode } from './functionNode';
-export declare class OppositeNode extends FunctionNode implements Node {
-    constructor(child: Node);
+import { Node, NodeOptions, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isOppositeNode(a: Node): a is OppositeNode;
+export declare class OppositeNode implements FunctionNode {
+    id: FunctionsIds;
+    child: AlgebraicNode;
+    type: NodeType;
+    opts?: NodeOptions;
+    constructor(child: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toTex(): string;
-    toEquivalentNodes(): Node[];
-    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
+    /**
+     * start opposite node
+     * find all external child of multiply and fraction nodes
+     * add opposite to them
+     */
+    toAllValidTexs(opts?: NodeOptions): string[];
     toMathjs(): number;
 }
 //# sourceMappingURL=oppositeNode.d.ts.map

package/lib/tree/nodes/functions/oppositeNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAG5D,qBAAa,YAAa,SAAQ,YAAa,YAAW,IAAI;gBAChD,KAAK,EAAE,IAAI;IAGvB,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAcf,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ;CAGT"}
+{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAGD,qBAAa,YAAa,YAAW,YAAY;IAC/C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAMpD,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAqCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,QAAQ;CAGT"}

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

@@ -1,41 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OppositeNode = void 0;
+exports.OppositeNode = exports.isOppositeNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const operatorNode_1 = require("../operators/operatorNode");
 const functionNode_1 = require("./functionNode");
-class OppositeNode extends functionNode_1.FunctionNode {
-    constructor(child) {
-        super(functionNode_1.FunctionsIds.opposite, child, '-');
+const numberNode_1 = require("../numbers/numberNode");
+function isOppositeNode(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.opposite;
+}
+exports.isOppositeNode = isOppositeNode;
+const getEquivalentTrees = (root) => { };
+class OppositeNode {
+    constructor(child, opts) {
+        this.id = functionNode_1.FunctionsIds.opposite;
+        this.child = child;
+        this.type = node_1.NodeType.function;
+        this.opts = opts;
     }
     toMathString() {
         return `-(${this.child.toMathString()})`;
     }
     toTex() {
         let childTex = this.child.toTex();
-        let needBrackets = childTex[0] === '-';
-        if (this.child.type === node_1.NodeType.operator) {
-            const operatorChild = this.child;
-            needBrackets ||= [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorChild.id);
+        let needBrackets = childTex[0] === "-";
+        if ((0, operatorNode_1.isOperatorNode)(this.child)) {
+            needBrackets ||= [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.child.id);
         }
-        if (this.child.type === node_1.NodeType.number && childTex[0] === '-') {
+        if ((0, numberNode_1.isNumberNode)(this.child) && childTex[0] === "-") {
             return childTex.substring(1);
         }
         if (needBrackets)
-            childTex = `(${childTex})`;
+            childTex = `\\left(${childTex}\\right)`;
         return `-${childTex}`;
     }
-    toEquivalentNodes() {
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
         const res = [];
-        const childNodes = this.child.toEquivalentNodes();
+        const externalNodes = [];
+        //! est ce qu'il faut faire ici des simplifications du type -ln(2) => 1/ln(2)
+        //! ou meme -(a+b) => -a - b
+        // if (isMultiplyNode(this.child))
+        //   res.push(
+        //     ...new MultiplyNode(
+        //       new OppositeNode(this.child.leftChild),
+        //       this.child.rightChild,
+        //     ).toEquivalentNodes(options),
+        //   );
+        // else if (isDivideNode(this.child))
+        //   res.push(
+        //     ...new DivideNode(
+        //       new OppositeNode(this.child.leftChild),
+        //       this.child.rightChild,
+        //     ).toEquivalentNodes(options),
+        //   );
+        // else if (isFractionNode(this.child))
+        //   res.push(
+        //     ...new FractionNode(
+        //       new OppositeNode(this.child.leftChild),
+        //       this.child.rightChild,
+        //     ).toEquivalentNodes(options),
+        //   );
+        // else {
+        const childNodes = this.child.toEquivalentNodes(options);
         childNodes.forEach((childNode) => {
             res.push(new OppositeNode(childNode));
         });
+        // }
         return res;
     }
-    toAllValidTexs() {
-        return this.toEquivalentNodes().map((node) => node.toTex());
+    /**
+     * start opposite node
+     * find all external child of multiply and fraction nodes
+     * add opposite to them
+     */
+    toAllValidTexs(opts) {
+        const options = opts ?? this.opts;
+        return this.toEquivalentNodes(options).map((node) => node.toTex());
     }
     toMathjs() {
         return (0, mathjs_1.unaryMinus)(this.child.toMathjs());

package/lib/tree/nodes/functions/sinNode.d.ts

@@ -1,8 +1,12 @@
-import { Node, NodeType } from '../node';
-import { FunctionNode } from './functionNode';
-export declare class SinNode extends FunctionNode implements Node {
+import { Node, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isSinNode(a: Node): a is SinNode;
+export declare class SinNode implements FunctionNode {
+    id: FunctionsIds;
+    child: AlgebraicNode;
     type: NodeType;
-    constructor(child: Node);
+    constructor(child: AlgebraicNode);
     toMathString(): string;
     toTex(): string;
     toMathjs(): number;

package/lib/tree/nodes/functions/sinNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sinNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sinNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAE5D,qBAAa,OAAQ,SAAQ,YAAa,YAAW,IAAI;IACvD,IAAI,EAAE,QAAQ,CAAqB;gBAEvB,KAAK,EAAE,IAAI;IAIvB,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAGR,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,IAAI,IAAI;CAGjB"}
+{"version":3,"file":"sinNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sinNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;gBAEH,KAAK,EAAE,aAAa;IAMhC,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAGR,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,IAAI,IAAI;CAGjB"}

package/lib/tree/nodes/functions/sinNode.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SinNode = void 0;
+exports.SinNode = exports.isSinNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
-class SinNode extends functionNode_1.FunctionNode {
+function isSinNode(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.sin;
+}
+exports.isSinNode = isSinNode;
+class SinNode {
     constructor(child) {
-        super(functionNode_1.FunctionsIds.sin, child, '\\sin');
+        this.id = functionNode_1.FunctionsIds.opposite;
+        this.child = child;
         this.type = node_1.NodeType.function;
     }
     toMathString() {

package/lib/tree/nodes/functions/sqrtNode.d.ts

@@ -1,12 +1,17 @@
-import { Node, NodeType } from '../node';
-import { FunctionNode } from './functionNode';
-export declare class SqrtNode extends FunctionNode implements Node {
+import { Node, NodeOptions, NodeType } from "../node";
+import { FunctionNode, FunctionsIds } from "./functionNode";
+import { AlgebraicNode } from "../algebraicNode";
+export declare function isSqrtNode(a: Node): a is SqrtNode;
+export declare class SqrtNode implements FunctionNode {
+    id: FunctionsIds;
+    child: AlgebraicNode;
     type: NodeType;
-    constructor(child: Node);
+    opts?: NodeOptions;
+    constructor(child: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toMathjs(): number | import("mathjs").Complex;
     toTex(): string;
-    toEquivalentNodes(): Node[];
+    toEquivalentNodes(opts?: NodeOptions): Node[];
     toAllValidTexs(): string[];
 }
 //# sourceMappingURL=sqrtNode.d.ts.map

package/lib/tree/nodes/functions/sqrtNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAE5D,qBAAa,QAAS,SAAQ,YAAa,YAAW,IAAI;IACxD,IAAI,EAAE,QAAQ,CAAqB;gBACvB,KAAK,EAAE,IAAI;IAGvB,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,KAAK,IAAI,MAAM;IAIf,iBAAiB,IAAI,IAAI,EAAE;IAS3B,cAAc,IAAI,MAAM,EAAE;CAG3B"}
+{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AACD,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAMpD,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,EAAE;IAwB7C,cAAc,IAAI,MAAM,EAAE;CAG3B"}

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

@@ -1,13 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqrtNode = void 0;
+exports.SqrtNode = exports.isSqrtNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
-class SqrtNode extends functionNode_1.FunctionNode {
-    constructor(child) {
-        super(functionNode_1.FunctionsIds.sqrt, child, '\\sqrt');
+const real_1 = require("../../../math/numbers/reals/real");
+const numberNode_1 = require("../numbers/numberNode");
+const multiplyNode_1 = require("../operators/multiplyNode");
+const isInt_1 = require("../../../utils/isInt");
+function isSqrtNode(a) {
+    return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.sqrt;
+}
+exports.isSqrtNode = isSqrtNode;
+class SqrtNode {
+    constructor(child, opts) {
+        this.id = functionNode_1.FunctionsIds.sqrt;
+        this.child = child;
         this.type = node_1.NodeType.function;
+        this.opts = opts;
     }
     toMathString() {
         return `sqr(${this.child.toMathString()})`;
@@ -18,12 +28,23 @@ class SqrtNode extends functionNode_1.FunctionNode {
     toTex() {
         return `\\sqrt{${this.child.toTex()}}`;
     }
-    toEquivalentNodes() {
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
         const res = [];
         const childNodes = this.child.toEquivalentNodes();
         childNodes.forEach((childNode) => {
             res.push(new SqrtNode(childNode));
         });
+        if (options?.allowSimplifySqrt && (0, numberNode_1.isNumberNode)(this.child)) {
+            const sqrt = new real_1.SquareRoot(this.child.value);
+            const coeffs = sqrt.getSimplifiedCoeffs();
+            if ((0, isInt_1.isInt)(Math.sqrt(coeffs[1]))) {
+                res.push(new numberNode_1.NumberNode(coeffs[0]));
+            }
+            else if (coeffs[0] !== 1) {
+                res.push(...new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(coeffs[0]), new SqrtNode(new numberNode_1.NumberNode(coeffs[1]))).toEquivalentNodes());
+            }
+        }
         return res;
     }
     toAllValidTexs() {

package/lib/tree/nodes/geometry/lengthNode.d.ts

@@ -0,0 +1,14 @@
+import { AlgebraicNode } from "../algebraicNode";
+import { NodeOptions, NodeType } from "../node";
+export declare class LengthNode implements AlgebraicNode {
+    opts?: NodeOptions | undefined;
+    segmentName: string;
+    type: NodeType;
+    constructor(segmentName: string, opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): LengthNode[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+//# sourceMappingURL=lengthNode.d.ts.map

package/lib/tree/nodes/geometry/lengthNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lengthNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/geometry/lengthNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEhD,qBAAa,UAAW,YAAW,aAAa;IAC9C,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,QAAQ,CAAC;gBAEH,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW;IASnD,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAOpC,YAAY;IAGZ,QAAQ;IAIR,KAAK;CAGN"}

package/lib/tree/nodes/geometry/lengthNode.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LengthNode = void 0;
+const node_1 = require("../node");
+class LengthNode {
+    constructor(segmentName, opts) {
+        this.type = node_1.NodeType.mesure;
+        this.opts = opts;
+        this.segmentName = segmentName;
+    }
+    //   toAllTexs() {
+    //     return [this.segmentName, this.segmentName.split("").reverse().join()];
+    //   }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).flatMap((node) => node.toTex());
+    }
+    toEquivalentNodes(opts) {
+        return [
+            this,
+            new LengthNode(this.segmentName.split("").reverse().join("")),
+        ];
+    }
+    toMathString() {
+        return this.toTex();
+    }
+    toMathjs() {
+        return this.toTex();
+    }
+    toTex() {
+        return this.segmentName;
+    }
+}
+exports.LengthNode = LengthNode;

package/lib/tree/nodes/geometry/pointNode.d.ts

@@ -0,0 +1,15 @@
+import { Point } from "../../../math/geometry/point";
+import { Node, NodeOptions, NodeType } from "../node";
+export declare class PointNode implements Node {
+    opts?: NodeOptions | undefined;
+    point: Point;
+    type: NodeType;
+    constructor(point: Point, opts?: NodeOptions);
+    toAllTexs(): string[];
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): PointNode[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+//# sourceMappingURL=pointNode.d.ts.map

package/lib/tree/nodes/geometry/pointNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/geometry/pointNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAElD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEtD,qBAAa,SAAU,YAAW,IAAI;IACpC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC;gBAEH,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,WAAW;IAM5C,SAAS;IAGT,cAAc;IAMd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAepC,YAAY;IAGZ,QAAQ;IAIR,KAAK;CAGN"}

package/lib/tree/nodes/geometry/pointNode.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointNode = void 0;
+const point_1 = require("../../../math/geometry/point");
+const cartesianProducts_1 = require("../../../utils/cartesianProducts");
+const node_1 = require("../node");
+class PointNode {
+    constructor(point, opts) {
+        this.type = node_1.NodeType.point;
+        this.opts = opts;
+        this.point = point;
+    }
+    toAllTexs() {
+        return [this.point.toTexWithCoords(), this.point.toCoords()];
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).flatMap((node) => node.toAllTexs());
+    }
+    toEquivalentNodes(opts) {
+        const res = [];
+        const equivs = [
+            this.point.x.toEquivalentNodes(opts),
+            this.point.y.toEquivalentNodes(opts),
+        ];
+        const cartesians = (0, cartesianProducts_1.getCartesiansProducts)(equivs);
+        cartesians.forEach((product) => {
+            res.push(new PointNode(new point_1.Point(this.point.name, product[0], product[1]), opts));
+        });
+        return res;
+    }
+    toMathString() {
+        return this.toTex();
+    }
+    toMathjs() {
+        return this.toTex();
+    }
+    toTex() {
+        return this.point.toTexWithCoords();
+    }
+}
+exports.PointNode = PointNode;

package/lib/tree/nodes/geometry/vectorNode.d.ts

@@ -0,0 +1,14 @@
+import { AlgebraicNode } from "../algebraicNode";
+import { NodeOptions, NodeType } from "../node";
+export declare class VectorNode implements AlgebraicNode {
+    opts?: NodeOptions | undefined;
+    name: string;
+    type: NodeType;
+    constructor(name: string, opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): this[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+//# sourceMappingURL=vectorNode.d.ts.map

package/lib/tree/nodes/geometry/vectorNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectorNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/geometry/vectorNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEhD,qBAAa,UAAW,YAAW,aAAa;IAC9C,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC;gBAEH,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW;IAS5C,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAIpC,YAAY;IAGZ,QAAQ;IAIR,KAAK;CAGN"}