math-exercises 3.0.124 → 3.0.126

package/lib/exercises/math/functions/basics/coordsOfPointOnCurveFindY.js

@@ -0,0 +1,216 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/operatorNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const nodeByReplacingOperations = (node, replacementDict) => {
+    if (isOperatorNode(node)) {
+        const leftChild = nodeByReplacingOperations(node.leftChild, replacementDict);
+        const rightChild = nodeByReplacingOperations(node.rightChild, replacementDict);
+        const targetOperatorId = replacementDict[+node.id] ?? node.id;
+        switch (+targetOperatorId) {
+            case OperatorIds.add:
+                return add(leftChild, rightChild);
+            case OperatorIds.substract:
+                return substract(leftChild, rightChild);
+            case OperatorIds.multiply:
+                return multiply(leftChild, rightChild);
+            case OperatorIds.divide:
+                return frac(leftChild, rightChild);
+            case OperatorIds.power:
+                return power(leftChild, rightChild);
+            default:
+                return add(leftChild, rightChild);
+        }
+    }
+    else {
+        return node;
+    }
+};
+const nodeBySubstitutingX = (node, strVar) => {
+    return parseAlgebraic(node.toTex().replaceAll("x", `"${strVar}"`));
+};
+const getInstruction = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    return `Le point $M$ d'abscisse $${xValue}$ appartient à la courbe d'équation 
+
+$$
+y=${node.toTex()} 
+$$
+
+Quelles sont les coordonnées de $M$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const nodeWithXValue = nodeBySubstitutingX(node, `(${xValue})`);
+    const answer = `(${xValue.frenchify()};${nodeWithXValue
+        .simplify({ calculatePowers: true })
+        .toTex()})`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const texWithXM = node.toTex().replaceAll("x", "x_M");
+    const nodeWithXValue = nodeBySubstitutingX(node, `(${xValue})`);
+    return `Les coordonnées $(x_M;y_M)$ de $M$ vérifient:
+
+$$
+${texWithXM} = y_M 
+$$
+
+On doit calculer : 
+  
+$$
+y_M = ${nodeWithXValue.toTex()}  
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const texWithXM = node.toTex().replaceAll("x", "x_M");
+    const nodeWithXValue = nodeBySubstitutingX(node, `(${xValue})`);
+    const answer = getAnswer(identifiers);
+    return `Les coordonnées $(x_M;y_M)$ de $M$ vérifient:
+
+$$
+${texWithXM} = y_M 
+$$
+  
+On calcule : 
+  
+$$
+y_M = ${nodeWithXValue.toTex()} 
+$$
+
+$$
+y_M = ${answer.slice(1, -1).split(";")[1]}  
+$$
+
+Les coordonnées de $M$ sont donc $${answer}$.`;
+};
+const getPropositions = (n, { answer, questionFunc, xValue }) => {
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //power becomes multiply
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${nodeBySubstitutingX(nodeByReplacingOperations(node, {
+        [OperatorIds.power]: OperatorIds.multiply,
+    }), `(${xValue})`)
+        .simplify({ calculatePowers: true })
+        .toTex()})`);
+    //sign mistake
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${nodeBySubstitutingX(nodeByReplacingOperations(node, {
+        [OperatorIds.add]: OperatorIds.substract,
+        [OperatorIds.substract]: coinFlip()
+            ? OperatorIds.add
+            : OperatorIds.substract,
+    }), `(${xValue})`)
+        .simplify({ calculatePowers: true })
+        .toTex()})`);
+    //multiply becomes add
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${nodeBySubstitutingX(nodeByReplacingOperations(node, {
+        [OperatorIds.multiply]: OperatorIds.add,
+    }), `(${xValue})`)
+        .simplify({ calculatePowers: true })
+        .toTex()})`);
+    //let's try 0
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};0)`);
+    //(x,y) becomes (y,x)
+    if (propositions.length < n) {
+        const [x, y] = answer.slice(1, -1).split(";");
+        tryToAddWrongProp(propositions, `(${y};${x})`);
+    }
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, `(${xValue.frenchify()};${randint(-50, 50, [0])})`);
+        tryToAddWrongProp(propositions, `(${randint(-50, 50, [0])};${xValue.frenchify()})`);
+    }
+    return shuffleProps(propositions, n);
+};
+const getCoordsOfPointOnAffineFindYQuestion = () => {
+    const xValue = randint(-9, 10);
+    const questionFunc = random([
+        {
+            type: "...x^2",
+            nodeIds: new Polynomial([
+                randint(-9, 10),
+                randint(-5, 6),
+                randint(-2, 3, [0]),
+            ])
+                .toTree()
+                .toIdentifiers(),
+        },
+        {
+            type: "...x^3",
+            nodeIds: new Polynomial([
+                randint(-9, 10),
+                randint(-5, 6),
+                0,
+                randint(-1, 2, [0]),
+            ])
+                .toTree()
+                .toIdentifiers(),
+        },
+        {
+            type: "(x-...)(x-...)",
+            nodeIds: multiply(substract("x", randint(-3, 4, [xValue])), substract("x", randint(-3, 4, [0, xValue]))).toIdentifiers(),
+        },
+        {
+            type: "(x+...)(x-...)",
+            nodeIds: multiply(add("x", randint(-3, 4, [-xValue])), substract("x", randint(-3, 4, [0, xValue]))).toIdentifiers(),
+        },
+        {
+            type: "(x+...)(x+...)",
+            nodeIds: multiply(add("x", randint(-3, 4, [-xValue])), add("x", randint(-3, 4, [0, -xValue]))).toIdentifiers(),
+        },
+        {
+            type: "a/(x+...)",
+            nodeIds: frac(randint(-3, 4, [0]), add("x", randint(-3, 4, [0, -xValue]))).toIdentifiers(),
+        },
+        {
+            type: "(x+...)/(x+...)",
+            nodeIds: frac(add("x", randint(-3, 4)), add("x", randint(-3, 4, [0, -xValue]))).toIdentifiers(),
+        },
+    ]);
+    const identifiers = {
+        questionFunc,
+        xValue,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const coordsOfPointOnCurveFindY = {
+    id: "coordsOfPointOnCurveFindY",
+    getPropositions,
+    label: "Déterminer les coordonnées d'un point appartenant à une courbe et dont on connaît l'abscisse",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCoordsOfPointOnAffineFindYQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/basics/findZeroesProductQuotient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findZeroesProductQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/findZeroesProductQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AAkOF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAkB3D,CAAC"}
+{"version":3,"file":"findZeroesProductQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/findZeroesProductQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAuBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AA6QF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAkB3D,CAAC"}

package/lib/exercises/math/functions/basics/findZeroesProductQuotient.js

@@ -153,17 +153,44 @@ $$
 const getKeys = () => {
     return ["S", "equal", "lbrace", "semicolon", "rbrace"];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
         const parsed = discreteSetParser(ans);
         if (!parsed)
             return false;
-        return "S=" + parsed.simplify().toTex() === answer;
+        const roots = getRoots(identifiers).map((r) => r.simplify());
+        return isArrayOfNodesValid(parsed.elements, roots);
     }
     catch (err) {
         return handleVEAError(err);
     }
 };
+const isArrayOfNodesValid = (arrAns, arrAnswer) => {
+    //tried with toAllValidTexs() but there is always an unhandled case
+    function isNodesEqual(node1, node2) {
+        return [1, 1_000, 1_000_000].every((factor) => substract(multiply(factor, node1), multiply(factor, node2)).evaluate() === 0);
+    }
+    const dictAnswer = Object.fromEntries(arrAnswer.map((node, i) => [i, node]));
+    let isValid = true;
+    for (let i = 0; i < arrAns.length; i++) {
+        const nodeAns = arrAns[i];
+        let isFound = false;
+        const keys = Object.keys(dictAnswer);
+        for (let j = 0; j < keys.length; j++) {
+            const key = keys[j];
+            const answerNode = dictAnswer[key];
+            if (isNodesEqual(nodeAns, answerNode)) {
+                isFound = true;
+                delete dictAnswer[key]; //one-to-one correspondence
+                break;
+            }
+        }
+        isValid = isValid && isFound;
+        if (!isValid)
+            break;
+    }
+    return isValid;
+};
 const getFindZeroesProductQuotientQuestion = () => {
     const type = randint(0, 3);
     let a = 0;

package/lib/exercises/math/functions/basics/index.d.ts

@@ -15,4 +15,5 @@ export * from "./valueTableFromGraph.js";
 export * from "./isPointOnFunction.js";
 export * from "./countFunctionZeroes.js";
 export * from "./findZeroesProductQuotient.js";
+export * from "./coordsOfPointOnCurveFindY.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/basics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/functions/basics/index.js

@@ -15,3 +15,4 @@ export * from "./valueTableFromGraph.js";
 export * from "./isPointOnFunction.js";
 export * from "./countFunctionZeroes.js";
 export * from "./findZeroesProductQuotient.js";
+export * from "./coordsOfPointOnCurveFindY.js";

package/lib/exercises/math/functions/basics/inverseImageFunctionGeogebra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IAEjB,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAuNF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAkB9D,CAAC"}
+{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IAEjB,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAyOF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAkB9D,CAAC"}

package/lib/exercises/math/functions/basics/inverseImageFunctionGeogebra.js

@@ -56,74 +56,85 @@ const getGGBOptions = (identifiers) => {
     });
 };
 const getInverseImageFunctionGeogebra = () => {
-    const isLine = coinFlip();
-    const hasAntecedent = probaFlip(0.8);
-    // const isLine = false;
-    // const hasAntecedent = true;
-    let yValue;
-    const points = [];
-    if (isLine) {
-        if (hasAntecedent) {
-            yValue = randint(-6, 7);
-            const xIsDecimal = probaFlip(0.3);
-            const xValue = xIsDecimal
-                ? randfloat(-6, 7, 2, [yValue])
-                : randint(-6, 7, [yValue]);
-            const wrongY = randint(-6, 7);
-            points.push([xValue, yValue], [yValue, wrongY]);
-        }
-        else {
-            yValue = randint(-6, 7, [0]);
-            const constante = randint(-6, 7, [yValue]);
-            points.push([0, constante], [1, constante]);
-        }
-    }
-    else {
-        if (hasAntecedent) {
-            yValue = randint(-6, 7);
-            const xIsDecimal = coinFlip();
-            const xValue = xIsDecimal
-                ? randfloat(-6, 7, 2, [yValue])
-                : randint(-6, 7, [yValue]);
-            const hasTwoAntecedents = probaFlip(0.8);
-            if (hasTwoAntecedents) {
-                const wrongY = randint(-6, 7, [yValue]);
-                const secondAntecedentPoint = [
-                    randint(-6, 7, [xValue, yValue]),
-                    yValue,
-                ];
-                points.push([xValue, yValue], [yValue, wrongY], secondAntecedentPoint);
+    function generateIdentifiers() {
+        const isLine = coinFlip();
+        const hasAntecedent = probaFlip(0.8);
+        // const isLine = false;
+        // const hasAntecedent = true;
+        let yValue;
+        const points = [];
+        if (isLine) {
+            if (hasAntecedent) {
+                yValue = randint(-6, 7);
+                const xIsDecimal = probaFlip(0.3);
+                const xValue = xIsDecimal
+                    ? randfloat(-6, 7, 2, [yValue])
+                    : randint(-6, 7, [yValue]);
+                const wrongY = randint(-6, 7);
+                points.push([xValue, yValue], [yValue, wrongY]);
             }
             else {
-                //(x,y) is summit
-                const wrongY = randint(-6, 7, [yValue]);
-                points.push([xValue, yValue], [yValue, wrongY], [2 * xValue - yValue, wrongY]);
+                yValue = randint(-6, 7, [0]);
+                const constante = randint(-6, 7, [yValue]);
+                points.push([0, constante], [1, constante]);
             }
         }
         else {
-            yValue = randint(-8, 9);
-            const wrongY = randint(-3, 4, [yValue, yValue - 1, yValue + 1]);
-            const below = wrongY < yValue;
-            const summit = [
-                randint(-6, 7, [yValue]),
-                below
-                    ? randint(wrongY + 1, yValue, [wrongY])
-                    : randint(yValue + 1, wrongY, [wrongY]),
-            ];
-            const thirdPoint = [2 * summit[0] - yValue, wrongY];
-            //construire deux autrs points au pif avec y sous/audssu yValus
-            points.push([yValue, wrongY], summit, thirdPoint);
+            if (hasAntecedent) {
+                yValue = randint(-6, 7);
+                const xIsDecimal = coinFlip();
+                const xValue = xIsDecimal
+                    ? randfloat(-6, 7, 2, [yValue])
+                    : randint(-6, 7, [yValue]);
+                const hasTwoAntecedents = probaFlip(0.8);
+                if (hasTwoAntecedents) {
+                    const wrongY = randint(-6, 7, [yValue]);
+                    const secondAntecedentPoint = [
+                        randint(-6, 7, [xValue, yValue]),
+                        yValue,
+                    ];
+                    points.push([xValue, yValue], [yValue, wrongY], secondAntecedentPoint);
+                }
+                else {
+                    //(x,y) is summit
+                    const wrongY = randint(-6, 7, [yValue]);
+                    points.push([xValue, yValue], [yValue, wrongY], [2 * xValue - yValue, wrongY]);
+                }
+            }
+            else {
+                yValue = randint(-8, 9);
+                const wrongY = randint(-3, 4, [yValue, yValue - 1, yValue + 1]);
+                const below = wrongY < yValue;
+                const summit = [
+                    randint(-6, 7, [yValue]),
+                    below
+                        ? randint(wrongY + 1, yValue, [wrongY])
+                        : randint(yValue + 1, wrongY, [wrongY]),
+                ];
+                const thirdPoint = [2 * summit[0] - yValue, wrongY];
+                //construire deux autrs points au pif avec y sous/audssu yValus
+                points.push([yValue, wrongY], summit, thirdPoint);
+            }
         }
+        points.sort((p1, p2) => p1[0] - p2[0]);
+        const identifiers = {
+            // xValue,
+            // affineCoeffs: isAffine ? affine!.coefficients : undefined,
+            // trinomCoeffs: isAffine ? undefined : trinom!.coefficients,
+            yValue,
+            points,
+            // isAffine,
+        };
+        return identifiers;
     }
-    points.sort((p1, p2) => p1[0] - p2[0]);
-    const identifiers = {
-        // xValue,
-        // affineCoeffs: isAffine ? affine!.coefficients : undefined,
-        // trinomCoeffs: isAffine ? undefined : trinom!.coefficients,
-        yValue,
-        points,
-        // isAffine,
-    };
+    function isInfinityOfSolutions(identifiers) {
+        const { yValue, points } = identifiers;
+        return points.every((point) => point[1] === yValue);
+    }
+    let identifiers;
+    do {
+        identifiers = generateIdentifiers();
+    } while (isInfinityOfSolutions(identifiers));
     return getQuestionFromIdentifiers(identifiers);
 };
 const getHint = (identifiers) => {

package/lib/exercises/math/functions/composition/functionComposition.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIds: NodeIdentifiers[];
+};
+export declare const functionComposition: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=functionComposition.d.ts.map

package/lib/exercises/math/functions/composition/functionComposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/composition/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA+D7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AA+NF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}