math-exercises 2.0.19 → 2.0.20

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

@@ -41,13 +41,16 @@ const runServer = () => {
     dotenv_1.default.config();
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
-    // const latex = "\\sqrt{3,230982}";
-    // try {
-    //   const res = parseLatex(latex);
-    //   console.log(res.toTex());
-    // } catch (err) {
-    //   throw err;
-    // }
+    // 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

@@ -1,3 +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

@@ -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;AA2BvD,eAAO,MAAM,UAAU,UAAW,MAAM,kBAgBvC,CAAC"}
+{"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

@@ -1,11 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseLatex = void 0;
-const isLetter_1 = require("../../utils/isLetter");
+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 isDyck = (latex) => {
-    const brackets = latex.split("").filter((el) => el === "(" || el === ")");
+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)
@@ -24,157 +41,247 @@ const isDyck = (latex) => {
     }
     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 isWellBracketed = isDyck(latex);
-    if (!isWellBracketed)
+    const tokens = (0, exports.tokenize)(formattedLatex);
+    if (!isDyck(tokens))
         throw Error("Problème de parenthèses.");
-    let currentTree;
-    let currentItem;
-    const length = formattedLatex.length;
     try {
-        const parsed = parseString(latex);
-        return parsed.node;
+        const parsed = buildTree(tokens);
+        return parsed;
     }
     catch (err) {
         throw err;
     }
 };
 exports.parseLatex = parseLatex;
-const parseString = (latex) => {
-    let currentTree;
-    let currentItem;
-    let currentAddCandidate;
-    const length = latex.length;
-    let jump = 0;
-    try {
-        for (let i = 0; i < length; i++) {
-            const char = latex[i];
-            const parsed = parseItem(latex);
-            currentItem = parsed.node;
-            currentTree = parsed.node;
-            jump = parsed.jump;
-            i += parsed.jump;
-        }
-        return {
-            node: currentTree,
-            jump,
-        };
+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--;
     }
-    catch (err) {
-        throw err;
+    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 parseItem = (latex) => {
-    const length = latex.length;
-    const char = latex[0];
-    if (charIsNumber(char)) {
-        return parseNumber(latex);
+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}`);
     }
-    else if (char === "\\") {
-        const cmdData = parseCommand(latex);
-        switch (cmdData.cmd) {
-            case "sqrt":
-                const childLatex = getChildLatex(latex.substring(cmdData.jump));
-                const parsedChild = parseString(childLatex);
-                return {
-                    node: new sqrtNode_1.SqrtNode(parsedChild.node),
-                    jump: parsedChild.jump,
-                };
-            default:
-                throw Error(`Commande ${cmdData.cmd} non gérée`);
+    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);
+            }
         }
     }
-    else if (char === "+") {
+    //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);
+            }
+        }
     }
-    throw Error(`Symbole ${char} non géré`);
-};
-/**
- *
- * @param latex latex[0] must be {
- *
- *
- * cette fonction extrait le latex d'un child,
- * par ex elle renverra "x" dans \\sqrt{x}
- */
-const getChildLatex = (latex) => {
-    const childStartIndex = 1;
-    let leftBracesCount = 0;
-    let childEndIndex = -1;
-    for (let i = childStartIndex; i < latex.length; i++) {
-        if (latex[i] === "{")
-            leftBracesCount++;
-        if (latex[i] === "}") {
-            if (leftBracesCount === 0) {
-                return latex.substring(1, i);
+    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;
             }
-            else
-                leftBracesCount--;
         }
     }
-    throw Error(`Erreur en récupérant un child dans ${latex}`);
-};
-/**
- *
- * @param latex latex[0] must be \
- */
-const parseCommand = (latex) => {
-    let nextChar = latex[1];
-    const length = latex.length;
-    if (!nextChar)
-        throw Error("Antislash mais pas de nom de commande");
-    let j = 1;
-    let cmd = "";
-    while (j < length && (0, isLetter_1.isLetter)(nextChar)) {
-        cmd += nextChar;
-        j++;
-        nextChar = latex[j];
+    if (currentProduct &&
+        (0, multiplyNode_1.isMultiplyNode)(currentProduct) &&
+        currentProductStartIndex !== undefined) {
+        tempTokens[currentProductStartIndex] = currentProduct;
+        tempTokens.splice(currentProductStartIndex + 1, tempTokens.length - 1 - currentProductStartIndex);
     }
-    return {
-        cmd,
-        jump: 1 + cmd.length,
-    };
-};
-/**
- *
- * @param latex latex[0] must be a number
- * @returns
- */
-const parseNumber = (latex) => {
-    const char = latex[0];
-    const length = latex.length;
-    let numberString = char;
-    let j = 1;
-    let nextChar = latex[j];
-    while (j < length && (charIsNumber(nextChar) || nextChar === ",")) {
-        numberString += nextChar;
-        j++;
-        nextChar = latex[j];
+    //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++;
+            }
+        }
     }
-    if (numberString[numberString.length - 1] === ",")
-        throw Error(`Nombre ${numberString} avec virgule mais sans partie décimale`);
-    if (numberString.split(",").length > 2)
-        throw Error(`Trop de virgules dans le nombre ${numberString}`);
-    const number = Number(numberString.replace(",", "."));
-    return {
-        node: new numberNode_1.NumberNode(number),
-        jump: numberString.length,
-    };
-};
-/***
- * Nombres
- * Constantes
- * Opérations :
- *  - +
- *  - -
- *  - *
- *  - /
- * Fonctions :
- *  - exp
- *  - ln
- */
-const charIsNumber = (s) => {
-    return ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"].includes(s);
+    return currentAdd;
 };

package/package.json

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