math-exercises 2.2.68 → 2.2.70

package/lib/tree/nodes/polynomials/trinomNode.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrinomNode = exports.TrinomNodeConstructor = void 0;
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const substractNode_1 = require("../../../tree/nodes/operators/substractNode");
+const oppositeNode_1 = require("../../../tree/nodes/functions/oppositeNode");
+const randint_1 = require("../../../math/utils/random/randint");
+const random_1 = require("../../../utils/alea/random");
+const node_1 = require("../../../tree/nodes/node");
+const nodeConstructor_1 = require("../../../tree/nodes/nodeConstructor");
+class TrinomNodeConstructor {
+    static random(aOpts, bOpts, cOpts) {
+        const a = (0, randint_1.randint)(aOpts?.min ?? -9, aOpts?.max ?? 10, aOpts?.excludes ?? [0]);
+        const b = (0, randint_1.randint)(bOpts?.min ?? -9, bOpts?.max ?? 10, bOpts?.excludes ?? []);
+        const c = (0, randint_1.randint)(cOpts?.min ?? -9, cOpts?.max ?? 10, cOpts?.excludes ?? []);
+        return new TrinomNode(a, b, c);
+    }
+    static randomCanonical(aOpts, alphaOpts, betaOpts) {
+        const a = aOpts?.from
+            ? (0, random_1.random)(aOpts.from)
+            : (0, randint_1.randint)(aOpts?.min ?? -9, aOpts?.max ?? 10, aOpts?.excludes ?? [0]);
+        const alpha = (0, randint_1.randint)(alphaOpts?.min ?? -9, alphaOpts?.max ?? 10, alphaOpts?.excludes ?? []);
+        const beta = (0, randint_1.randint)(betaOpts?.min ?? -9, betaOpts?.max ?? 10, betaOpts?.excludes ?? []);
+        const b = -2 * a * alpha;
+        const c = a * alpha ** 2 + beta;
+        return new TrinomNode(a, b, c);
+    }
+    static randomNiceRoots(nbOfRoots = 2) {
+        if (nbOfRoots === 0) {
+            //canonical +c
+            const a = (0, randint_1.randint)(-9, 10, [0]);
+            const root = (0, randint_1.randint)(-9, 10);
+            //a(x-root)^2 = ax^2 -2arootx + aroot^2
+            const c = a > 0 ? a * root ** 2 + (0, randint_1.randint)(1, 6) : a * root ** 2 - (0, randint_1.randint)(1, 6);
+            return new TrinomNode(a, -2 * a * root, c);
+        }
+        else if (nbOfRoots === 1) {
+            const a = (0, randint_1.randint)(-9, 10, [0]);
+            const root = (0, randint_1.randint)(-9, 10);
+            //a(x-root)^2 = ax^2 -2arootx + aroot^2
+            return new TrinomNode(a, -2 * a * root, a * root ** 2);
+        }
+        else {
+            const a = (0, randint_1.randint)(-9, 10, [0]);
+            const x1 = (0, randint_1.randint)(-9, 10, []);
+            const x2 = (0, randint_1.randint)(-9, 10, [x1]);
+            return new TrinomNode(a, -a * (x1 + x2), a * x1 * x2);
+        }
+    }
+    static fromCoeffs(coeffs) {
+        return new TrinomNode(coeffs[2], coeffs[1], coeffs[0]);
+    }
+    static fromIdentifiers(identifiers) {
+        return new TrinomNode(typeof identifiers.a === "number"
+            ? identifiers.a
+            : nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.a), typeof identifiers.b === "number"
+            ? identifiers.b
+            : nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.b), typeof identifiers.c === "number"
+            ? identifiers.c
+            : nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.c), identifiers.opts);
+    }
+}
+exports.TrinomNodeConstructor = TrinomNodeConstructor;
+class TrinomNode {
+    // roots: AlgebraicNode[];
+    constructor(a, b, c, opts) {
+        this.type = node_1.NodeType.trinom;
+        // super([c, b, a], opts?.variable ?? "x");
+        this.a = typeof a === "number" ? a.toTree() : a;
+        this.b = typeof b === "number" ? b.toTree() : b;
+        this.c = typeof c === "number" ? c.toTree() : c;
+        this.isNumeric = false;
+        this.variable = opts?.variable ?? "x";
+    }
+    getDelta() {
+        return (0, substractNode_1.substract)((0, powerNode_1.square)(this.b), (0, multiplyNode_1.multiply)(4, (0, multiplyNode_1.multiply)(this.a, this.c))).simplify();
+    }
+    //   getRoots() {
+    //     const delta = this.getDelta();
+    //     if (delta < 0) return [];
+    //     if (delta === 0) return [-this.b / (2 * this.a)];
+    //     return [
+    //       (-this.b - Math.sqrt(delta)) / (2 * this.a),
+    //       (-this.b + Math.sqrt(delta)) / (2 * this.a),
+    //     ].sort((a, b) => a - b);
+    //   }
+    derivative(varName) {
+        return (0, addNode_1.add)((0, multiplyNode_1.multiply)(2, (0, multiplyNode_1.multiply)(this.a, "x")), this.b);
+    }
+    equals(node) {
+        return this.toTree().equals(node);
+    }
+    evaluate(vars) {
+        return this.toTree().evaluate(vars);
+    }
+    toDetailedEvaluation(vars) {
+        return this.toTree().toDetailedEvaluation(vars);
+    }
+    simplify(opts) {
+        return this.toTree().simplify(opts);
+    }
+    toAllValidTexs(opts) {
+        return this.toTree().toAllValidTexs(opts);
+    }
+    toEquivalentNodes(opts) {
+        return this.toTree().toEquivalentNodes(opts);
+    }
+    toMathString() {
+        return this.toTree().toMathString();
+    }
+    getRoots() {
+        const delta = this.getDelta();
+        const deltaEv = delta.evaluate();
+        if (deltaEv < 0)
+            return [];
+        if (deltaEv === 0)
+            return [(0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(this.b), (0, multiplyNode_1.multiply)(2, this.a)).simplify()];
+        return [
+            (0, fractionNode_1.frac)((0, substractNode_1.substract)((0, oppositeNode_1.opposite)(this.b), (0, sqrtNode_1.sqrt)(delta)), (0, multiplyNode_1.multiply)(2, this.a)).simplify(),
+            (0, fractionNode_1.frac)((0, addNode_1.add)((0, oppositeNode_1.opposite)(this.b), (0, sqrtNode_1.sqrt)(delta)), (0, multiplyNode_1.multiply)(2, this.a)).simplify(),
+        ].sort((a, b) => a.evaluate() - b.evaluate());
+    }
+    toTree() {
+        const bEv = this.b.evaluate();
+        const cEv = this.c.evaluate();
+        const highMonom = (0, multiplyNode_1.multiply)(this.a, (0, powerNode_1.square)(this.variable));
+        const middleMonom = (0, multiplyNode_1.multiply)(this.b, this.variable);
+        if (!bEv && !cEv)
+            return highMonom;
+        if (!cEv)
+            return (0, addNode_1.add)(highMonom, middleMonom);
+        if (!bEv)
+            return (0, addNode_1.add)(highMonom, this.c);
+        return (0, addNode_1.add)(highMonom, (0, addNode_1.add)(middleMonom, this.c));
+    }
+    toTex() {
+        return this.toTree().toTex();
+    }
+    getCoeffs() {
+        return [this.c.evaluate(), this.b.evaluate(), this.a.evaluate()];
+    }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.trinom,
+            a: this.a.toIdentifiers(),
+            b: this.b.toIdentifiers(),
+            c: this.c.toIdentifiers(),
+            opts: { variable: this.variable },
+        };
+    }
+}
+exports.TrinomNode = TrinomNode;

