math-exercises 3.0.47 → 3.0.49

package/lib/exercises/math/calcul/addAndSub.d.ts

@@ -1,7 +1,13 @@
 import { Exercise } from "../../exercise.js";
+/**
+ * a±b±c±d
+ */
 type Identifiers = {
     numbers: number[];
 };
-export declare const addAndSubExercise: Exercise<Identifiers>;
+type Options = {
+    explicitWriting?: boolean;
+};
+export declare const addAndSubExercise: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=addAndSub.d.ts.map

package/lib/exercises/math/calcul/addAndSub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addAndSub.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/addAndSub.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAWT,MAAM,mBAAmB,CAAC;AAgD3B,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAkBzC,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAcnD,CAAC"}
+{"version":3,"file":"addAndSub.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/addAndSub.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAE3B;;GAEG;AAEH,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAYzC,KAAK,OAAO,GAAG;IACb,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAyEF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB5D,CAAC"}

package/lib/exercises/math/calcul/addAndSub.js

@@ -4,11 +4,17 @@ import { randint } from "../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { AddNode } from "../../../tree/nodes/operators/addNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-import { addValidProp, tryToAddWrongProp, } from "../../exercise.js";
-/**
- * a±b±c±d
- */
-const getStatementNode = (identifiers) => {
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../exercise.js";
+const options = [
+    {
+        id: "explicitWriting",
+        label: "Utiliser l'écriture explicite (parenthèses autour de chaque nombre)",
+        target: GeneratorOptionTarget.instruction,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
+const getStatementNode = (identifiers, opts) => {
     const { numbers } = identifiers;
     const allNumbersNodes = numbers.map((nb) => new NumberNode(nb));
     let statementTree = new AddNode(allNumbersNodes[0], allNumbersNodes[1]);
@@ -17,14 +23,16 @@ const getStatementNode = (identifiers) => {
     }
     return statementTree;
 };
-const getStartStatement = (identifiers) => {
-    return getStatementNode(identifiers).toTex();
+const getStartStatement = (identifiers, opts) => {
+    return getStatementNode(identifiers, opts).toTex({
+        explicitNumberWriting: opts?.explicitWriting,
+    });
 };
-const getInstruction = (identifiers) => {
+const getInstruction = (identifiers, opts) => {
     return `Calculer : 
   
 $$
-${getStartStatement(identifiers)}
+${getStartStatement(identifiers, opts)}
 $$`;
 };
 const getAnswer = (identifiers) => {
@@ -32,17 +40,20 @@ const getAnswer = (identifiers) => {
     const answer = numbers.reduce((a, b) => a + b) + "";
     return answer;
 };
-const getAddAndSubQuestions = () => {
+const getAddAndSubQuestions = (opts) => {
     const nbOperations = randint(2, 4);
     const numbers = [];
     for (let i = 0; i < nbOperations + 1; i++) {
         numbers.push(randint(-15, 15, [0]));
     }
+    if (numbers.every((n) => n > 0)) {
+        numbers[randint(0, numbers.length)] *= -1;
+    }
     const identifiers = { numbers };
     const question = {
-        instruction: getInstruction(identifiers),
-        startStatement: getStartStatement(identifiers),
-        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
         keys: [],
         answerFormat: "tex",
         identifiers,
@@ -67,7 +78,7 @@ export const addAndSubExercise = {
     connector: "=",
     label: "Additions et soustractions de nombres entiers",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getAddAndSubQuestions, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getAddAndSubQuestions(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -76,4 +87,5 @@ export const addAndSubExercise = {
     getInstruction,
     getAnswer,
     getStartStatement,
+    options,
 };

package/lib/exercises/math/calculLitteral/factorisation/factoIdRmq1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoIdRmq1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoIdRmq1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAuBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqIF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAkB7C,CAAC"}
+{"version":3,"file":"factoIdRmq1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoIdRmq1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqIF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAkB7C,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoIdRmq2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoIdRmq2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoIdRmq2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+HF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAkB7C,CAAC"}
+{"version":3,"file":"factoIdRmq2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoIdRmq2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+HF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAkB7C,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoIdRmq3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoIdRmq3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoIdRmq3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAmKF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAkB7C,CAAC"}
+{"version":3,"file":"factoIdRmq3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoIdRmq3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAmKF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAkB7C,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"affineExpressionReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineExpressionReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAkIF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"affineExpressionReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineExpressionReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAiIF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}

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

@@ -90,7 +90,6 @@ const isAnswerValid = (ans, { answer, secondPoint, b }) => {
             parsed
                 .simplify({
                 forbidFactorize: true,
-                forceIsolateMonomCoeffs: true,
                 decimalToFractions: true,
                 forceDistributeFractions: true,
             })

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

@@ -11,5 +11,4 @@ export * from "./affineAdjustmentRsquared.js";
 export * from "./affineAdjustmentComplete.js";
 export * from "./affineMeanValue.js";
 export * from "./affineExpressionFromTwoImages.js";
-export * from "./isPointOnLine.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC"}

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

@@ -11,4 +11,3 @@ export * from "./affineAdjustmentRsquared.js";
 export * from "./affineAdjustmentComplete.js";
 export * from "./affineMeanValue.js";
 export * from "./affineExpressionFromTwoImages.js";
-export * from "./isPointOnLine.js";

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"}

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

@@ -0,0 +1,99 @@
+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 { 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";
+//y = ax+b
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const node = add(monom(a, 1), b);
+    while (propositions.length < n) {
+        const point = doWhile(() => PointConstructor.random("A"), (p) => node.toDetailedEvaluation({ x: p.x }).simplify().toTex() ===
+            p.y.toTex());
+        tryToAddWrongProp(propositions, point.toCoords());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const point = new Point("A", 1, a + b);
+    return point.toCoords();
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Soit $d$ la droite d'équation : 
+  
+$$
+y = ${add(monom(a, 1), b).toTex()}
+$$
+
+Donner les coordonnées d'un point appartenant à $d$.`;
+};
+const getHint = (identifiers) => {
+    return "On peut remplacer $x$ dans l'équation de $d$ par une valeur quelconque $x_A$. Cela nous donne une valeur $y_A$ pour $y$. Le point $(x_A;y_A)$ est alors un point appartenant à $d$.";
+};
+const getCorrection = (identifiers) => {
+    const node = add(monom(identifiers.a, 1), identifiers.b);
+    const detailed = node.toDetailedEvaluation({ x: (1).toTree() });
+    const y = detailed.simplify();
+    return `On peut, par exemple, remplacer $x$ par $1$ dans l'équation de $d$ : 
+
+$$
+${detailed.toTex()} = ${y.toTex()} 
+$$
+
+On en déduit que le point de coordonnées $\\left(1;${y.toTex()}\\right)$ appartient à $d$. `;
+};
+const getKeys = (identifiers) => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer, a, b }) => {
+    try {
+        const parsed = pointParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.y.evaluate() === a * parsed.x.evaluate() + b;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindPointOnLineWithReductEquationQuestion = (ops) => {
+    const a = randint(-10, 10, [0]);
+    const b = randint(-10, 10, a === 1 ? [0] : undefined);
+    const identifiers = { a, b };
+    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 findPointOnLineWithReductEquation = {
+    id: "findPointOnLineWithReductEquation",
+    label: "Déterminer les coordonnées d'un point dans l'équation reduite d'une droite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindPointOnLineWithReductEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1,2 +1,7 @@
 export * from "./linesRelativePositions.js";
+export * from "./findPointOnLineWithReductEquation.js";
+export * from "./cartesianEquationToReduced.js";
+export * from "./findPointOnLineWithCartesianEquation.js";
+export * from "./isPointOnLine.js";
+export * from "./isPointOnCartesianLine.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,iCAAiC,CAAC;AAChD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC"}

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

@@ -1 +1,6 @@
 export * from "./linesRelativePositions.js";
+export * from "./findPointOnLineWithReductEquation.js";
+export * from "./cartesianEquationToReduced.js";
+export * from "./findPointOnLineWithCartesianEquation.js";
+export * from "./isPointOnLine.js";
+export * from "./isPointOnCartesianLine.js";

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    x: NodeIdentifiers;
+    y: NodeIdentifiers;
+    isOnLine: boolean;
+};
+export declare const isPointOnCartesianLine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isPointOnCartesianLine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isPointOnCartesianLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/isPointOnCartesianLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAiHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}