math-exercises 3.0.48 → 3.0.50

package/lib/exercises/math/functions/trinoms/summitAndCanonical/summitAbscissFromRoots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"summitAbscissFromRoots.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/summitAbscissFromRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8CF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"summitAbscissFromRoots.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/summitAbscissFromRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoFF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

package/lib/exercises/math/functions/trinoms/summitAndCanonical/summitAbscissFromRoots.js

@@ -3,19 +3,52 @@ import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinct
 import { Rational } from "../../../../../math/numbers/rationals/rational.js";
 import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-const getSummitAbscissFromRootsQuestion = () => {
-    const trinom = TrinomConstructor.randomNiceRoots(2);
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRoots();
+    return `Soit $f(x) = ax^2+bx+c$ une fonction polynôme du second degé, dont les racines sont $${roots[0]}$ et $${roots[1]}$. 
+  
+Quelle est l'abscisse du sommet de la parabole représentant $f$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
     const roots = trinom.getRoots();
     const answer = new Rational(roots[0] + roots[1], 2)
         .simplify()
         .toTree()
         .toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `L'abscisse du sommet d'une parabole admettant deux racines est la moyenne des racines.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRoots();
+    return `L'ascisse $\\alpha$ du sommet de la parabole représentant $f$ est la moyenne des racines de $f$ : 
+  
+$$
+\\alpha = ${frac(add(roots[0], roots[1]), 2).toTex()} = ${getAnswer(identifiers)}
+$$`;
+};
+const getSummitAbscissFromRootsQuestion = () => {
+    const trinom = TrinomConstructor.randomNiceRoots(2);
+    const identifiers = { a: trinom.a, b: trinom.b, c: trinom.c };
     const question = {
-        answer,
-        instruction: `Soit $f(x) = ax^2+bx+c$ une fonction polynôme du second degé, dont les racines sont $${roots[0]}$ et $${roots[1]}$. Quelle est l'abscisse du sommet de la parabole représentant $f$ ?`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -31,25 +64,28 @@ const getPropositions = (n, { answer, a, b, c }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer, a, b, c }) => {
-    const trinom = new Trinom(a, b, c);
-    const node = trinom.getAlphaNode();
-    const texs = node.toAllValidTexs({
-        allowFractionToDecimal: true,
-        allowMinusAnywhereInFraction: true,
-    });
-    return texs.includes(ans);
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify({ decimalToFractions: true }).toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const summitAbscissFromRoots = {
     id: "summitAbscissFromRoots",
     connector: "=",
     label: "Déterminer l'abscisse du sommet d'une parabole en connaissant ses racines",
-    levels: ["1reSpé", "1rePro", "1reTech"],
     isSingleStep: true,
-    sections: ["Second degré"],
     generator: (nb) => getDistinctQuestions(getSummitAbscissFromRootsQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/cartesian/directionVectorEquation.d.ts

@@ -2,6 +2,7 @@ import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
     xValue: number;
     yValue: number;
+    c: number;
 };
 export declare const directionVectorEquation: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/geometry/cartesian/directionVectorEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directionVectorEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/directionVectorEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAwHF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"directionVectorEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/directionVectorEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AA+HF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}

package/lib/exercises/math/geometry/cartesian/directionVectorEquation.js

@@ -2,48 +2,55 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Vector } from "../../../../math/geometry/vector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { equal } from "../../../../tree/nodes/equations/equalNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
-import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
-import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
-function parseVector(input) {
-    const tex = input.replace("\\left", "");
-    const latex = tex.replace("\\right", "");
-    const regex = /\((-?\d+)\s*[;,]\s*(-?\d+)\)/;
-    const match = latex.match(regex);
-    if (match && match.length === 3) {
-        return {
-            x: parseInt(match[1], 10),
-            y: parseInt(match[2], 10),
-        };
-    }
-    return null;
-}
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { vectorParser } from "../../../../tree/parsers/vectorParser.js";
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds.c !== undefined)
+        return oldIds;
+    return {
+        xValue: oldIds.xValue,
+        yValue: oldIds.yValue,
+        c: randint(-5, 5),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { xValue, yValue, c } = identifiers;
+    const equation = equal(add(add(multiply(yValue.toTree(), "x"), multiply((-xValue).toTree(), "y")).simplify({ forbidFactorize: true }), c.toTree()), new NumberNode(0)).toTex();
+    return `Soit une droite $d$ d'équation cartésienne : 
+    
+$$
+${equation}
+$$ 
+    
+Déterminez les coordonnées d'un vecteur directeur de $d$.`;
+};
+const getAnswer = (identifiers) => {
+    const { xValue, yValue, c } = identifiers;
+    const vector = new Vector("v", xValue.toTree(), yValue.toTree());
+    return vector.toInlineCoordsTex();
+};
 const getDirectionVectorEquationQuestion = () => {
     let x1 = randint(-8, 8);
-    let x2 = randint(-8, 8);
-    while (x2 === x1) {
-        x2 = randint(-8, 8);
-    }
+    let x2 = randint(-8, 8, [x1]);
     let y1 = randint(-8, 8);
-    let y2 = randint(-8, 8);
-    while (y2 === y1) {
-        y2 = randint(-8, 8);
-    }
+    let y2 = randint(-8, 8, [y1]);
     const xValue = x2 - x1;
     const yValue = y2 - y1;
     const c = randint(-5, 5);
-    const vector = new Vector("v", xValue.toTree(), yValue.toTree());
-    const equation = new EqualNode(new AddNode(new AddNode(new MultiplyNode(yValue.toTree(), new VariableNode("x")), new MultiplyNode((-xValue).toTree(), new VariableNode("y"))).simplify({ forbidFactorize: true }), c.toTree()), new NumberNode(0)).toTex();
-    const question = {
-        answer: vector.toInlineCoordsTex(),
-        instruction: `Soit une droite $d$ d'équation cartésienne $${equation}$. Déterminez les coordonnées d'un vecteur directeur de $d$.`,
+    const identifiers = { xValue, yValue, c };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["semicolon", "x", "y"],
         answerFormat: "tex",
-        identifiers: { xValue, yValue },
+        identifiers,
     };
-    return question;
 };
 const getPropositions = (n, { answer, xValue, yValue }) => {
     const propositions = [];
@@ -70,13 +77,12 @@ const getPropositions = (n, { answer, xValue, yValue }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer, xValue, yValue }) => {
-    const parsed = parseVector(ans);
-    if (!parsed) {
+    const parsed = vectorParser(ans);
+    if (!parsed)
         return false;
-    }
     const { x, y } = parsed;
-    const correctVector = new Vector("v", xValue.toTree(), yValue.toTree());
-    const studentVector = new Vector("v", x.toTree(), y.toTree());
+    const correctVector = new Vector("u", xValue.toTree(), yValue.toTree());
+    const studentVector = new Vector("v", x, y);
     if (!studentVector.isColinear(correctVector)) {
         return false;
     }
@@ -85,13 +91,15 @@ const isAnswerValid = (ans, { answer, xValue, yValue }) => {
 export const directionVectorEquation = {
     id: "directionVectorEquation",
     label: "Coordonnées d'un vecteur directeur à partir d'une équation cartésienne",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Géométrie cartésienne"],
-    generator: (nb) => getDistinctQuestions(getDirectionVectorEquationQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(getDirectionVectorEquationQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getQuestionFromIdentifiers,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/geometry/lines/cartesianEquationToReduced.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    toReduced: boolean;
+};
+export declare const cartesianEquationToReduced: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=cartesianEquationToReduced.d.ts.map

package/lib/exercises/math/geometry/lines/cartesianEquationToReduced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianEquationToReduced.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/cartesianEquationToReduced.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAoLF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}

package/lib/exercises/math/geometry/lines/cartesianEquationToReduced.js

@@ -0,0 +1,171 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
+import { randint } from "../../../../math/utils/random/randint.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { monom } from "../../../../tree/nodes/polynomials/monomNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+//ax+by+c = 0 into y = ... (et inversement)
+const getCartesianEquation = (identifiers) => {
+    const { a, b, c, toReduced } = identifiers;
+    return add(add(monom(a, 1), monom(b, 1, { variable: "y" })), c).simplify({
+        forbidFactorize: true,
+    });
+};
+const getReducedEquation = (identifiers) => {
+    const { a, b, c, toReduced } = identifiers;
+    return frac(substract(-c, multiply(a, "x")), b).simplify({
+        towardsDistribute: true,
+        forceDistributeFractions: true,
+        forbidFactorize: true,
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { a, b, c, toReduced } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        if (toReduced) {
+            const bRand = randint(-9, 10);
+            const aRand = coinFlip()
+                ? RationalConstructor.randomIrreductible().toTree()
+                : randint(-9, 10);
+            tryToAddWrongProp(propositions, `y=${add(monom(aRand, 1), bRand).toTex()}`);
+        }
+        else {
+            const bRand = randint(-9, 10);
+            const aRand = randint(-9, 10);
+            const cRand = randint(-9, 10);
+            tryToAddWrongProp(propositions, `${add(monom(aRand, 1), add(monom(bRand, 1, { variable: "y" }), cRand)).toTex()}=0`);
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, toReduced } = identifiers;
+    const equation = toReduced
+        ? `y=${getReducedEquation(identifiers).toTex()}`
+        : `${getCartesianEquation(identifiers).toTex()}=0`;
+    return equation;
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c, toReduced } = identifiers;
+    const equation = toReduced
+        ? `${getCartesianEquation(identifiers).toTex()}=0`
+        : `y=${getReducedEquation(identifiers).toTex()}`;
+    return `Soit $d$ une droite d'équation ${toReduced ? "cartésienne" : "réduite"} : 
+  
+$$
+${equation}
+$$
+
+${toReduced
+        ? `Quelle est l'équation réduite de $d$ ?`
+        : `Donner une équation cartésienne de $d$.`}`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return "";
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return "";
+// };
+const getKeys = (identifiers) => {
+    return ["x", "y", "equal"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const { a, b, c, toReduced } = identifiers;
+        if (toReduced) {
+            const splitted = ans.split("=");
+            if (splitted[0] !== "y" || splitted.length !== 2)
+                return false;
+            const parsed = parseAlgebraic(splitted[1]);
+            return ("y=" +
+                parsed
+                    .simplify({
+                    towardsDistribute: true,
+                    forceDistributeFractions: true,
+                    forbidFactorize: true,
+                })
+                    .toTex() ===
+                answer);
+        }
+        else {
+            const splitted = ans.split("=");
+            if (splitted[1] !== "0" || splitted.length !== 2)
+                return false;
+            const parsed = parseAlgebraic(splitted[0]);
+            if (b === 0) {
+                const x = frac(-c, a).simplify();
+                return (parsed
+                    .toDetailedEvaluation({ x: x, y: (0).toTree() })
+                    .simplify()
+                    .toTex() === "0" &&
+                    parsed
+                        .toDetailedEvaluation({ x: x, y: (1).toTree() })
+                        .simplify()
+                        .toTex() === "0");
+            }
+            const validpoints = [
+                [(0).toTree(), frac(-c, b).simplify()],
+                [(1).toTree(), frac(-c - a, b).simplify()],
+            ];
+            return (parsed
+                .toDetailedEvaluation({ x: validpoints[0][0], y: validpoints[0][1] })
+                .simplify()
+                .toTex() === "0" &&
+                parsed
+                    .toDetailedEvaluation({ x: validpoints[1][0], y: validpoints[1][1] })
+                    .simplify()
+                    .toTex() === "0");
+        }
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCartesianEquationToReducedQuestion = (ops) => {
+    let a;
+    let b;
+    let c;
+    do {
+        a = randint(-9, 10);
+        b = randint(-9, 10, [0]);
+        c = randint(-9, 10, (a === 1 && b === 0) || (a === 0 && b === 1) ? [0] : undefined);
+    } while (gcd(a, b, c) !== 1 || (a <= 0 && b <= 0 && c <= 0));
+    const identifiers = { a, b, c, toReduced: coinFlip() };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+};
+export const cartesianEquationToReduced = {
+    id: "cartesianEquationToReduced",
+    label: "Passer d'équation réduite d'une droite à équation cartésienne, et inversement",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCartesianEquationToReducedQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/geometry/lines/findPointOnLineWithCartesianEquation.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+};
+export declare const findPointOnLineWithCartesianEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findPointOnLineWithCartesianEquation.d.ts.map

package/lib/exercises/math/geometry/lines/findPointOnLineWithCartesianEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findPointOnLineWithCartesianEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/findPointOnLineWithCartesianEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4IF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAqBtE,CAAC"}

package/lib/exercises/math/geometry/lines/findPointOnLineWithCartesianEquation.js

@@ -0,0 +1,146 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.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 { monom } from "../../../../tree/nodes/polynomials/monomNode.js";
+import { pointParser } from "../../../../tree/parsers/pointParser.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+//ax+by+c = 0
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const node = add(add(monom(a, 1), monom(b, 1, { variable: "y" })), c);
+    while (propositions.length < n) {
+        const point = doWhile(() => PointConstructor.random("A"), (p) => node.toDetailedEvaluation({ x: p.x, y: p.y }).simplify().toTex() ===
+            "0");
+        tryToAddWrongProp(propositions, point.toCoords());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    if (b === 0)
+        return new Point("A", frac(-c, a).simplify(), 0).toCoords();
+    return new Point("A", 0, frac(-c, b).simplify()).toCoords();
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c } = identifiers;
+    return `Soit $d$ la droite d'équation cartésienne : 
+  
+$$
+${add(add(monom(a, 1), monom(b, 1, { variable: "y" })), c).toTex()} = 0
+$$
+
+Donner les coordonnées d'un point appartenant à $d$.`;
+};
+const getHint = (identifiers) => {
+    const { a, b, c } = identifiers;
+    if (b === 0)
+        return `On peut isoler $x$ dans l'équation cartésienne de la droite, puis remarquer que $d$ est une droite verticale.`;
+    if (a === 0)
+        return `On peut isoler $y$ dans l'équation cartésienne de la droite, puis remarquer que $d$ est une droite horizontale.`;
+    return `On peut remplacer $x$ par une valeur quelconque $x_A$ dans l'équation de la droite, puis en déduire une valeur $y_A$ pour $y$. Le point de coordonnées $(x_A;y_A)$ est alors un point appartenant à $d$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const node = add(add(monom(a, 1), monom(b, 1, { variable: "y" })), c);
+    if (b === 0) {
+        const x = frac(-c, a).simplify();
+        return `On isole $x$ dans l'équation cartésienne de la droite : 
+    
+${alignTex([
+            [node.toTex(), "=", "0"],
+            ["x", "=", x.toTex()],
+        ])}
+
+On en déduit que tout point d'abscisse $${x.toTex()}$ appartient à $d$ (c'est à dire que $d$ est une droite verticale). Par exemple, le point $(${x.toTex()};0)$ appartient à $d$.`;
+    }
+    if (a === 0) {
+        const y = frac(-c, b).simplify();
+        return `On isole $y$ dans l'équation cartésienne de la droite : 
+    
+${alignTex([
+            [node.toTex(), "=", "0"],
+            ["y", "=", y.toTex()],
+        ])}
+
+On en déduit que tout point d'ordonnée $${y.toTex()}$ appartient à $d$ (c'est à dire que $d$ est une droite horizontale). Par exemple, le point $(0;${y.toTex()})$ appartient à $d$.`;
+    }
+    const detailed = node.toDetailedEvaluation({ x: (0).toTree() });
+    const simp = detailed.simplify();
+    const y = frac(-c, b).simplify();
+    return `On peut, par example, remplacer $x$ par $0$ dans l'équation de la droite :
+
+$$
+${detailed.toTex()} = ${simp.toTex()}
+$$
+
+On résout alors l'équation $${simp.toTex()} = 0$ : 
+
+${alignTex([
+        [simp.toTex(), "=", "0"],
+        ["y", "=", y.toTex()],
+    ])}
+$$
+${detailed.toTex()} = ${simp.toTex()}
+$$
+
+On en déduit que le point de coordonnées $(0;${y.toTex()})$ appartient à $d$.
+`;
+};
+const getKeys = (identifiers) => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const { a, b, c } = identifiers;
+        const parsed = pointParser(ans);
+        if (!parsed)
+            return false;
+        const node = add(add(multiply(a, parsed.x), multiply(b, parsed.y)), c);
+        return node.simplify().toTex() === "0";
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindPointOnLineWithCartesianEquationQuestion = (ops) => {
+    const a = randint(-9, 10);
+    const b = randint(-9, 10, a === 0 ? [0] : undefined);
+    const c = randint(-9, 10, (a === 1 && b === 0) || (a === 0 && b === 1) ? [0] : undefined);
+    const identifiers = { a, b, c };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const findPointOnLineWithCartesianEquation = {
+    id: "findPointOnLineWithCartesianEquation",
+    label: "Déterminer les coordonnées d'un point dans l'équation cartésienne d'une droite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindPointOnLineWithCartesianEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/lines/findPointOnLineWithReductEquation.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+};
+export declare const findPointOnLineWithReductEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findPointOnLineWithReductEquation.d.ts.map

package/lib/exercises/math/geometry/lines/findPointOnLineWithReductEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findPointOnLineWithReductEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/findPointOnLineWithReductEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyFF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAqBnE,CAAC"}