math-exercises 2.2.65 → 2.2.67

package/lib/tree/parsers/monomParser.js

@@ -1,5 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.monomParser = void 0;
-const monomParser = (str) => { };
+exports.isMonomNode = exports.monomParser = void 0;
+const fractionNode_1 = require("../nodes/operators/fractionNode");
+const multiplyNode_1 = require("../nodes/operators/multiplyNode");
+const powerNode_1 = require("../nodes/operators/powerNode");
+const variableNode_1 = require("../nodes/variables/variableNode");
+const latexParser_1 = require("./latexParser");
+const monomParser = (str, { variable, maxDegree, minDegree } = {
+    variable: "x",
+    maxDegree: undefined,
+    minDegree: 0,
+}) => {
+    try {
+        const parsed = (0, latexParser_1.parseAlgebraic)(str);
+        return (0, exports.isMonomNode)(parsed, { variable, maxDegree, minDegree })
+            ? parsed
+            : false;
+        if ((0, fractionNode_1.isFractionNode)(parsed)) {
+            //!unimplemented
+            return false;
+        }
+        else
+            return false;
+    }
+    catch (err) {
+        return false;
+    }
+};
 exports.monomParser = monomParser;
+const isMonomNode = (node, { variable, maxDegree, minDegree } = {
+    variable: "x",
+    maxDegree: undefined,
+    minDegree: 0,
+}) => {
+    variable = variable ?? "x";
+    maxDegree = maxDegree ?? undefined;
+    minDegree = minDegree ?? 0;
+    if (node.isNumeric && minDegree === 0)
+        return true;
+    if ((0, variableNode_1.isVariableNode)(node) && node.name === variable && minDegree < 2)
+        return true;
+    if ((0, multiplyNode_1.isMultiplyNode)(node)) {
+        const numericChild = node.leftChild.isNumeric
+            ? "left"
+            : node.rightChild.isNumeric
+                ? "right"
+                : undefined;
+        if (!numericChild)
+            return false;
+        const varChild = numericChild === "left" ? node.rightChild : node.leftChild;
+        if ((0, variableNode_1.isVariableNode)(varChild) && varChild.name === "x" && minDegree < 2)
+            return true;
+        if ((0, powerNode_1.isPowerNode)(varChild) &&
+            (0, variableNode_1.isVariableNode)(varChild.leftChild) &&
+            varChild.leftChild.name === "x" &&
+            varChild.rightChild.isNumeric) {
+            const powerEv = varChild.rightChild.evaluate();
+            if (maxDegree && powerEv > maxDegree)
+                return false;
+            if (minDegree && powerEv < minDegree)
+                return false;
+            return true;
+        }
+    }
+    return false;
+};
+exports.isMonomNode = isMonomNode;

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * 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 ?
+ * @param str réponse élève
+ */
+export declare const purifyLatex: (str: string) => void;
+//# sourceMappingURL=purifyLatex.d.ts.map

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

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

package/lib/tree/parsers/purifyLatex.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 ?
+ * @param str réponse élève
+ */
+const purifyLatex = (str) => {
+    //on peut supprimer des parenthèses si :
+    //* pas suivi/précédé d'une multiplication
+    //* pas arguments d'une fonction
+    //* .. ?
+};
+exports.purifyLatex = purifyLatex;

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/algebraicNode").AlgebraicNode | FractionNode | import("../nodes/functions/oppositeNode").OppositeNode | undefined;
+export declare const rationalParser: (ans: string) => false | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/functions/oppositeNode").OppositeNode | FractionNode | undefined;
 //# 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,+IA0BzC,CAAC"}
+{"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"}

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

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

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

@@ -0,0 +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"}

package/lib/tree/parsers/trinomParser.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trinomParser = void 0;
+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 ...
+        // const monom = monomParser(ans, { variable, maxDegree: 2, minDegree: 2 });
+        // if (monom) return monom;
+        // const parsed = parseAlgebraic(ans);
+        // if (isAddNode(parsed) || isSubstractNode(parsed)) {
+        //   const numericChild = parsed.leftChild.isNumeric
+        //     ? "left"
+        //     : parsed.rightChild.isNumeric
+        //     ? "right"
+        //     : undefined;
+        // //si numeric : alors ax^2 + b ou ax+b
+        // //sinon : ax^2 + bx + c car monom déjà exclu
+        //   if (!numericChild) return false;
+        //   const varChild =
+        //     numericChild === "left" ? parsed.rightChild : parsed.leftChild;
+        //   return isMonomNode(varChild, { variable, maxDegree: 1 }) ? parsed : false;
+        // }
+        // return false;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.trinomParser = trinomParser;

package/package.json

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