math-exercises 3.0.126 → 3.0.128

package/lib/exercises/math/equaDiff/equaDiffCheckSolutionFirstOrder.js

@@ -106,9 +106,6 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const equaDiffCheckSolutionFirstOrder = {
     id: "equaDiffCheckSolutionFirstOrder",
     label: "Vérifier si une fonction est solution d'une équation différentielle du premier ordre",
@@ -117,7 +114,6 @@ export const equaDiffCheckSolutionFirstOrder = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     answerType: "QCU",
     subject: "Mathématiques",
     getQuestionFromIdentifiers,

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

@@ -1 +1 @@
-{"version":3,"file":"affineAdjustmentComplete.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineAdjustmentComplete.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA0JF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}
+{"version":3,"file":"affineAdjustmentComplete.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineAdjustmentComplete.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA0JF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}

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

@@ -96,7 +96,6 @@ export const affineAdjustmentCompleteExercise = {
     label: "Déterminer l'équation de la droite d'ajustement et le coefficient de détermination",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getAffineAdjustmentCompleteQuestion, nb),
-    answerType: "QCU",
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

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

@@ -1 +1 @@
-{"version":3,"file":"coordsOfPointOnAffineFindX.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/coordsOfPointOnAffineFindX.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAuHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}
+{"version":3,"file":"coordsOfPointOnAffineFindX.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/coordsOfPointOnAffineFindX.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAqIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

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

@@ -6,6 +6,8 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { equationResolutionTex } from "../../../../tree/nodes/equations/equalNode.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { pointParser } from "../../../../tree/parsers/pointParser.js";
 const getInstruction = (identifiers) => {
     const { yValue, coeffs } = identifiers;
     const affine = AffineConstructor.fromCoeffs(coeffs);
@@ -69,6 +71,17 @@ const getPropositions = (n, { answer, coeffs, yValue }) => {
     tryToAddWrongProp(propositions, `(${frac(add(yValue, p), m).simplify().toTex()}, ${yValue.frenchify()})`);
     return shuffleProps(propositions, n);
 };
+const isAnswerValid = (ans, { answer }) => {
+    const pointAns = pointParser(ans);
+    if (!pointAns) {
+        return false;
+    }
+    const pointAnswer = pointParser(answer);
+    return [
+        [pointAns.x, pointAnswer.x],
+        [pointAns.y, pointAnswer.y],
+    ].every(([nodeAns, nodeAnswer]) => substract(nodeAns, nodeAnswer).evaluate() === 0);
+};
 const getCoordsOfPointOnAffineFindXQuestion = () => {
     const polynome1 = new Polynomial([randint(-9, 10), randint(-5, 6, [0])]);
     const xValue = randint(-9, 10);
@@ -80,7 +93,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         answer: getAnswer(identifiers),
-        keys: [],
+        keys: ["semicolon"],
         answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),
@@ -90,8 +103,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 export const coordsOfPointOnAffineFindX = {
     id: "coordsOfPointOnAffineFindX",
-    getPropositions,
-    label: "Déterminer les coordonnées d'un point appartenant à une courbe et dont on connaît l'ordonnée",
+    label: "Déterminer les coordonnées d'un point appartenant à une droite et dont on connaît l'ordonnée",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getCoordsOfPointOnAffineFindXQuestion, nb),
     qcmTimer: 60,
@@ -99,5 +111,6 @@ export const coordsOfPointOnAffineFindX = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
-    answerType: "QCU",
+    getPropositions,
+    isAnswerValid,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"coordsOfPointOnAffineFindY.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/coordsOfPointOnAffineFindY.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA6GF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}
+{"version":3,"file":"coordsOfPointOnAffineFindY.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/coordsOfPointOnAffineFindY.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA+HF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

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,14 +104,14 @@ 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",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
-    answerType: "QCU",
 };

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;AAkOF,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/recognizeAffineGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeAffineGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/recognizeAffineGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,UAAU,GAAG;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAmBF,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAgKF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAgBtD,CAAC"}
+{"version":3,"file":"recognizeAffineGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/recognizeAffineGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,UAAU,GAAG;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAmBF,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA6JF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

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

@@ -141,9 +141,6 @@ const getPropositions = (_, { answer, ...idenfitiers }) => {
     });
     return propositions;
 };
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const recognizeAffineGraph = {
     id: "recognizeAffineGraph",
     label: "Reconnaître la représentation graphique d'une fonction linéaire ou d'une fonction affine",
@@ -152,7 +149,6 @@ export const recognizeAffineGraph = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,

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,CAc3D,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,14 +221,14 @@ 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",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
-    answerType: "QCU",
 };

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

@@ -1 +1 @@
-{"version":3,"file":"isPointOnFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/isPointOnFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAI7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA0HF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAmBnD,CAAC"}
+{"version":3,"file":"isPointOnFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/isPointOnFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAG7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAmHF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}