math-exercises 2.0.17 → 2.0.19

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/functions/affines/index.d.ts

@@ -3,4 +3,5 @@ export * from "./leadingCoefficientCalculV1";
 export * from "./leadingCoefficientCalculV2";
 export * from "./signFunction";
 export * from "./affineExpressionReading";
+export * from "./interceptReading";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/functions/affines/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC"}

package/lib/exercises/functions/affines/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./leadingCoefficientCalculV1"), exports);
 __exportStar(require("./leadingCoefficientCalculV2"), exports);
 __exportStar(require("./signFunction"), exports);
 __exportStar(require("./affineExpressionReading"), exports);
+__exportStar(require("./interceptReading"), exports);

package/lib/exercises/functions/affines/interceptReading.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    b: number;
+    secondPoint: number[];
+};
+export declare const interceptReading: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=interceptReading.d.ts.map

package/lib/exercises/functions/affines/interceptReading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/affines/interceptReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA+CF,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,WAAW,CAatD,CAAC"}

package/lib/exercises/functions/affines/interceptReading.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interceptReading = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const getInterceptReadingQuestion = () => {
+    const b = (0, randint_1.randint)(-5, 6);
+    const secondPoint = [(0, randint_1.randint)(-5, 6, [0]), (0, randint_1.randint)(-5, 6)];
+    const answer = b + "";
+    let xMin = Math.min(0, secondPoint[0]);
+    if (xMin > 0)
+        xMin = -0.5;
+    let xMax = Math.max(0, secondPoint[0]);
+    if (xMax < 0)
+        xMax = 0.5;
+    let yMin = Math.min(b, secondPoint[1]);
+    if (yMin > 0)
+        yMin = -0.5;
+    let yMax = Math.max(b, secondPoint[1]);
+    if (yMax < 0)
+        yMax = 0.5;
+    const coords = [xMin - 1, xMax + 1, yMin - 1, yMax + 1];
+    const question = {
+        answer,
+        instruction: `Ci-dessous est tracée la courbe représentative d'une fonction affine $f$. Déterminer graphiquement l'ordonnée à l'origine $b$ de la fonction $f$.`,
+        keys: [],
+        commands: [`Line((0, ${b}), (${secondPoint[0]}, ${secondPoint[1]}))`],
+        coords,
+        answerFormat: "tex",
+        identifiers: { b, secondPoint },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, b, secondPoint }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-5, 6) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, secondPoint, b }) => {
+    return ans === answer;
+};
+exports.interceptReading = {
+    id: "interceptReading",
+    connector: "=",
+    label: "Lire graphiquement l'ordonnée à l'origine",
+    levels: ["2nde", "1reESM", "1rePro", "1reSpé", "1reTech"],
+    isSingleStep: true,
+    sections: ["Droites", "Fonctions affines"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getInterceptReadingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/limits/limitReading.js

@@ -72,7 +72,7 @@ const getLimitReadingQuestion = () => {
     const question = {
         answer,
         instruction: `Ci-dessous est tracée la courbe représentative d'une fonction $f$. Déterminer la limite: $\\displaystyle ${new limitNode_1.LimitNode(to, new variableNode_1.VariableNode("f(x)"), from).toTex()}$`,
-        keys: [],
+        keys: ["infty"],
         commands: [fct],
         coords: [-10, 10, -10, 10],
         answerFormat: "tex",

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/index.d.ts

@@ -330,6 +330,9 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     b: number;
     secondPoint: number[];
+}> | import("./exercises/exercise").MathExercise<{
+    b: number;
+    secondPoint: number[];
 }> | import("./exercises/exercise").MathExercise<{
     rand: boolean;
     poly1: number[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/server.js

@@ -35,24 +35,19 @@ 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 latex = "\\sqrt{3,230982}";
+    // try {
+    //   const res = parseLatex(latex);
+    //   console.log(res.toTex());
+    // } catch (err) {
+    //   throw err;
+    // }
     app.get("/", (req, res) => {
         res.json(allExercises);
     });

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

@@ -0,0 +1,3 @@
+import { AlgebraicNode } from "../nodes/algebraicNode";
+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":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA2BvD,eAAO,MAAM,UAAU,UAAW,MAAM,kBAgBvC,CAAC"}

package/lib/tree/parsers/latexParser.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLatex = void 0;
+const isLetter_1 = require("../../utils/isLetter");
+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 === ")");
+    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 parseLatex = (latex) => {
+    const formattedLatex = latex
+        .replaceAll("\\left", "")
+        .replaceAll("\\right", "");
+    const isWellBracketed = isDyck(latex);
+    if (!isWellBracketed)
+        throw Error("Problème de parenthèses.");
+    let currentTree;
+    let currentItem;
+    const length = formattedLatex.length;
+    try {
+        const parsed = parseString(latex);
+        return parsed.node;
+    }
+    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,
+        };
+    }
+    catch (err) {
+        throw err;
+    }
+};
+const parseItem = (latex) => {
+    const length = latex.length;
+    const char = latex[0];
+    if (charIsNumber(char)) {
+        return parseNumber(latex);
+    }
+    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`);
+        }
+    }
+    else if (char === "+") {
+    }
+    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);
+            }
+            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];
+    }
+    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];
+    }
+    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);
+};

package/package.json

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