math-exercises 3.0.126 → 3.0.127

package/lib/exercises/math/functions/affines/coordsOfPointOnAffineFindY.js

@@ -1,9 +1,12 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
 import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { Polynomial } from "../../../../math/polynomials/polynomial.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { pointParser } from "../../../../tree/parsers/pointParser.js";
 const getInstruction = (identifiers) => {
     const { xValue, coeffs } = identifiers;
     const affine = AffineConstructor.fromCoeffs(coeffs);
@@ -15,11 +18,15 @@ $$
 
 Quelles sont les coordonnées de $M$ ?`;
 };
-const getAnswer = (identifiers) => {
+const getAnswerPoint = (identifiers) => {
     const { xValue, coeffs } = identifiers;
     const polynome = AffineConstructor.fromCoeffs(coeffs);
     const yValue = polynome.calculate(xValue);
-    const answer = `(${xValue.frenchify()};${yValue.frenchify()})`;
+    return new Point("A", xValue, yValue);
+};
+const getAnswer = (identifiers) => {
+    const answerPoint = getAnswerPoint(identifiers);
+    const answer = `(${answerPoint.x.toTex()};${answerPoint.y.toTex()})`;
     return answer;
 };
 const getHint = (identifiers) => {
@@ -61,12 +68,22 @@ const getPropositions = (n, { answer, coeffs, xValue }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     const poly = AffineConstructor.fromCoeffs(coeffs);
-    tryToAddWrongProp(propositions, `(${m.frenchify()}, ${p.frenchify()})`);
-    tryToAddWrongProp(propositions, `(${p.frenchify()}, ${m.frenchify()})`);
-    tryToAddWrongProp(propositions, `(${xValue.frenchify()}, ${multiply(m, xValue).simplify().toTex()})`);
-    tryToAddWrongProp(propositions, `(${xValue.frenchify()}, ${poly.calculate(1).frenchify()})`);
+    tryToAddWrongProp(propositions, `(${m.frenchify()};${p.frenchify()})`);
+    tryToAddWrongProp(propositions, `(${p.frenchify()};${m.frenchify()})`);
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${multiply(m, xValue).simplify().toTex()})`);
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${poly.calculate(1).frenchify()})`);
     return shuffleProps(propositions, n);
 };
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const pointAns = pointParser(ans);
+    if (!pointAns)
+        return false;
+    const pointAnswer = getAnswerPoint(identifiers);
+    return [
+        [pointAns.x, pointAnswer.x],
+        [pointAns.y, pointAnswer.y],
+    ].every(([ansNode, answerNode]) => substract(ansNode, answerNode).simplify().evaluate() === 0);
+};
 const getCoordsOfPointOnAffineFindYQuestion = () => {
     const polynome1 = new Polynomial([randint(-9, 10), randint(-5, 6, [0])]);
     const xValue = randint(-9, 10);
@@ -77,7 +94,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         answer: getAnswer(identifiers),
-        keys: [],
+        keys: ["semicolon"],
         answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),
@@ -87,10 +104,11 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 export const coordsOfPointOnAffineFindY = {
     id: "coordsOfPointOnAffineFindY",
-    getPropositions,
-    label: "Déterminer les coordonnées d'un point appartenant à une courbe et dont on connaît l'abscisse",
+    label: "Déterminer les coordonnées d'un point appartenant à une droite et dont on connaît l'abscisse",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getCoordsOfPointOnAffineFindYQuestion, nb),
+    getPropositions,
+    isAnswerValid,
     qcmTimer: 60,
     freeTimer: 60,
     subject: "Mathématiques",

package/lib/exercises/math/functions/affines/drawAffineFromProgCalc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drawAffineFromProgCalc.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/drawAffineFromProgCalc.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,mBAAmB,EAEpB,MAAM,iCAAiC,CAAC;AAMzC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAgNF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAC5B,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AAwBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBjE,CAAC"}
+{"version":3,"file":"drawAffineFromProgCalc.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/drawAffineFromProgCalc.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,mBAAmB,EAEpB,MAAM,iCAAiC,CAAC;AAOzC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA+NF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAC5B,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AAwBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBjE,CAAC"}

package/lib/exercises/math/functions/affines/drawAffineFromProgCalc.js

@@ -17,9 +17,8 @@ const getInstruction = (identifiers) => {
     const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
     return `La fonction $ ${funcName} $ est définie par le programme de calcul suivant :
 
