math-exercises 2.0.0 → 2.0.2

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"}

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

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

package/lib/tree/nodes/inequations/inequationNode.d.ts

@@ -0,0 +1,21 @@
+import { Node, NodeOptions, NodeType } from "../node";
+import { IntervalNode } from "../sets/intervalNode";
+export type InegalitySymbols = "<" | ">" | "\\le" | "\\ge";
+export declare const getInversedInequationSymbol: (s: InegalitySymbols) => InegalitySymbols;
+export declare class InequationNode implements Node {
+    opts?: NodeOptions | undefined;
+    type: NodeType;
+    tex: string;
+    children: Node[];
+    symbols: InegalitySymbols[];
+    constructor(children: Node[], symbols: InegalitySymbols[] | InegalitySymbols);
+    toInterval(): IntervalNode;
+    toReversed(): InequationNode;
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions | undefined): InequationNode[];
+    toMathString(): string;
+    toMathjs(): string;
+    toAllTexs(): string[];
+    toTex(): string;
+}
+//# sourceMappingURL=inequationNode.d.ts.map

package/lib/tree/nodes/inequations/inequationNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inequationNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,EAAe,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEjE,MAAM,MAAM,gBAAgB,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3D,eAAO,MAAM,2BAA2B,MACnC,gBAAgB,KAClB,gBAWF,CAAC;AAEF,qBAAa,cAAe,YAAW,IAAI;IACzC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,IAAI,EAAE,CAAC;IACjB,OAAO,EAAE,gBAAgB,EAAE,CAAC;gBAE1B,QAAQ,EAAE,IAAI,EAAE,EAChB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAwBhD,UAAU;IA6CV,UAAU;IAMV,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,QAAQ;IAGR,SAAS;IAGT,KAAK;CAGN"}

