math-exercises 2.0.18 → 2.0.20

package/lib/exercises/calculLitteral/equation/firstDegreeEquation.js

@@ -48,7 +48,7 @@ exports.firstDegreeEquation = {
     connector: "=",
     label: "Résoudre une équation du premier degré du type $\\frac{a}{x} = b$",
     levels: ["2nde", "1reESM", "1reSpé"],
-    sections: ["Équations"],
+    sections: ["Équations", "Fonction inverse", "Fonctions de référence"],
     isSingleStep: false,
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFirstDegreeEquation, nb),
     getPropositions,

package/lib/exercises/percent/applyPercent.js

@@ -56,7 +56,7 @@ const isAnswerValid = (ans, { answer }) => {
 exports.applyPercent = {
     id: "applyPercent",
     connector: "=",
-    label: "Appliquer un pourcentage d'augmentation ou de diminution.",
+    label: "Appliquer un pourcentage d'augmentation ou de diminution",
     levels: [
         "4ème",
         "3ème",

package/lib/exercises/trigonometry/remarkableValues.js

@@ -52,7 +52,7 @@ const getPropositions = (n, { answer }) => {
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { mainValue, isCos }) => {
-    const remarkableValue = remarkableValues_1.remarkableTrigoValues.find((point) => point.angle.evaluate({}) === mainValue);
+    const remarkableValue = remarkableValues_1.remarkableTrigoValues.find((point) => Math.abs(point.angle.evaluate({}) - mainValue) < 0.0001);
     const answer = isCos ? remarkableValue.cos : remarkableValue.sin;
     const texs = answer.toAllValidTexs({
         allowFractionToDecimal: true,

package/lib/server.js

@@ -35,24 +35,22 @@ const express_1 = __importDefault(require("express"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const cors_1 = __importDefault(require("cors"));
-const addNode_1 = require("./tree/nodes/operators/addNode");
-const numberNode_1 = require("./tree/nodes/numbers/numberNode");
-const powerNode_1 = require("./tree/nodes/operators/powerNode");
-const sqrtNode_1 = require("./tree/nodes/functions/sqrtNode");
-const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
 const jsonParser = body_parser_1.default.json();
 const allExercises = [...exercises];
 const runServer = () => {
     dotenv_1.default.config();
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
-    console.log(exercises.length + " exercices");
-    const firstTerm = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(3), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)));
-    const secondTerm = new numberNode_1.NumberNode(5);
-    const answer = new addNode_1.AddNode(new powerNode_1.SquareNode(firstTerm), new addNode_1.AddNode(new powerNode_1.SquareNode(secondTerm), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), new multiplyNode_1.MultiplyNode(firstTerm, secondTerm))))
-        .simplify()
-        .toTex();
-    console.log(answer);
+    // const string = "\\frac{9}{12}";
+    // const a = string.match(/^[0-9]+,?[0-9]*/);
+    // const before = Date.now();
+    // const parsed = parseLatex(string);
+    // console.log("res", parsed);
+    // console.log(parsed?.toTex());
+    // console.log(parsed?.simplify().toTex());
+    // console.log(parsed?.evaluate({ x: 1 }));
+    // console.log("time", Date.now() - before);
+    // tokenize(string);
     app.get("/", (req, res) => {
         res.json(allExercises);
     });

package/lib/tree/nodes/functions/oppositeNode.d.ts

@@ -19,7 +19,7 @@ export declare class OppositeNode implements FunctionNode {
      */
     toAllValidTexs(opts?: NodeOptions): string[];
     evaluate(vars: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): OppositeNode;
+    simplify(opts?: SimplifyOptions): AlgebraicNode;
     equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=oppositeNode.d.ts.map

package/lib/tree/nodes/functions/oppositeNode.js

@@ -6,6 +6,7 @@ const node_1 = require("../node");
 const operatorNode_1 = require("../operators/operatorNode");
 const functionNode_1 = require("./functionNode");
 const numberNode_1 = require("../numbers/numberNode");
+const multiplyNode_1 = require("../operators/multiplyNode");
 const fractionNode_1 = require("../operators/fractionNode");
 function isOppositeNode(a) {
     return (0, functionNode_1.isFunctionNode)(a) && a.id === functionNode_1.FunctionsIds.opposite;
@@ -70,7 +71,7 @@ class OppositeNode {
         return -this.child.evaluate(vars);
     }
     simplify(opts) {
-        return new OppositeNode(this.child.simplify(opts));
+        return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(-1), this.child).simplify(opts);
     }
     equals(node) {
         return isOppositeNode(node) && node.child.equals(this.child);

package/lib/tree/nodes/operators/powerNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAOlE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAuBf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IA+FrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAO/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAGrD"}
+{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAOlE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAuBf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IA+FrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAY/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAGrD"}

package/lib/tree/nodes/operators/powerNode.js

@@ -157,11 +157,14 @@ class PowerNode {
     //   // puissances négatives ?
     // }
     simplify(opts) {
+        const leftSimplified = this.leftChild.simplify(opts);
+        const rightSimplified = this.rightChild.simplify(opts);
+        const copy = new PowerNode(leftSimplified, rightSimplified, this.opts);
         //! temporaire
-        if ((0, numberNode_1.isNumberNode)(this.rightChild) && this.rightChild.value === 2) {
-            return new multiplyNode_1.MultiplyNode(this.leftChild, this.leftChild).simplify(opts);
+        if ((0, numberNode_1.isNumberNode)(copy.rightChild) && copy.rightChild.value === 2) {
+            return new multiplyNode_1.MultiplyNode(copy.leftChild, copy.leftChild).simplify(opts);
         }
-        return this;
+        return copy;
     }
     equals(node) {
         return (isPowerNode(node) &&

package/lib/tree/nodes/operators/substractNode.js

@@ -43,7 +43,7 @@ class SubstractNode {
             [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
             rightTex[0] === "-";
         if (needBrackets)
-            rightTex = `(${rightTex})`;
+            rightTex = `\\left(${rightTex}\\right)`;
         return `${leftTex}-${rightTex}`;
     }
     evaluate(vars) {

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

@@ -0,0 +1,4 @@
+import { AlgebraicNode } from "../nodes/algebraicNode";
+export declare const tokenize: (latex: string) => string[];
+export declare const parseLatex: (latex: string) => AlgebraicNode;
+//# sourceMappingURL=latexParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA0CvD,eAAO,MAAM,QAAQ,UAAW,MAAM,aA4BrC,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,kBAavC,CAAC"}

package/lib/tree/parsers/latexParser.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLatex = exports.tokenize = void 0;
+const oppositeNode_1 = require("../nodes/functions/oppositeNode");
+const sqrtNode_1 = require("../nodes/functions/sqrtNode");
+const numberNode_1 = require("../nodes/numbers/numberNode");
+const addNode_1 = require("../nodes/operators/addNode");
+const fractionNode_1 = require("../nodes/operators/fractionNode");
+const multiplyNode_1 = require("../nodes/operators/multiplyNode");
+const powerNode_1 = require("../nodes/operators/powerNode");
+const substractNode_1 = require("../nodes/operators/substractNode");
+const variableNode_1 = require("../nodes/variables/variableNode");
+//cmd that needs a child, like \exp{3}
+const functions = [
+    "\\exp",
+    "\\sqrt",
+    "\\log",
+    "\\ln",
+    "\\cos",
+    "\\sin",
+    "\\frac",
+];
+const operators = ["+", "-", "\\div", "\\times", "^"];
+const isDyck = (tokens) => {
+    const brackets = tokens.filter((el) => el === "(" || el === ")");
+    while (brackets.length) {
+        const rightIndex = brackets.findIndex((el) => el == ")");
+        if (rightIndex === -1 || rightIndex === 0)
+            return false;
+        let leftIndex = -1;
+        for (let i = rightIndex - 1; i > -1; i--) {
+            if (brackets[i] === "(") {
+                leftIndex = i;
+            }
+            break;
+        }
+        if (leftIndex === -1)
+            return false;
+        brackets.splice(rightIndex, 1);
+        brackets.splice(leftIndex, 1);
+    }
+    return true;
+};
+const tokenize = (latex) => {
+    const tokens = [];
+    for (let i = 0; i < latex.length; i++) {
+        const char = latex[i];
+        if (char === " ")
+            continue;
+        const match = char.match(/[\+\-\(\)\^a-zA-Z_=\{\}]/);
+        if (match) {
+            tokens.push(char);
+            continue;
+        }
+        const substring = latex.substring(i);
+        const nbMatch = substring.match(/^[0-9]+,?[0-9]*/); //x nombres éventuellement séparés par une virgule
+        if (nbMatch) {
+            tokens.push(nbMatch[0].replace(",", "."));
+            i += nbMatch[0].length - 1;
+            continue;
+        }
+        const cmdMatch = substring.match(/^\\[a-z]+/i);
+        if (cmdMatch) {
+            tokens.push(cmdMatch[0]);
+            i += cmdMatch[0].length - 1;
+            continue;
+        }
+    }
+    return tokens;
+};
+exports.tokenize = tokenize;
+const parseLatex = (latex) => {
+    const formattedLatex = latex
+        .replaceAll("\\left", "")
+        .replaceAll("\\right", "");
+    const tokens = (0, exports.tokenize)(formattedLatex);
+    if (!isDyck(tokens))
+        throw Error("Problème de parenthèses.");
+    try {
+        const parsed = buildTree(tokens);
+        return parsed;
+    }
+    catch (err) {
+        throw err;
+    }
+};
+exports.parseLatex = parseLatex;
+const buildTree = (tokens) => {
+    let currentDepth = 0;
+    let maxDepth = 0;
+    const depthedTokens = [];
+    for (const token of tokens) {
+        if (token === "(" || token === "{")
+            currentDepth++;
+        depthedTokens.push({
+            token,
+            depth: currentDepth,
+        });
+        if (currentDepth > maxDepth)
+            maxDepth = currentDepth;
+        if (token === ")" || token === "}")
+            currentDepth--;
+    }
+    console.log("depthed: ", depthedTokens);
+    while (true) {
+        if (maxDepth === 0) {
+            const tree = buildTreeForSameDepthTokens(depthedTokens.map((el) => el.token));
+            return tree;
+        }
+        for (let i = 0; i < depthedTokens.length; i++) {
+            const token = depthedTokens[i];
+            if (token.depth < maxDepth)
+                continue;
+            //le token est forcément ici ( ou {
+            //et on est sur qu'il n'y a aucun autre nestage à l'intérieur
+            const endIndex = depthedTokens.findIndex((el, index) => index > i && (el.token === ")" || el.token === "}"));
+            const tree = buildTreeForSameDepthTokens(depthedTokens.slice(i + 1, endIndex).map((el) => el.token));
+            depthedTokens.splice(i, endIndex - i + 1, {
+                token: tree,
+                depth: token.depth - 1,
+            });
+            console.log(`depthed after iter ${i}`, depthedTokens);
+        }
+        maxDepth--;
+    }
+};
+const buildTreeForSameDepthTokens = (tokens) => {
+    console.log("start: ", tokens);
+    let tempTokens = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (typeof token !== "string") {
+            tempTokens[i] = token;
+            continue;
+        }
+        if (token[0].match(/[0-9]/)) {
+            tempTokens[i] = new numberNode_1.NumberNode(Number(token));
+        }
+        else if (token[0].match(/[a-z]/i))
+            tempTokens[i] = new variableNode_1.VariableNode(token);
+        //! les fonctions qui attendent un child ne sont pas encore parsées
+        else if (functions.includes(token)) {
+            tempTokens[i] = token;
+        }
+        //!idem pour les opérators
+        else if (operators.includes(token))
+            tempTokens[i] = token;
+        else
+            throw Error(`token not implemented: ${token}`);
+    }
+    console.log("after parses : ", tempTokens);
+    //1 build les fct
+    for (let i = 0; i < tempTokens.length; i++) {
+        if (typeof tempTokens[i] !== "string")
+            continue;
+        const token = tempTokens[i];
+        if (functions.includes(token)) {
+            if (typeof tempTokens[i + 1] === "string")
+                throw Error(`Function child has not been parsed at index ${i}`);
+            switch (token) {
+                case "\\sqrt":
+                    tempTokens[i] = new sqrtNode_1.SqrtNode(tempTokens[i + 1]);
+                    tempTokens.splice(i + 1, 1);
+                    break;
+                case "\\frac":
+                    tempTokens[i] = new fractionNode_1.FractionNode(tempTokens[i + 1], tempTokens[i + 2]);
+                    tempTokens.splice(i + 1, 2);
+            }
+        }
+        if (token === "^") {
+            if (!tempTokens[i - 1] ||
+                typeof tempTokens[i - 1] === "string" ||
+                !tempTokens[i + 1] ||
+                typeof tempTokens[i + 1] === "string")
+                throw Error("Error parsing power node");
+            else {
+                tempTokens[i - 1] = new powerNode_1.PowerNode(tempTokens[i - 1], tempTokens[i + 1]);
+                tempTokens.splice(i, 2);
+            }
+        }
+    }
+    //2 build les opposites
+    for (let i = 0; i < tempTokens.length; i++) {
+        const token = tempTokens[i];
+        if (token === "-") {
+            if (i === 0 ||
+                tempTokens[i - 1] === "\\times" ||
+                tempTokens[i - 1] === "+" ||
+                tempTokens[i - 1] === "-") {
+                //faire la liste des - conéscutifs
+                let j = i + 1;
+                while (tempTokens[j] === "-" && j < tempTokens.length) {
+                    j++;
+                }
+                if (j === tempTokens.length)
+                    throw Error("Nothing after minus");
+                const nextToken = tempTokens[j];
+                //! à ce stade, le nextToken est soit un node, soit : + ou \\times
+                //!on fait ici le choix d'interdire -+x
+                if (typeof nextToken === "string") {
+                    throw Error("Opposé pas clair");
+                }
+                const oppositeCount = j - i;
+                let node = nextToken;
+                for (let k = 0; k < oppositeCount; k++) {
+                    node = new oppositeNode_1.OppositeNode(node);
+                }
+                tempTokens[i] = node;
+                tempTokens.splice(i + 1, oppositeCount);
+            }
+        }
+    }
+    console.log("after fcts: ", tempTokens);
+    //3 build les *
+    let currentProduct;
+    let currentProductStartIndex;
+    for (let i = 0; i < tempTokens.length; i++) {
+        const token = tempTokens[i];
+        if (token === "\\times")
+            continue;
+        //la seule chose qui arrete un produit est + ou -
+        //y a t il d'autres cas ?
+        //? rappel ici on est sur une expression de niveau uniforme (sans parentheses ni childs)
+        if (token === "+" || token === "-") {
+            if (currentProduct &&
+                (0, multiplyNode_1.isMultiplyNode)(currentProduct) &&
+                currentProductStartIndex !== undefined) {
+                tempTokens[currentProductStartIndex] = currentProduct;
+                tempTokens.splice(currentProductStartIndex + 1, i - currentProductStartIndex - 1);
+                i = currentProductStartIndex + 1;
+            }
+            currentProduct = undefined;
+            currentProductStartIndex = undefined;
+            continue;
+        }
+        else {
+            if (currentProduct) {
+                currentProduct = new multiplyNode_1.MultiplyNode(currentProduct, token);
+            }
+            else {
+                currentProduct = token;
+                currentProductStartIndex = i;
+            }
+        }
+    }
+    if (currentProduct &&
+        (0, multiplyNode_1.isMultiplyNode)(currentProduct) &&
+        currentProductStartIndex !== undefined) {
+        tempTokens[currentProductStartIndex] = currentProduct;
+        tempTokens.splice(currentProductStartIndex + 1, tempTokens.length - 1 - currentProductStartIndex);
+    }
+    //4 build les +
+    let currentAdd;
+    console.log("beforeAdd", tempTokens);
+    for (let i = 0; i < tempTokens.length; i++) {
+        const token = tempTokens[i];
+        if (!currentAdd) {
+            if (typeof token === "string") {
+                if (token === "+" || token === "-") {
+                    throw Error("Addition with no first term");
+                }
+                else
+                    throw Error(`unexpected non parsed token ${token}`);
+            }
+            else {
+                currentAdd = token;
+            }
+        }
+        else {
+            if (typeof token !== "string" || (token !== "+" && token !== "-")) {
+                throw Error(`unexpected consecutive nodes without addition : ${token}`);
+            }
+            const next = tempTokens[i + 1];
+            if (typeof next === "string") {
+                throw Error(`unexpected non parsed token ${next}`);
+            }
+            else {
+                if (token === "+")
+                    currentAdd = new addNode_1.AddNode(currentAdd, next);
+                else
+                    currentAdd = new substractNode_1.SubstractNode(currentAdd, next);
+                i++;
+            }
+        }
+    }
+    return currentAdd;
+};

package/package.json

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