-${progCalc.getArrOfFrenchStrings().map((str) => `
-
-${str}
+${progCalc.getArrOfFrenchStrings().map((str) => `> ${str}`).join(`
+  
 `)}
 
 Dans le repère, tracer la représentation de la fonction $ ${funcName} $.`;
@@ -35,23 +34,41 @@ Le point de coordonnées $ (x;${funcName}(x)) $ appartient à la droite qu'il fa
 `;
 };
 const getCorrection = (identifiers) => {
-    const { progCalcIds, funcName } = identifiers;
+    const { funcName, progCalcIds } = identifiers;
     const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
-    const xA = 0;
-    const yA = progCalc.apply(xA.toTree()).evaluate();
-    const xB = 1;
-    const yB = progCalc.apply(xB.toTree()).evaluate();
-    return `
-Toutes les fonctions dans le programme de calcul sont des fonctions affines,
-la fonction $ ${funcName} $ est donc une fonction affine. On va donc tracer une droite.
+    const nodeProgCalc = progCalc.toTree("x".toTree());
+    const nodeXA = (0).toTree();
+    const nodeYA = progCalc.apply(nodeXA).simplify();
+    const nodeXB = (1).toTree();
+    const nodeYB = progCalc.apply(nodeXB).simplify();
+    return `Si on exécute le programme de calcul avec $x$, on obtient: 
+
+$$
+${funcName}(x) =
+${nodeProgCalc.toTex({
+        allowMinusAnywhereInFraction: true,
+        allowDoubleMinus: true,
+        forceTimesSign: true,
+        forceParenthesis: true,
+    })} = ${nodeProgCalc
+        .simplify({
+        forbidFactorize: true,
+        towardsDistribute: true,
+        forceDistributeFractions: true,
+    })
+        .toTex()}
+$$
+
+On reconnaît l'expression d'une fonction affine.
+On va donc tracer une droite.
 
-Si on exécute le programme de calcul avec la valeur $ ${xA} $, on obtient $ ${yA} $.
-La droite passe donc par le point de coordonnées $(${xA};${yA})$.
+Si on exécute le programme de calcul avec la valeur $ ${nodeXA.toTex()} $, on obtient $ ${nodeYA.toTex()} $.
+La droite passe donc par le point de coordonnées $(${nodeXA.toTex()};${nodeYA.toTex()})$.
   
-Si on exécute le programme de calcul avec la valeur $ ${xB} $, on obtient $ ${yB} $.
-La droite passe donc par le point de coordonnées $(${xB};${yB})$.
+Si on exécute le programme de calcul avec la valeur $ ${nodeXB.toTex()} $, on obtient $ ${nodeYB.toTex()} $.
+La droite passe donc par le point de coordonnées $(${nodeXB.toTex()};${nodeYB.toTex()})$.
 
-On place donc les deux points de coordonnées $(${xA};${yA})$ et $(${xB};${yB})$, 
+On place donc les deux points de coordonnées $(${nodeXA.toTex()};${nodeYA.toTex()})$ et $(${nodeXB.toTex()};${nodeYB.toTex()})$, 
 puis on trace la droite passant par ces deux points.
 `;
 };

package/lib/exercises/math/functions/affines/representationOfAffine.d.ts

@@ -1,7 +1,10 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
 type Item = {
     tex: string;
     isValid: boolean;
+    point?: PointIdentifiers | undefined;
+    isPointValid?: boolean;
 };
 type Identifiers = {
     fName: string;

package/lib/exercises/math/functions/affines/representationOfAffine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"representationOfAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/representationOfAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAwOF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"representationOfAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/representationOfAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACrC,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAmWF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/functions/affines/representationOfAffine.js

@@ -1,9 +1,11 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
 import { AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { add } from "../../../../tree/nodes/operators/addNode.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";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -18,36 +20,83 @@ const primordialRightsAndWrongs = {
         `une fonction affine`,
     ],
 };
-const createRightsAndWrongs = (validSuffixFunc, invalidSuffixFuncs) => {
+const createRightsAndWrongs = (validSuffixObj, invalidSuffixObjs) => {
     return {
-        rights: primordialRightsAndWrongs.rights.map((rightStr) => (pointName) => validSuffixFunc(rightStr, pointName)),
+        rights: primordialRightsAndWrongs.rights.map((rightStr) => (pointName) => {
+            const point = validSuffixObj.nodeX &&
+                validSuffixObj.nodeY &&
+                new Point(pointName, validSuffixObj.nodeX, validSuffixObj.nodeY);
+            return {
+                str: validSuffixObj.suffixFunc(rightStr, pointName),
+                point,
+                isPointValid: point ? true : undefined,
+            };
+        }),
         wrongs: [
-            ...primordialRightsAndWrongs.wrongs.map((wrongStr) => (pointName) => validSuffixFunc(wrongStr, pointName)),
-            ...invalidSuffixFuncs.flatMap((invalidSuffixFunc) => primordialRightsAndWrongs.rights.map((rightStr) => (pointName) => invalidSuffixFunc(rightStr, pointName))),
+            ...primordialRightsAndWrongs.wrongs.map((wrongStr) => (pointName) => {
+                const point = validSuffixObj.nodeX &&
+                    validSuffixObj.nodeY &&
+                    new Point(pointName, validSuffixObj.nodeX, validSuffixObj.nodeY);
+                return {
+                    str: validSuffixObj.suffixFunc(wrongStr, pointName),
+                    point,
+                    isPointValid: point ? true : undefined,
+                };
+            }),
+            ...invalidSuffixObjs.flatMap((invalidSuffixObj) => primordialRightsAndWrongs.rights.map((rightStr) => (pointName) => {
+                const point = invalidSuffixObj.nodeX &&
+                    invalidSuffixObj.nodeY &&
+                    new Point(pointName, invalidSuffixObj.nodeX, invalidSuffixObj.nodeY);
+                return {
+                    str: invalidSuffixObj.suffixFunc(rightStr, pointName),
+                    point,
+                    isPointValid: point ? false : undefined,
+                };
+            })),
         ],
     };
 };
+const nodeBySubstitutingX = (node, strVar) => {
+    return parseAlgebraic(node.toTex().replaceAll("x", `({${strVar}})`));
+};
+const calculateWithNode = (f, nodeX) => {
+    return nodeBySubstitutingX(f.toTree(), nodeX.toTex()).simplify();
+};
 const createArrayOfRightsAndWrongs = (f) => {
-    function createRightAndWrongsCoords(f, x) {
-        const yR = f.calculate(x);
-        const yWs = [
-            f.a,
-            f.b,
-            add(f.a, f.b).evaluate(),
-            substract(f.a, f.b).evaluate(),
-        ].filter((yW) => yW !== yR);
+    function createRightAndWrongsCoords(f, nodeX) {
+        const nodeYR = calculateWithNode(f, nodeX);
+        const nodeYWs = [
+            f.a.toTree(),
+            f.b.toTree(),
+            add(f.a, f.b),
+            substract(f.a, f.b),
+        ].filter((yW) => substract(yW, nodeYR).evaluate() !== 0);
         return {
-            right: [x, yR],
-            wrongs: yWs.map((yW) => [x, yW]),
+            right: [nodeX, nodeYR],
+            wrongs: nodeYWs.map((nodeYW) => [nodeX, nodeYW]),
         };
     }
-    const coordObjects = [-1, 0, 1].map((x) => createRightAndWrongsCoords(f, x));
-    const strFunc = (str, pointName, x, y) => `${str} qui passe par $${pointName}(${x.frenchify()};${y.frenchify()})$`;
+    const coordObjects = [-1, 0, 1]
+        .map((x) => x.toTree())
+        .map((nodeX) => createRightAndWrongsCoords(f, nodeX));
+    const strFunc = (str, pointName, nodeX, nodeY) => `${str} qui passe par $${pointName}(${nodeX.simplify().toTex()};${nodeY
+        .simplify()
+        .toTex()})$`;
     return [
-        createRightsAndWrongs((str) => `${str}`, []),
-        ...coordObjects.flatMap((coordObject) => {
-            return createRightsAndWrongs((str, pointName) => strFunc(str, pointName, coordObject.right[0], coordObject.right[1]), coordObject.wrongs.map(([x, y]) => (str, pointName) => strFunc(str, pointName, x, y)));
-        }),
+        createRightsAndWrongs({
+            suffixFunc: (str) => `${str}`,
+        }, []),
+        ...coordObjects.flatMap((coordObject) => createRightsAndWrongs({
+            suffixFunc: (str, pointName) => strFunc(str, pointName, coordObject.right[0], coordObject.right[1]),
+            nodeX: coordObject.right[0],
+            nodeY: coordObject.right[1],
+        }, coordObject.wrongs.map(([nodeX, nodeY]) => {
+            return {
+                suffixFunc: (str, pointName) => strFunc(str, pointName, nodeX, nodeY),
+                nodeX,
+                nodeY,
+            };
+        }))),
     ];
 };
 const getInstruction = (identifiers) => {
@@ -65,20 +114,60 @@ const getHint = () => {
     return `Les fonctions affines et linéaires sont représentées par des droites.`;
 };
 const getCorrection = (identifiers) => {
-    const { fName } = identifiers;
+    const { fName, items, coeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(coeffs);
     const abstractFName = ["f", "g", "h"].find((letter) => letter !== fName);
-    return `Une fonction affine $${abstractFName}$ est de la forme 
-  
+    return `Une fonction affine $${abstractFName}$ est de la forme
+
 $$
 ${abstractFName}(x)=mx+p
 $$
 
-Sa représentation graphique est donc une droite qui passe, entre autres, par le point de coordonnées $(1;m+p)$ car
+Sa représentation graphique est une droite.
+
+$\\ $
+
+${items
+        .filter((item) => item.isValid && item.point && item.isPointValid)
+        .map((item) => {
+        const point = PointConstructor.fromIdentifiers(item.point);
+        const applyNode = nodeBySubstitutingX(affine.toTree(), point.x.toTex());
+        const texRaw = applyNode.toTex();
+        const texSimplified = applyNode.simplify().toTex();
+        return `On a :
+
+$$
+${fName}(${point.x.toTex()}) = ${texRaw} = ${texSimplified} 
+$$
+
+Donc elle passe par le point $${point.name}(${point.x.toTex()},${point.y.toTex()})$.`;
+    }).join(`
+
+$\\ $
+
+`)}
+
+$\\ $
+
+${items
+        .filter((item) => !item.isValid && item.point && !item.isPointValid)
+        .map((item) => {
+        const point = PointConstructor.fromIdentifiers(item.point);
+        const applyNode = nodeBySubstitutingX(affine.toTree(), point.x.toTex());
+        const texRaw = applyNode.toTex();
+        const texSimplified = applyNode.simplify().toTex();
+        return `On a :
 
 $$
-${abstractFName}(1)=m+p
+${fName}(${point.x.toTex()}) = ${texRaw} = ${texSimplified} \\neq ${point.y.toTex()}
 $$
-`;
+
+Donc le point $${point.name}(${point.x.toTex()},${point.y.toTex()})$ n'appartient pas à la droite représentant $${fName}$.`;
+    }).join(`
+  
+$\\ $
+
+`)}`;
 };
 const getPropositions = (_, { answer, ...idenfitiers }) => {
     const { items } = idenfitiers;
@@ -112,7 +201,7 @@ const getRepresentationOfAffineQuestion = () => {
         const index = random(allIndexes.filter((index) => !previouslyPickedIndexes.includes(index)));
         if (rightsAndWrongs[index].rights.length > 0) {
             return {
-                texFunc: random(rightsAndWrongs[index].rights),
+                objFunc: random(rightsAndWrongs[index].rights),
                 index,
             };
         }
@@ -129,7 +218,7 @@ const getRepresentationOfAffineQuestion = () => {
         const index = random(indexArray);
         if (rightsAndWrongs[index].wrongs.length > 0) {
             return {
-                texFunc: random(rightsAndWrongs[index].wrongs),
+                objFunc: random(rightsAndWrongs[index].wrongs),
                 index,
             };
         }
@@ -146,11 +235,13 @@ const getRepresentationOfAffineQuestion = () => {
                 ? getRightTexFunc(previouslyPickedIndexes)
                 : getWrongTexFunc(previouslyPickedIndexes);
         } while (!pick);
-        const tex = pick.texFunc(pointName);
+        const obj = pick.objFunc(pointName);
         previouslyPickedIndexes.push(pick.index);
         const item = {
-            tex,
+            tex: obj.str,
             isValid,
+            point: obj.point?.toIdentifiers(),
+            isPointValid: obj.isPointValid,
         };
         return item;
     }));

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

@@ -1 +1 @@
-{"version":3,"file":"coordsOfPointOnCurveFindY.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/coordsOfPointOnCurveFindY.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,gBAAgB,GACjB,QAAQ,GACR,QAAQ,GACR,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,WAAW,GACX,iBAAiB,CAAC;AAEtB,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAsRF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"coordsOfPointOnCurveFindY.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/coordsOfPointOnCurveFindY.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAe7C,KAAK,gBAAgB,GACjB,QAAQ,GACR,QAAQ,GACR,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,WAAW,GACX,iBAAiB,CAAC;AAEtB,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA0SF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

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

@@ -1,5 +1,6 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
 import { Polynomial } from "../../../../math/polynomials/polynomial.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
@@ -10,6 +11,7 @@ import { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/o
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { pointParser } from "../../../../tree/parsers/pointParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 const nodeByReplacingOperations = (node, replacementDict) => {
@@ -50,13 +52,15 @@ $$
 
 Quelles sont les coordonnées de $M$ ?`;
 };
-const getAnswer = (identifiers) => {
+const getAnswerPoint = (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 new Point("A", xValue.toTree(), nodeWithXValue.simplify({ calculatePowers: true }));
+};
+const getAnswer = (identifiers) => {
+    const answerPoint = getAnswerPoint(identifiers);
+    const answer = `(${answerPoint.x.toTex()};${answerPoint.y.toTex()})`;
     return answer;
 };
 const getHint = (identifiers) => {
@@ -138,6 +142,16 @@ const getPropositions = (n, { answer, questionFunc, xValue }) => {
     }
     return shuffleProps(propositions, n);
 };
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const pointAns = pointParser(ans);
+    if (!pointAns)
+        return false;
+    const pointAnswer = getAnswerPoint(identifiers);
+    return [
+        [pointAns.x, pointAnswer.x],
+        [pointAns.y, pointAnswer.y],
+    ].every(([ansNode, answerNode]) => substract(ansNode, answerNode).simplify().evaluate() === 0);
+};
 const getCoordsOfPointOnAffineFindYQuestion = () => {
     const xValue = randint(-9, 10);
     const questionFunc = random([
@@ -164,15 +178,15 @@ const getCoordsOfPointOnAffineFindYQuestion = () => {
         },
         {
             type: "(x-...)(x-...)",
-            nodeIds: multiply(substract("x", randint(-3, 4, [xValue])), substract("x", randint(-3, 4, [0, xValue]))).toIdentifiers(),
+            nodeIds: multiply(substract("x", randint(-3, 4, [0, 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(),
+            nodeIds: multiply(add("x", randint(-3, 4, [0, -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(),
+            nodeIds: multiply(add("x", randint(-3, 4, [0, -xValue])), add("x", randint(-3, 4, [0, -xValue]))).toIdentifiers(),
         },
         {
             type: "a/(x+...)",
@@ -180,7 +194,11 @@ const getCoordsOfPointOnAffineFindYQuestion = () => {
         },
         {
             type: "(x+...)/(x+...)",
-            nodeIds: frac(add("x", randint(-3, 4)), add("x", randint(-3, 4, [0, -xValue]))).toIdentifiers(),
+            nodeIds: (() => {
+                const a = randint(-3, 4, [0]);
+                const b = randint(-3, 4, [0, -xValue, a]);
+                return frac(add("x", a), add("x", b)).toIdentifiers();
+            })(),
         },
     ]);
     const identifiers = {
@@ -193,7 +211,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         answer: getAnswer(identifiers),
-        keys: [],
+        keys: ["semicolon"],
         answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),
@@ -203,10 +221,11 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 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),
+    getPropositions,
+    isAnswerValid,
     qcmTimer: 60,
     freeTimer: 60,
     subject: "Mathématiques",

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

@@ -1 +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"}
+{"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;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA+D7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AA8NF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

package/lib/exercises/math/functions/composition/functionComposition.js

@@ -1,6 +1,7 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { realize } from "../../../../math/utils/latex/realize.js";
+import { randint } from "../../../../math/utils/random/randint.js";
 import { isFunctionNode, } from "../../../../tree/nodes/functions/functionNode.js";
 import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
 // import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
@@ -186,9 +187,8 @@ const getFunctionCompositionQuestion = (_) => {
     function getRandomNode() {
         return random([
             ...[
-                `x`,
                 realize({ a: "I" })(`x+a`),
-                realize({ a: "I" })(`ax`),
+                realize({ a: { custom: () => randint(2, 10).toTree() } })(`ax`),
                 realize({ a: "I", b: "I" })(`ax+b`),
                 realize({ a: "I", b: "I" })(`(ax+b)^2`),
                 realize({ a: "RI", b: "RI" })(`(x+a)(x+b)`),

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"possibleValuesForProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/possibleValuesForProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AA2EF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAwMF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}
+{"version":3,"file":"possibleValuesForProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/possibleValuesForProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AA2EF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAuNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.js

@@ -19,10 +19,10 @@ import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
     const { isFilterPossibleProba } = identifiers;
-    return `Parmi les valeurs de la liste ci-dessous, donner celles qui sont des valeurs ${isFilterPossibleProba ? "possibles" : "impossibles"} pour une probabilité.`;
+    return `Parmi les valeurs de la liste ci-dessous, donner celles qui sont des valeurs ${isFilterPossibleProba ? "**possibles**" : "**impossibles**"} pour une probabilité.`;
 };
 const getHint = () => {
-    return "Une probabilité est toujours comprise entre $0\\%$ et $100\\%$.";
+    return "Une probabilité est un nombre compris entre $0$ et $1$.";
 };
 const getCorrection = (identifiers) => {
     const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
@@ -69,7 +69,14 @@ const getPropositions = (_, { answer, ...identifiers }) => {
     return propositions;
 };
 const optsDefault = {
-    numberTypes: ["Entier", "Décimal", "Fraction", "Puiss10", "Sci", "Réel"],
+    numberTypes: [
+        "Entier",
+        "Décimal",
+        "Fraction",
+        "Puissance de 10",
+        "Écriture scientifique",
+        "Réel",
+    ],
 };
 const options = [
     {
@@ -77,7 +84,14 @@ const options = [
         label: "Types de nombres",
         type: GeneratorOptionType.multiselect,
         target: GeneratorOptionTarget.generation,
-        values: ["Entier", "Décimal", "Fraction", "Puiss10", "Sci", "Réel"],
+        values: [
+            "Entier",
+            "Décimal",
+            "Fraction",
+            "Puissance de 10",
+            "Écriture scientifique",
+            "Réel",
+        ],
         defaultValue: optsDefault.numberTypes,
     },
 ];
@@ -98,9 +112,9 @@ const createRandomNode = (numberType, isPossibleProba) => {
                     return frac(num, den);
                 }
             }
-            case "Puiss10":
+            case "Puissance de 10":
                 return power(10, randint(-15, 1));
-            case "Sci":
+            case "Écriture scientifique":
                 if (probaFlip(0.7)) {
                     return multiply(randfloat(1, 10, randint(1, 5)), power(10, randint(-15, 0)));
                 }
@@ -142,9 +156,9 @@ const createRandomNode = (numberType, isPossibleProba) => {
                     return frac(num, den);
                 }
             }
-            case "Puiss10":
+            case "Puissance de 10":
                 return power(10, randint(1, 15));
-            case "Sci":
+            case "Écriture scientifique":
                 if (probaFlip(0.7)) {
                     return coinFlip()
                         ? multiply(randfloat(1, 10, randint(1, 5), [1]), power(10, randint(0, 15)))
@@ -175,10 +189,11 @@ const getPossibleValuesForProbaQuestion = (optsIn) => {
     //create numberType list
     const dictNumberTypeToPriority = {
         Entier: 1,
-        Puiss10: 2,
+        "Puissance de 10": 2,
         Décimal: 3,
         Fraction: 4,
         Réel: 5,
+        "Écriture scientifique": 6,
     };
     let arrNumberType = [...opts.numberTypes];
     //filler

package/lib/exercises/math/probaStat/conditionalProbaWriteFromFrench.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conditionalProbaWriteFromFrench.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/conditionalProbaWriteFromFrench.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAK3B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0QF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAejE,CAAC"}
+{"version":3,"file":"conditionalProbaWriteFromFrench.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/conditionalProbaWriteFromFrench.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAK3B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8QF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAejE,CAAC"}

package/lib/exercises/math/probaStat/conditionalProbaWriteFromFrench.js

@@ -108,9 +108,13 @@ const getInstruction = (identifiers) => {
     let instruction = `${situation.context}`;
     instruction += `
 
-Soit A l'évenement : "${situation.strA}".
+Soit $A$ l'évenement : 
 
-Soit B l'évenement : "${situation.strB}".`;
+> ${situation.strA}
+
+Soit $B$ l'évenement : 
+
+> ${situation.strB}`;
     instruction += `
 
 Écris en langage mathématique : 
@@ -179,9 +183,9 @@ const getQuestionFromIdentifiers = (identifiers) => {
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    tryToAddWrongProp(propositions, `P(A\\cap B)`, "tex");
-    tryToAddWrongProp(propositions, `P_A(B)`, "tex");
-    tryToAddWrongProp(propositions, `P_B(A)`, "tex");
+    tryToAddWrongProp(propositions, `P\\left(A\\cap B\\right)`, "tex");
+    tryToAddWrongProp(propositions, `P_A\\left(B\\right)`, "tex");
+    tryToAddWrongProp(propositions, `P_B\\left(A\\right)`, "tex");
     tryToAddWrongProp(propositions, `P(A)`, "tex");
     tryToAddWrongProp(propositions, `P(B)`, "tex");
     return shuffleProps(propositions, n);