package/lib/tree/nodes/inequations/inequationNode.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InequationNode = exports.getInversedInequationSymbol = void 0;
+const cartesianProducts_1 = require("../../../utils/cartesianProducts");
+const isLetter_1 = require("../../../utils/isLetter");
+const node_1 = require("../node");
+const infiniteNode_1 = require("../numbers/infiniteNode");
+const intervalNode_1 = require("../sets/intervalNode");
+const getInversedInequationSymbol = (s) => {
+    switch (s) {
+        case "<":
+            return ">";
+        case ">":
+            return "<";
+        case "\\ge":
+            return "\\le";
+        case "\\le":
+            return "\\ge";
+    }
+};
+exports.getInversedInequationSymbol = getInversedInequationSymbol;
+class InequationNode {
+    constructor(children, symbols) {
+        if (children.length < 2)
+            throw Error("can't build inequality with unique child");
+        if (Array.isArray(symbols) && symbols.length !== children.length - 1)
+            throw Error("symbols not in adequation with children");
+        this.children = children;
+        this.symbols = Array.isArray(symbols)
+            ? symbols
+            : this.children.slice(1).map((el) => symbols);
+        this.tex = "";
+        for (let i = 0; i < children.length; i++) {
+            this.tex += children[i].toTex();
+            if (i < children.length - 1) {
+                const shouldAddSpace = (this.symbols[i] === "\\le" || this.symbols[i] === "\\ge") &&
+                    (0, isLetter_1.isLetter)(children[i + 1].toTex());
+                this.tex += `${this.symbols[i]}${shouldAddSpace ? " " : ""}`;
+            }
+        }
+        this.type = node_1.NodeType.inequation;
+    }
+    toInterval() {
+        if (this.children.length > 3)
+            throw Error("can't build interval with this inequality");
+        if (this.children.length === 3) {
+            const closure = this.symbols[0] === "<"
+                ? this.symbols[1] === "<"
+                    ? intervalNode_1.ClosureType.OO
+                    : intervalNode_1.ClosureType.OF
+                : this.symbols[1] === "<"
+                    ? intervalNode_1.ClosureType.FO
+                    : intervalNode_1.ClosureType.FF;
+            return new intervalNode_1.IntervalNode(this.children[0], this.children[2], closure);
+        }
+        else {
+            let leftIsInf = false;
+            let rightIsInf = false;
+            let closure;
+            switch (this.symbols[0]) {
+                case "<":
+                    closure = intervalNode_1.ClosureType.OO;
+                    leftIsInf = true;
+                    break;
+                case ">":
+                    closure = intervalNode_1.ClosureType.OO;
+                    rightIsInf = true;
+                    break;
+                case "\\le":
+                    closure = intervalNode_1.ClosureType.OF;
+                    leftIsInf = true;
+                    break;
+                case "\\ge":
+                    closure = intervalNode_1.ClosureType.FO;
+                    rightIsInf = true;
+                    break;
+                default:
+                    throw Error("unrecognized inequation type");
+            }
+            return new intervalNode_1.IntervalNode(leftIsInf ? infiniteNode_1.MinusInfinityNode : this.children[1], rightIsInf ? infiniteNode_1.PlusInfinityNode : this.children[1], closure);
+        }
+    }
+    toReversed() {
+        const newChildren = [...this.children].reverse();
+        const newSymbols = this.symbols.map(exports.getInversedInequationSymbol);
+        return new InequationNode(newChildren, newSymbols);
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    toEquivalentNodes(opts) {
+        const equivs = this.children.map((node) => node.toEquivalentNodes());
+        const cartesians = (0, cartesianProducts_1.getCartesiansProducts)(equivs);
+        const nodes = [];
+        cartesians.forEach((product) => {
+            const newNode = new InequationNode(product, this.symbols);
+            const reversed = newNode.toReversed();
+            nodes.push(newNode);
+            nodes.push(reversed);
+        });
+        return nodes;
+    }
+    toMathString() {
+        return this.tex;
+    }
+    toMathjs() {
+        return this.tex;
+    }
+    toAllTexs() {
+        return [this.toTex()];
+    }
+    toTex() {
+        return this.tex;
+    }
+}
+exports.InequationNode = InequationNode;

package/lib/tree/nodes/inequations/inequationSolutionNode.d.ts

@@ -0,0 +1,21 @@
+import { Node, NodeOptions, NodeType } from "../node";
+import { IntervalNode } from "../sets/intervalNode";
+type InequationSolutionNodeOptions = {
+    variable?: string;
+    opts?: NodeOptions;
+};
+export declare class InequationSolutionNode implements Node {
+    type: NodeType;
+    variable: string;
+    intervalSolution: IntervalNode;
+    opts?: NodeOptions;
+    constructor(intervalSolution: IntervalNode, params?: InequationSolutionNodeOptions);
+    toAllTexs(): string[];
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): (import("./inequationNode").InequationNode | InequationSolutionNode)[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+export {};
+//# sourceMappingURL=inequationSolutionNode.d.ts.map

package/lib/tree/nodes/inequations/inequationSolutionNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inequationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,KAAK,6BAA6B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC/E,qBAAa,sBAAuB,YAAW,IAAI;IACjD,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,YAAY,CAAC;IAC/B,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,gBAAgB,EAAE,YAAY,EAC9B,MAAM,CAAC,EAAE,6BAA6B;IAcxC,SAAS;IAUT,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAQpC,YAAY;IAGZ,QAAQ;IAGR,KAAK;CAGN"}

package/lib/tree/nodes/inequations/inequationSolutionNode.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InequationSolutionNode = void 0;
+const node_1 = require("../node");
+class InequationSolutionNode {
+    constructor(intervalSolution, params) {
+        this.type = node_1.NodeType.set;
+        this.intervalSolution = intervalSolution;
+        this.variable = params?.variable ?? "x";
+        this.opts = params?.opts
+            ? {
+                ...params.opts,
+                allowRawRightChildAsSolution: params.opts.allowRawRightChildAsSolution ?? true,
+            }
+            : { allowRawRightChildAsSolution: true };
+    }
+    toAllTexs() {
+        const intervalTex = this.intervalSolution.toTex();
+        const res = [
+            this.toTex(),
+            this.intervalSolution.toTex(),
+            `${this.variable}\\in${intervalTex}`,
+        ];
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).flatMap((el) => el.toAllTexs());
+    }
+    toEquivalentNodes(opts) {
+        const equivs = this.intervalSolution.toEquivalentNodes(opts ?? this.opts);
+        return equivs.flatMap((equiv) => [
+            new InequationSolutionNode(equiv, { variable: this.variable, opts }),
+            ...equiv.toInequality().toEquivalentNodes(),
+        ]);
+    }
+    toMathString() {
+        return "";
+    }
+    toMathjs() {
+        return `S={${this.intervalSolution.toMathjs()}}`;
+    }
+    toTex() {
+        return `S=${this.intervalSolution.toTex()}`;
+    }
+}
+exports.InequationSolutionNode = InequationSolutionNode;

package/lib/tree/nodes/node.d.ts

@@ -3,13 +3,32 @@ export declare enum NodeType {
     constant = 1,
     variable = 2,
     operator = 3,
-    function = 4
+    function = 4,
+    set = 5,
+    inequation = 6,
+    point = 7,
+    mesure = 8,
+    equality = 9,
+    belongs = 10,
+    vector = 11
 }
+export type NodeOptions = {
+    forceTimesSign?: boolean;
+    forbidPowerToProduct?: boolean;
+    allowRawRightChildAsSolution?: boolean;
+    allowFractionToDecimal?: boolean;
+    allowMinusAnywhereInFraction?: boolean;
+    useExpNotation?: boolean;
+    allowLnOfOne?: boolean;
+    allowPowerOne?: boolean;
+    allowSimplifySqrt?: boolean;
+};
 export interface Node {
     type: NodeType;
+    opts?: NodeOptions;
     toMathString: () => string;
-    toEquivalentNodes: () => Node[];
-    toAllValidTexs: () => string[];
+    toEquivalentNodes: (opts?: NodeOptions) => Node[];
+    toAllValidTexs: (opts?: NodeOptions) => string[];
     toTex: () => string;
     toMathjs: () => any;
 }

package/lib/tree/nodes/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;CACT;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAC;IAEf,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,iBAAiB,EAAE,MAAM,IAAI,EAAE,CAAC;IAChC,cAAc,EAAE,MAAM,MAAM,EAAE,CAAC;IAC/B,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,CAAC;CAErB"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,GAAG,IAAA;IACH,UAAU,IAAA;IACV,KAAK,IAAA;IACL,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,OAAO,KAAA;IACP,MAAM,KAAA;CACP;AACD,MAAM,MAAM,WAAW,GAAG;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AACF,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,EAAE,CAAC;IAClD,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,MAAM,EAAE,CAAC;IACjD,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,CAAC;CAErB"}