package/lib/tree/nodes/variables/variableNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variableNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/variables/variableNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAElD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,WAAqB;IACzB,SAAS,EAAE,OAAO,CAAC;gBACP,IAAI,EAAE,MAAM;IAIxB,aAAa;;;;IAMb,KAAK,IAAI,MAAM;IAGf,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,cAAc;IAGd,iBAAiB;IAIjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAStC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAKxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAKxD"}
+{"version":3,"file":"variableNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/variables/variableNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAElD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,WAAqB;IACzB,SAAS,EAAE,OAAO,CAAC;gBACP,IAAI,EAAE,MAAM;IAIxB,aAAa;;;;IAMb,KAAK,IAAI,MAAM;IAGf,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,cAAc;IAGd,iBAAiB;IAIjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQtC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAKxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAKxD"}

package/lib/tree/nodes/variables/variableNode.js

@@ -36,7 +36,7 @@ class VariableNode {
     evaluate(vars) {
         const value = vars?.[this.name];
         if (value === undefined)
-            throw Error(`Can't evaluate variable ${this.name}`);
+            return Number.NaN;
         return value;
     }
     // simplify(): Node {

package/lib/tree/parsers/affineParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affineParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/affineParser.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,qKAqBzD,CAAC"}
+{"version":3,"file":"affineParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/affineParser.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,qKAuBzD,CAAC"}

package/lib/tree/parsers/affineParser.js

@@ -7,6 +7,7 @@ const latexParser_1 = require("./latexParser");
 const monomParser_1 = require("./monomParser");
 const affineParser = (ans, variable = "x") => {
     try {
+        //double parse, pas opti
         const monom = (0, monomParser_1.monomParser)(ans, { variable, maxDegree: 1 });
         if (monom)
             return monom;

package/lib/tree/parsers/discreteSetParser.d.ts

@@ -0,0 +1,3 @@
+import { AlgebraicNode } from "../nodes/algebraicNode";
+export declare const discreteSetParser: (str: string) => false | AlgebraicNode[];
+//# sourceMappingURL=discreteSetParser.d.ts.map

package/lib/tree/parsers/discreteSetParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discreteSetParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/discreteSetParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmB,MAAM,wBAAwB,CAAC;AAMxE,eAAO,MAAM,iBAAiB,QAAS,MAAM,4BAe5C,CAAC"}

package/lib/tree/parsers/discreteSetParser.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discreteSetParser = void 0;
+const latexParser_1 = require("./latexParser");
+const discreteSetParser = (str) => {
+    try {
+        const formated = str
+            .replace("S", "")
+            .replace("=", "")
+            .replace("\\left", "")
+            .replace("\\right", "")
+            .replace("\\{", "")
+            .replace("\\}", "");
+        const elements = formated.split(";").map((e) => (0, latexParser_1.parseAlgebraic)(e));
+        if (elements.some((e) => !e))
+            return false;
+        return elements;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.discreteSetParser = discreteSetParser;

package/lib/tree/parsers/equationSolutionParser.d.ts

@@ -1,3 +1,3 @@
 import { AlgebraicNode } from "../nodes/algebraicNode";
-export declare const equationSolutionParser: (str: string) => false | AlgebraicNode;
+export declare const equationSolutionParser: (str: string, variable?: string) => false | AlgebraicNode;
 //# sourceMappingURL=equationSolutionParser.d.ts.map

package/lib/tree/parsers/equationSolutionParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationSolutionParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/equationSolutionParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmB,MAAM,wBAAwB,CAAC;AAKxE,eAAO,MAAM,sBAAsB,QAAS,MAAM,0BAgBjD,CAAC"}
+{"version":3,"file":"equationSolutionParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/equationSolutionParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmB,MAAM,wBAAwB,CAAC;AAMxE,eAAO,MAAM,sBAAsB,QAAS,MAAM,6CAyBjD,CAAC"}

package/lib/tree/parsers/equationSolutionParser.js

@@ -3,19 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.equationSolutionParser = void 0;
 const algebraicNode_1 = require("../nodes/algebraicNode");
 const equalNode_1 = require("../nodes/equations/equalNode");
-const hasVariableNode_1 = require("../nodes/hasVariableNode");
+const variableNode_1 = require("../nodes/variables/variableNode");
 const latexParser_1 = require("./latexParser");
-const equationSolutionParser = (str) => {
+const equationSolutionParser = (str, variable = "x") => {
     try {
         const parsed = (0, latexParser_1.parseLatex)(str);
         if ((0, equalNode_1.isEqualNode)(parsed)) {
             const children = [parsed.leftChild, parsed.rightChild];
-            const scalar = children.find((e) => !(0, hasVariableNode_1.hasVariableNode)(e));
-            if (!scalar)
+            const varNode = (0, variableNode_1.isVariableNode)(parsed.leftChild)
+                ? 0
+                : (0, variableNode_1.isVariableNode)(parsed.rightChild)
+                    ? 1
+                    : undefined;
+            if (varNode === undefined)
+                return false;
+            if (children[varNode].name !== "x")
+                return false;
+            const scalar = children[(varNode + 1) % 2];
+            if (!(0, algebraicNode_1.isAlgebraicNode)(scalar) || !scalar.isNumeric)
                 return false;
             return scalar;
         }
         else if ((0, algebraicNode_1.isAlgebraicNode)(parsed)) {
+            if (!parsed.isNumeric)
+                return false;
             return parsed;
         }
         else {

package/lib/tree/parsers/latexParser.d.ts

@@ -2,6 +2,10 @@ import { AlgebraicNode } from "../nodes/algebraicNode";
 import { EqualNode } from "../nodes/equations/equalNode";
 import { InequationNode } from "../nodes/inequations/inequationNode";
 export declare const tokenize: (latex: string) => string[];
-export declare const parseAlgebraic: (latex: string) => AlgebraicNode;
+type ParserOptions = {
+    allowStartingPower?: boolean;
+};
+export declare const parseAlgebraic: (latex: string, opts?: ParserOptions) => AlgebraicNode;
 export declare const parseLatex: (latex: string) => AlgebraicNode | EqualNode | InequationNode;
+export {};
 //# sourceMappingURL=latexParser.d.ts.map

package/lib/tree/parsers/latexParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAGzD,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAkDrE,eAAO,MAAM,QAAQ,UAAW,MAAM,aA4BrC,CAAC;AAEF,eAAO,MAAM,cAAc,UAAW,MAAM,kBAa3C,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,+CA2CvC,CAAC"}
+{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAGzD,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAkDrE,eAAO,MAAM,QAAQ,UAAW,MAAM,aA4BrC,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AACF,eAAO,MAAM,cAAc,UAAW,MAAM,SAAS,aAAa,kBAyBjE,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,+CA2CvC,CAAC"}

package/lib/tree/parsers/latexParser.js

@@ -79,12 +79,26 @@ const tokenize = (latex) => {
     return tokens;
 };
 exports.tokenize = tokenize;
-const parseAlgebraic = (latex) => {
-    const formattedLatex = latex
+const parseAlgebraic = (latex, opts) => {
+    let formatedLatex = latex;
+    if (!opts?.allowStartingPower && latex.startsWith("^")) {
+        if (latex[1] === "{") {
+            const endIndex = latex.indexOf("}");
+            if (endIndex < 1)
+                formatedLatex = latex.slice(2, latex.length);
+            else
+                formatedLatex =
+                    latex.slice(2, endIndex) + latex.slice(endIndex + 1, latex.length);
+        }
+        else {
+            formatedLatex.replace("^", "");
+        }
+    }
+    formatedLatex = formatedLatex
         .replaceAll("\\left", "")
         .replaceAll("\\right", "");
     try {
-        const tokens = (0, exports.tokenize)(formattedLatex);
+        const tokens = (0, exports.tokenize)(formatedLatex);
         if (!isDyck(tokens))
             throw Error("Problème de parenthèses.");
         const parsed = buildTree(tokens);

package/lib/tree/parsers/monomParser.js

@@ -49,11 +49,11 @@ const isMonomNode = (node, { variable, maxDegree, minDegree } = {
         if (!numericChild)
             return false;
         const varChild = numericChild === "left" ? node.rightChild : node.leftChild;
-        if ((0, variableNode_1.isVariableNode)(varChild) && varChild.name === "x" && minDegree < 2)
+        if ((0, variableNode_1.isVariableNode)(varChild) && varChild.name === variable && minDegree < 2)
             return true;
         if ((0, powerNode_1.isPowerNode)(varChild) &&
             (0, variableNode_1.isVariableNode)(varChild.leftChild) &&
-            varChild.leftChild.name === "x" &&
+            varChild.leftChild.name === variable &&
             varChild.rightChild.isNumeric) {
             const powerEv = varChild.rightChild.evaluate();
             if (maxDegree && powerEv > maxDegree)

package/lib/tree/parsers/powerParser.d.ts

@@ -1,2 +1,2 @@
-export declare const powerParser: (ans: string) => false | import("../nodes/operators/powerNode").PowerNode | import("../nodes/operators/fractionNode").FractionNode;
+export declare const powerParser: (ans: string) => false | import("../nodes/operators/fractionNode").FractionNode | import("../nodes/operators/powerNode").PowerNode;
 //# sourceMappingURL=powerParser.d.ts.map

package/lib/tree/parsers/rationalParser.d.ts

@@ -1,3 +1,3 @@
 import { FractionNode } from "../nodes/operators/fractionNode";
-export declare const rationalParser: (ans: string) => false | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/functions/oppositeNode").OppositeNode | FractionNode | undefined;
+export declare const rationalParser: (ans: string) => false | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/functions/oppositeNode").OppositeNode<import("../nodes/algebraicNode").AlgebraicNode> | FractionNode;
 //# sourceMappingURL=rationalParser.d.ts.map

package/lib/tree/parsers/rationalParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rationalParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/rationalParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAQ,MAAM,iCAAiC,CAAC;AAGrE,eAAO,MAAM,cAAc,QAAS,MAAM,wMA0BzC,CAAC"}
+{"version":3,"file":"rationalParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/rationalParser.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,YAAY,EAGb,MAAM,iCAAiC,CAAC;AAIzC,eAAO,MAAM,cAAc,QAAS,MAAM,4OA0CzC,CAAC"}

package/lib/tree/parsers/rationalParser.js

@@ -2,39 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rationalParser = void 0;
 const oppositeNode_1 = require("../nodes/functions/oppositeNode");
+const numberNode_1 = require("../nodes/numbers/numberNode");
 const fractionNode_1 = require("../nodes/operators/fractionNode");
+const latexParser_1 = require("./latexParser");
 const numberParser_1 = require("./numberParser");
 const rationalParser = (ans) => {
     const nb = (0, numberParser_1.numberParser)(ans);
     if (nb !== false) {
         return nb.unfrenchify().toTree();
     }
-    if (!ans.includes("\\frac"))
+    const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+    if (!parsed)
         return false;
-    if (ans.startsWith("\\frac")) {
-        const fracs = ans.replaceAll("}", "").split("{").slice(1);
-        if (fracs.length !== 2)
-            return false;
-        const parsedFracs = fracs.map((e) => (0, numberParser_1.numberParser)(e));
-        if (parsedFracs.some((e) => e === false))
-            return false;
-        const nodeFracs = fracs.map((e) => e.unfrenchify().toTree());
-        if (nodeFracs[1].evaluate() === 0)
-            return false;
-        return (0, fractionNode_1.frac)(nodeFracs[0], nodeFracs[1]);
+    if ((0, fractionNode_1.isFractionNode)(parsed)) {
+        if ((0, numberNode_1.isNumberOrOppositeNumberNode)(parsed.leftChild) &&
+            (0, numberNode_1.isNumberOrOppositeNumberNode)(parsed.rightChild)) {
+            if (parsed.rightChild.evaluate() === 0)
+                return false;
+            return parsed;
+        }
     }
-    if (ans.startsWith("-")) {
-        const fracString = ans.slice(1);
-        const fracs = fracString.replaceAll("}", "").split("{").slice(1);
-        if (fracs.length !== 2)
-            return false;
-        const parsedFracs = fracs.map((e) => (0, numberParser_1.numberParser)(e));
-        if (parsedFracs.some((e) => e === false))
-            return false;
-        const nodeFracs = fracs.map((e) => e.unfrenchify().toTree());
-        if (nodeFracs[1].evaluate() === 0)
-            return false;
-        return (0, oppositeNode_1.opposite)((0, fractionNode_1.frac)(nodeFracs[0], nodeFracs[1]));
+    if ((0, oppositeNode_1.isOppositeNode)(parsed) && (0, fractionNode_1.isFractionNode)(parsed.child)) {
+        if ((0, numberNode_1.isNumberOrOppositeNumberNode)(parsed.child.leftChild) &&
+            (0, numberNode_1.isNumberOrOppositeNumberNode)(parsed.child.rightChild)) {
+            if (parsed.child.rightChild.evaluate() === 0)
+                return false;
+            return parsed;
+        }
     }
+    if ((0, oppositeNode_1.isOppositeNode)(parsed) &&
+        (0, oppositeNode_1.isOppositeNode)(parsed.child) &&
+        (0, fractionNode_1.isFractionNode)(parsed.child.child)) {
+        if ((0, numberNode_1.isNumberOrOppositeNumberNode)(parsed.child.child.leftChild) &&
+            (0, numberNode_1.isNumberOrOppositeNumberNode)(parsed.child.child.rightChild)) {
+            if (parsed.child.child.rightChild.evaluate() === 0)
+                return false;
+            return parsed;
+        }
+    }
+    return false;
 };
 exports.rationalParser = rationalParser;

package/lib/tree/parsers/sqrtParser.d.ts

@@ -0,0 +1,9 @@
+/**parses :
+ *  number
+ *  sqrt(a)
+ *  -sqrt(a)
+ *  sqrt(a) * b
+ *  -sqrt(a) * b
+ */
+export declare const sqrtParser: (ans: string) => false | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/operators/multiplyNode").MultiplyNode | import("../nodes/functions/oppositeNode").OppositeNode<import("../nodes/algebraicNode").AlgebraicNode> | import("../nodes/functions/sqrtNode").SqrtNode;
+//# sourceMappingURL=sqrtParser.d.ts.map

package/lib/tree/parsers/sqrtParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrtParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/sqrtParser.ts"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,QAAS,MAAM,uUAuCrC,CAAC"}

package/lib/tree/parsers/sqrtParser.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqrtParser = void 0;
+const oppositeNode_1 = require("../nodes/functions/oppositeNode");
+const sqrtNode_1 = require("../nodes/functions/sqrtNode");
+const numberNode_1 = require("../nodes/numbers/numberNode");
+const multiplyNode_1 = require("../nodes/operators/multiplyNode");
+const latexParser_1 = require("./latexParser");
+const numberParser_1 = require("./numberParser");
+/**parses :
+ *  number
+ *  sqrt(a)
+ *  -sqrt(a)
+ *  sqrt(a) * b
+ *  -sqrt(a) * b
+ */
+const sqrtParser = (ans) => {
+    try {
+        const nb = (0, numberParser_1.numberParser)(ans);
+        if (nb !== false) {
+            return nb.unfrenchify().toTree();
+        }
+        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+        if (!parsed)
+            return false;
+        if ((0, sqrtNode_1.isSqrtNode)(parsed)) {
+            return parsed;
+        }
+        if ((0, oppositeNode_1.isOppositeNode)(parsed) && (0, sqrtNode_1.isSqrtNode)(parsed.child)) {
+            return parsed;
+        }
+        if ((0, multiplyNode_1.isMultiplyNode)(parsed)) {
+            if (((0, sqrtNode_1.isSqrtNode)(parsed.leftChild) &&
+                (0, numberNode_1.isNumberOrOppositeNumberNode)(parsed.rightChild)) ||
+                ((0, numberNode_1.isNumberOrOppositeNumberNode)(parsed.leftChild) &&
+                    (0, sqrtNode_1.isSqrtNode)(parsed.rightChild)))
+                return parsed;
+        }
+        if ((0, oppositeNode_1.isOppositeNode)(parsed) && (0, multiplyNode_1.isMultiplyNode)(parsed.child)) {
+            if (((0, sqrtNode_1.isSqrtNode)(parsed.child.leftChild) &&
+                (0, numberNode_1.isNumberOrOppositeNumberNode)(parsed.child.rightChild)) ||
+                ((0, numberNode_1.isNumberOrOppositeNumberNode)(parsed.child.leftChild) &&
+                    (0, sqrtNode_1.isSqrtNode)(parsed.child.rightChild)))
+                return parsed;
+        }
+        return false;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.sqrtParser = sqrtParser;

package/lib/tree/parsers/trinomParser.d.ts

@@ -1,2 +1,2 @@
-export declare const trinomParser: (ans: string, variable?: string) => false | undefined;
+export declare const trinomParser: (ans: string, variable?: string) => false | import("../nodes/algebraicNode").AlgebraicNode | undefined;
 //# sourceMappingURL=trinomParser.d.ts.map

package/lib/tree/parsers/trinomParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trinomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/trinomParser.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,sBAyBzD,CAAC"}
+{"version":3,"file":"trinomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/trinomParser.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,uEAgCzD,CAAC"}

package/lib/tree/parsers/trinomParser.js

@@ -1,11 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trinomParser = void 0;
+const addNode_1 = require("../nodes/operators/addNode");
+const substractNode_1 = require("../nodes/operators/substractNode");
+const latexParser_1 = require("./latexParser");
+const monomParser_1 = require("./monomParser");
 const trinomParser = (ans, variable = "x") => {
     try {
         //! difficile !
-        //! peut etre que je fais fausse, il faut peut etre simplifier canoniquement et checker si ca ressemble à un trinome
-        //! mais ce qui m'embete dans cette approche c'est que la simplification va etre trop "gentille", on va accepter des trucs qu'on aurait pas du ...
+        //! peut etre que je fais fausse route, il faut peut etre simplifier canoniquement et checker si ca ressemble à un trinome
+        //! mais ce qui m'embete dans cette approche c'est que la simplification va etre trop gentille, on va accepter des trucs qu'on aurait pas du ...*
+        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+        if (!parsed)
+            return false;
+        if ((0, monomParser_1.isMonomNode)(parsed, { variable, maxDegree: 2, minDegree: 2 }))
+            return parsed;
+        if ((0, addNode_1.isAddNode)(parsed) || (0, substractNode_1.isSubstractNode)(parsed)) {
+            const children = [parsed.leftChild, parsed.rightChild];
+        }
         // const monom = monomParser(ans, { variable, maxDegree: 2, minDegree: 2 });
         // if (monom) return monom;
         // const parsed = parseAlgebraic(ans);

package/lib/tree/utilities/functionComposition.d.ts

@@ -1,5 +1,5 @@
 import { Class } from '../../types/class';
 import { FunctionNode } from '../nodes/functions/functionNode';
 import { Node } from '../nodes/node';
-export declare const functionComposition: <T extends Class<FunctionNode>>(Compositor: T, arr: Node[]) => FunctionNode;
+export declare const functionComposition: <T extends Class<FunctionNode<import("../nodes/algebraicNode").AlgebraicNode>>>(Compositor: T, arr: Node[]) => FunctionNode<import("../nodes/algebraicNode").AlgebraicNode>;
 //# sourceMappingURL=functionComposition.d.ts.map

package/lib/tree/utilities/functionComposition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,eAAO,MAAM,mBAAmB,sDAAuD,IAAI,EAAE,iBAU5F,CAAC"}
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,eAAO,MAAM,mBAAmB,sGAAuD,IAAI,EAAE,iEAU5F,CAAC"}

package/lib/utils/arrays/rotation.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param arr
+ * @param angle
+ * @returns [t_angle, t_angle+1, ..., t_0, t_1]
+ */
+export declare function arrayRotation<T>(arr: T[], angle: number): T[];
+//# sourceMappingURL=rotation.d.ts.map

package/lib/utils/arrays/rotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotation.d.ts","sourceRoot":"","sources":["../../../src/utils/arrays/rotation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,OAIvD"}

package/lib/utils/arrays/rotation.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayRotation = void 0;
+/**
+ *
+ * @param arr
+ * @param angle
+ * @returns [t_angle, t_angle+1, ..., t_0, t_1]
+ */
+function arrayRotation(arr, angle) {
+    if (angle < 0 || angle > arr.length - 1)
+        return [];
+    if (angle === 0)
+        return [...arr];
+    return [...arr.slice(angle), ...arr.slice(0, angle)];
+}
+exports.arrayRotation = arrayRotation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.2.68",
+  "version": "2.2.70",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [