math-exercises 2.2.95 → 2.2.96

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

@@ -16,10 +16,10 @@ function isMonomNode(a) {
     return a.type === node_1.NodeType.monom;
 }
 exports.isMonomNode = isMonomNode;
-function parseToMonomNode(a, variable = "x") {
+function parseToMonomNode(a) {
     if (!(0, algebraicNode_1.isAlgebraicNode)(a))
         return false;
-    return (0, exports.parseToMonom)(a, { variable, minDegree: 1, maxDegree: undefined });
+    return (0, exports.parseToMonom)(a);
 }
 exports.parseToMonomNode = parseToMonomNode;
 /**
@@ -80,75 +80,70 @@ class MonomNode {
     }
 }
 exports.MonomNode = MonomNode;
-const parseToMonom = (node, { variable, maxDegree, minDegree } = {
-    variable: "x",
-    maxDegree: undefined,
-    minDegree: 1,
-}) => {
-    variable = variable ?? "x";
-    maxDegree = maxDegree ?? undefined;
-    minDegree = minDegree ?? 1;
+const parseToMonom = (node) => {
+    // variable = variable ?? "x";
+    // maxDegree = maxDegree ?? undefined;
+    // minDegree = minDegree ?? 1;
     if (isMonomNode(node)) {
-        if (node.variable !== variable)
-            return false;
-        if (maxDegree && node.degree > maxDegree)
-            return false;
-        if (minDegree && node.degree < minDegree)
-            return false;
+        // if (node.variable !== variable) return false;
+        // if (maxDegree && node.degree > maxDegree) return false;
+        // if (minDegree && node.degree < minDegree) return false;
         return node;
     }
     if (node.isNumeric)
         return false;
-    if ((0, variableNode_1.isVariableNode)(node) && node.name === variable && minDegree < 2)
-        return new MonomNode(1, 1, { variable });
+    if ((0, variableNode_1.isVariableNode)(node))
+        return new MonomNode(1, 1, { variable: node.name });
     if ((0, oppositeNode_1.isOppositeNode)(node) &&
-        (0, variableNode_1.isVariableNode)(node.child) &&
-        node.child.name === variable &&
-        minDegree < 2)
-        return new MonomNode(-1, 1, { variable });
+        (0, variableNode_1.isVariableNode)(node.child)
+    // &&
+    // node.child.name === variable &&
+    // minDegree < 2
+    )
+        return new MonomNode(-1, 1, { variable: node.child.name });
     if ((0, powerNode_1.isSquareNode)(node)) {
-        if (minDegree > 2)
+        // if (minDegree > 2) return false;
+        // if (maxDegree && maxDegree < 2) return false;
+        if (!(0, variableNode_1.isVariableNode)(node.leftChild)
+        // || node.leftChild.name !== variable
+        )
             return false;
-        if (maxDegree && maxDegree < 2)
-            return false;
-        if (!(0, variableNode_1.isVariableNode)(node.leftChild) || node.leftChild.name !== variable)
-            return false;
-        return new MonomNode(1, 2, { variable });
+        return new MonomNode(1, 2, { variable: node.leftChild.name });
     }
     if ((0, oppositeNode_1.isOppositeNode)(node) && (0, powerNode_1.isSquareNode)(node.child)) {
-        if (minDegree > 2)
-            return false;
-        if (maxDegree && maxDegree < 2)
-            return false;
-        if (!(0, variableNode_1.isVariableNode)(node.child.leftChild) ||
-            node.child.leftChild.name !== variable)
-            return false;
-        return new MonomNode(-1, 2, { variable });
+        // if (minDegree > 2) return false;
+        // if (maxDegree && maxDegree < 2) return false;
+        if (!(0, variableNode_1.isVariableNode)(node.child.leftChild)
+        // ||
+        // node.child.leftChild.name !== variable
+        )
+            return false;
+        return new MonomNode(-1, 2, { variable: node.child.leftChild.name });
     }
     if ((0, powerNode_1.isPowerNode)(node)) {
         if (!node.rightChild.isNumeric)
             return false;
         const powerEv = node.rightChild.evaluate();
-        if (maxDegree && powerEv > maxDegree)
-            return false;
-        if (minDegree && powerEv < minDegree)
+        // if (maxDegree && powerEv > maxDegree) return false;
+        // if (minDegree && powerEv < minDegree) return false;
+        if (!(0, variableNode_1.isVariableNode)(node.leftChild)
+        // || node.leftChild.name !== variable
+        )
             return false;
-        if (!(0, variableNode_1.isVariableNode)(node.leftChild) || node.leftChild.name !== variable)
-            return false;
-        return new MonomNode(1, powerEv, { variable });
+        return new MonomNode(1, powerEv, { variable: node.leftChild.name });
     }
     if ((0, oppositeNode_1.isOppositeNode)(node) && (0, powerNode_1.isPowerNode)(node.child)) {
         if (!node.child.rightChild.isNumeric)
             return false;
         const powerEv = node.child.rightChild.evaluate();
-        if (maxDegree && powerEv > maxDegree)
-            return false;
-        if (minDegree && powerEv < minDegree)
-            return false;
-        if (!(0, variableNode_1.isVariableNode)(node.child.leftChild) ||
-            node.child.leftChild.name !== variable)
-            return false;
-        return new MonomNode(-1, powerEv, { variable });
+        // if (maxDegree && powerEv > maxDegree) return false;
+        // if (minDegree && powerEv < minDegree) return false;
+        if (!(0, variableNode_1.isVariableNode)(node.child.leftChild)
+        // ||
+        // node.child.leftChild.name !== variable
+        )
+            return false;
+        return new MonomNode(-1, powerEv, { variable: node.child.leftChild.name });
     }
     if ((0, multiplyNode_1.isMultiplyNode)(node)) {
         const numericChildPosition = node.leftChild.isNumeric
@@ -161,68 +156,71 @@ const parseToMonom = (node, { variable, maxDegree, minDegree } = {
         const numericChild = numericChildPosition === "left" ? node.leftChild : node.rightChild;
         const varChild = numericChildPosition === "left" ? node.rightChild : node.leftChild;
         if ((0, variableNode_1.isVariableNode)(varChild)) {
-            if (varChild.name !== variable || minDegree > 1)
-                return false;
-            else
-                return new MonomNode(numericChild, 1, { variable });
+            // if (varChild.name !== variable || minDegree > 1) return false;
+            // else
+            return new MonomNode(numericChild, 1, { variable: varChild.name });
         }
         if ((0, powerNode_1.isSquareNode)(varChild)) {
-            if (minDegree > 2)
-                return false;
-            if (maxDegree && maxDegree < 2)
-                return false;
-            if (!(0, variableNode_1.isVariableNode)(varChild.leftChild) ||
-                varChild.leftChild.name !== variable)
+            // if (minDegree > 2) return false;
+            // if (maxDegree && maxDegree < 2) return false;
+            if (!(0, variableNode_1.isVariableNode)(varChild.leftChild)
+            // ||
+            // varChild.leftChild.name !== variable
+            )
                 return false;
-            return new MonomNode(numericChild, 2, { variable });
+            return new MonomNode(numericChild, 2, {
+                variable: varChild.leftChild.name,
+            });
         }
         if ((0, oppositeNode_1.isOppositeNode)(varChild) && (0, powerNode_1.isSquareNode)(varChild.child)) {
-            if (minDegree > 2)
-                return false;
-            if (maxDegree && maxDegree < 2)
+            // if (minDegree > 2) return false;
+            // if (maxDegree && maxDegree < 2) return false;
+            if (!(0, variableNode_1.isVariableNode)(varChild.child.leftChild)
+            // ||
+            // varChild.child.leftChild.name !== variable
+            )
                 return false;
-            if (!(0, variableNode_1.isVariableNode)(varChild.child.leftChild) ||
-                varChild.child.leftChild.name !== variable)
-                return false;
-            return new MonomNode((0, oppositeNode_1.opposite)(numericChild), 2, { variable });
+            return new MonomNode((0, oppositeNode_1.opposite)(numericChild), 2, {
+                variable: varChild.child.leftChild.name,
+            });
         }
         if ((0, powerNode_1.isPowerNode)(varChild) &&
             (0, variableNode_1.isVariableNode)(varChild.leftChild) &&
-            varChild.leftChild.name === variable &&
+            // varChild.leftChild.name === variable &&
             varChild.rightChild.isNumeric) {
             const powerEv = varChild.rightChild.evaluate();
-            if (maxDegree && powerEv > maxDegree)
-                return false;
-            if (minDegree && powerEv < minDegree)
-                return false;
-            return new MonomNode(numericChild, powerEv, { variable });
+            // if (maxDegree && powerEv > maxDegree) return false;
+            // if (minDegree && powerEv < minDegree) return false;
+            return new MonomNode(numericChild, powerEv, {
+                variable: varChild.leftChild.name,
+            });
         }
         if ((0, oppositeNode_1.isOppositeNode)(varChild) &&
             (0, powerNode_1.isPowerNode)(varChild.child) &&
             (0, variableNode_1.isVariableNode)(varChild.child.leftChild) &&
-            varChild.child.leftChild.name === variable &&
+            // varChild.child.leftChild.name === variable &&
             varChild.child.rightChild.isNumeric) {
             const powerEv = varChild.child.rightChild.evaluate();
-            if (maxDegree && powerEv > maxDegree)
-                return false;
-            if (minDegree && powerEv < minDegree)
-                return false;
-            return new MonomNode((0, oppositeNode_1.opposite)(numericChild), powerEv, { variable });
+            // if (maxDegree && powerEv > maxDegree) return false;
+            // if (minDegree && powerEv < minDegree) return false;
+            return new MonomNode((0, oppositeNode_1.opposite)(numericChild), powerEv, {
+                variable: varChild.child.leftChild.name,
+            });
         }
     }
     return false;
 };
 exports.parseToMonom = parseToMonom;
 const isMonom = (node, { variable, maxDegree, minDegree } = {
-    variable: "x",
+    variable: undefined,
     maxDegree: undefined,
     minDegree: 0,
 }) => {
-    variable = variable ?? "x";
+    variable = variable ?? undefined;
     maxDegree = maxDegree ?? undefined;
     minDegree = minDegree ?? 0;
     if (isMonomNode(node)) {
-        if (node.variable !== variable)
+        if (variable && node.variable !== variable)
             return false;
         if (maxDegree && node.degree > maxDegree)
             return false;
@@ -233,12 +231,14 @@ const isMonom = (node, { variable, maxDegree, minDegree } = {
     if (node.isNumeric && minDegree === 0)
         return true;
     //not monom
-    if ((0, variableNode_1.isVariableNode)(node) && node.name === variable && minDegree < 2)
+    if ((0, variableNode_1.isVariableNode)(node) &&
+        (!variable || node.name === variable) &&
+        minDegree < 2)
         return true;
     //new MonomNode(1, 1, { variable });
     if ((0, oppositeNode_1.isOppositeNode)(node) &&
         (0, variableNode_1.isVariableNode)(node.child) &&
-        node.child.name === variable &&
+        (!variable || node.child.name === variable) &&
         minDegree < 2)
         return true;
     // new MonomNode(-1, 1, {variable})
@@ -247,14 +247,16 @@ const isMonom = (node, { variable, maxDegree, minDegree } = {
             return false;
         if (maxDegree && maxDegree < 2)
             return false;
-        return (0, variableNode_1.isVariableNode)(node.leftChild) && node.leftChild.name === "x";
+        return ((0, variableNode_1.isVariableNode)(node.leftChild) &&
+            (!variable || node.leftChild.name === variable));
     }
     if ((0, oppositeNode_1.isOppositeNode)(node) && (0, powerNode_1.isSquareNode)(node.child)) {
         if (minDegree > 2)
             return false;
         if (maxDegree && maxDegree < 2)
             return false;
-        return ((0, variableNode_1.isVariableNode)(node.child.leftChild) && node.child.leftChild.name === "x");
+        return ((0, variableNode_1.isVariableNode)(node.child.leftChild) &&
+            (!variable || node.child.leftChild.name === variable));
     }
     if ((0, powerNode_1.isPowerNode)(node)) {
         if (!node.rightChild.isNumeric)
@@ -264,7 +266,8 @@ const isMonom = (node, { variable, maxDegree, minDegree } = {
             return false;
         if (minDegree && powerEv < minDegree)
             return false;
-        return (0, variableNode_1.isVariableNode)(node.leftChild) && node.leftChild.name === "x";
+        return ((0, variableNode_1.isVariableNode)(node.leftChild) &&
+            (!variable || node.leftChild.name === variable));
     }
     if ((0, oppositeNode_1.isOppositeNode)(node) && (0, powerNode_1.isPowerNode)(node.child)) {
         if (!node.child.rightChild.isNumeric)
@@ -274,7 +277,8 @@ const isMonom = (node, { variable, maxDegree, minDegree } = {
             return false;
         if (minDegree && powerEv < minDegree)
             return false;
-        return ((0, variableNode_1.isVariableNode)(node.child.leftChild) && node.child.leftChild.name === "x");
+        return ((0, variableNode_1.isVariableNode)(node.child.leftChild) &&
+            (!variable || node.child.leftChild.name === variable));
     }
     if ((0, multiplyNode_1.isMultiplyNode)(node)) {
         const numericChild = node.leftChild.isNumeric
@@ -285,11 +289,13 @@ const isMonom = (node, { variable, maxDegree, minDegree } = {
         if (!numericChild)
             return false;
         const varChild = numericChild === "left" ? node.rightChild : node.leftChild;
-        if ((0, variableNode_1.isVariableNode)(varChild) && varChild.name === variable && minDegree < 2)
+        if ((0, variableNode_1.isVariableNode)(varChild) &&
+            (!variable || varChild.name === variable) &&
+            minDegree < 2)
             return true;
         if ((0, powerNode_1.isSquareNode)(varChild) &&
             (0, variableNode_1.isVariableNode)(varChild.leftChild) &&
-            varChild.leftChild.name === variable) {
+            (!variable || varChild.leftChild.name === variable)) {
             if (maxDegree && maxDegree < 2)
                 return false;
             if (minDegree > 2)
@@ -299,7 +305,7 @@ const isMonom = (node, { variable, maxDegree, minDegree } = {
         }
         if ((0, powerNode_1.isPowerNode)(varChild) &&
             (0, variableNode_1.isVariableNode)(varChild.leftChild) &&
-            varChild.leftChild.name === variable &&
+            (!variable || varChild.leftChild.name === variable) &&
             varChild.rightChild.isNumeric) {
             const powerEv = varChild.rightChild.evaluate();
             if (maxDegree && powerEv > maxDegree)
@@ -319,12 +325,14 @@ const isMonom = (node, { variable, maxDegree, minDegree } = {
         if (!numericChild)
             return false;
         const varChild = numericChild === "left" ? node.child.rightChild : node.child.leftChild;
-        if ((0, variableNode_1.isVariableNode)(varChild) && varChild.name === variable && minDegree < 2)
+        if ((0, variableNode_1.isVariableNode)(varChild) &&
+            (!variable || varChild.name === variable) &&
+            minDegree < 2)
             return true;
         //new MonomNode(numericChild, 1, {variable});
         if ((0, powerNode_1.isPowerNode)(varChild) &&
             (0, variableNode_1.isVariableNode)(varChild.leftChild) &&
-            varChild.leftChild.name === variable &&
+            (!variable || varChild.leftChild.name === variable) &&
             varChild.rightChild.isNumeric) {
             const powerEv = varChild.rightChild.evaluate();
             if (maxDegree && powerEv > maxDegree)

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

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

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":"AAYA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,qKAuBzD,CAAC"}
+{"version":3,"file":"affineParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/affineParser.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,UAwBzD,CAAC"}

package/lib/tree/parsers/affineParser.js

@@ -2,30 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.affineParser = void 0;
 const handleVEAError_1 = require("../../utils/errors/handleVEAError");
-const addNode_1 = require("../nodes/operators/addNode");
-const substractNode_1 = require("../nodes/operators/substractNode");
-const monomNode_1 = require("../nodes/polynomials/monomNode");
-const latexParser_1 = require("./latexParser");
-const monomParser_1 = require("./monomParser");
 const affineParser = (ans, variable = "x") => {
     try {
+        throw new Error("not sure this works");
         //double parse, pas opti
-        const monom = (0, monomParser_1.monomParser)(ans, { variable, maxDegree: 1 });
-        if (monom)
-            return monom;
-        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
-        if ((0, addNode_1.isAddNode)(parsed) || (0, substractNode_1.isSubstractNode)(parsed)) {
-            const numericChild = parsed.leftChild.isNumeric
-                ? "left"
-                : parsed.rightChild.isNumeric
-                    ? "right"
-                    : undefined;
-            if (!numericChild)
-                return false;
-            const varChild = numericChild === "left" ? parsed.rightChild : parsed.leftChild;
-            return (0, monomNode_1.isMonom)(varChild, { variable, maxDegree: 1 }) ? parsed : false;
-        }
-        return false;
+        // const monom = monomParser(ans, { variable, maxDegree: 1 });
+        // if (monom) return monom;
+        // const parsed = parseAlgebraic(ans);
+        // if (isAddNode(parsed) || isSubstractNode(parsed)) {
+        //   const numericChild = parsed.leftChild.isNumeric
+        //     ? "left"
+        //     : parsed.rightChild.isNumeric
+        //     ? "right"
+        //     : undefined;
+        //   if (!numericChild) return false;
+        //   const varChild =
+        //     numericChild === "left" ? parsed.rightChild : parsed.leftChild;
+        //   return isMonom(varChild, { variable, maxDegree: 1 }) ? parsed : false;
+        // }
+        // return false;
     }
     catch (err) {
         return (0, handleVEAError_1.handleVEAError)(err);

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

@@ -1,3 +1,7 @@
 import { AlgebraicNode } from "../nodes/algebraicNode";
-export declare const polynomialParser: (ans: string) => false | AlgebraicNode | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/operators/substractNode").SubstractNode | import("../nodes/operators/addNode").AddNode;
+type Opts = {
+    variable?: string;
+};
+export declare const polynomialParser: (ans: string, opts?: Opts) => false | AlgebraicNode | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/operators/substractNode").SubstractNode | import("../nodes/operators/addNode").AddNode;
+export {};
 //# sourceMappingURL=polynomialParser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"polynomialParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/polynomialParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAWvD,eAAO,MAAM,gBAAgB,QAAS,MAAM,8OAmC3C,CAAC"}
+{"version":3,"file":"polynomialParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/polynomialParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AASvD,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAGF,eAAO,MAAM,gBAAgB,QAAS,MAAM,SAAS,IAAI,8OAkCxD,CAAC"}

package/lib/tree/parsers/polynomialParser.js

@@ -11,13 +11,13 @@ const monomParser_1 = require("./monomParser");
 const numberParser_1 = require("./numberParser");
 //!parses polynomes sous forme développée
 //minDegree = 0, max = undefined
-const polynomialParser = (ans) => {
+const polynomialParser = (ans, opts) => {
     try {
         const nb = (0, numberParser_1.numberParser)(ans);
         if (nb !== false) {
             return nb.unfrenchify().toTree();
         }
-        const monom = (0, monomParser_1.monomParser)(ans);
+        const monom = (0, monomParser_1.monomParser)(ans, opts);
         if (monom)
             return monom;
         const parsed = (0, latexParser_1.parseAlgebraic)(ans);
@@ -39,7 +39,7 @@ const polynomialParser = (ans) => {
                 }
             };
             recursive(parsed);
-            if (externals.every((node) => (0, monomNode_1.isMonom)(node))) {
+            if (externals.every((node) => (0, monomNode_1.isMonom)(node, opts))) {
                 return parsed;
             }
         }

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

@@ -2,7 +2,7 @@
  * supprime les éléments superflus sans aucun calcul maths
  * ex : transforme (2) en 2
  * ex : transforme (9)/3 en 9/3 mais pas en 3
- * doit-il transformer 1*x en x ?
+ * doit-il transformer 1*x en x ? -> je dirais que non
  * @param str réponse élève
  */
 export declare const purifyLatex: (str: string) => void;

package/lib/tree/parsers/purifyLatex.js

@@ -5,7 +5,7 @@ exports.purifyLatex = void 0;
  * supprime les éléments superflus sans aucun calcul maths
  * ex : transforme (2) en 2
  * ex : transforme (9)/3 en 9/3 mais pas en 3
- * doit-il transformer 1*x en x ?
+ * doit-il transformer 1*x en x ? -> je dirais que non
  * @param str réponse élève
  */
 const purifyLatex = (str) => {

package/lib/utils/alea/shuffle.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shuffle = void 0;
-/* Randomize array in-place using Durstenfeld shuffle algorithm */
+/* Randomize array using Durstenfeld shuffle algorithm */
 function shuffle(array) {
     const res = [...array];
     for (var i = res.length - 1; i > 0; i--) {

package/package.json

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