math-exercises 2.2.69 → 2.2.70

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;
+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,4LA2BzC,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,43 @@
 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;
 };

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.69",
+  "version": "2.2.70",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [