math-exercises 3.0.53 → 3.0.54

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

@@ -2,13 +2,15 @@ import { isGGBLine } from "../../../../exercises/utils/geogebra/isGGBLine.js";
 import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { Line } from "../../../../math/geometry/line.js";
+import { Line, LineConstructor } from "../../../../math/geometry/line.js";
 import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector, VectorConstructor, } from "../../../../math/geometry/vector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { add } from "../../../../tree/nodes/operators/addNode.js";
-import { probaFlip } from "../../../../utils/alea/probaFlip.js";
 const getCartesianEquation = (identifiers) => {
-    const line = new Line(PointConstructor.fromIdentifiers(identifiers.AIds), PointConstructor.fromIdentifiers(identifiers.BIds));
+    const { pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    const line = LineConstructor.fromPointAndVector(point, vector);
     return line.getCartesianEquation();
 };
 const getInstruction = (identifiers) => {
@@ -32,8 +34,12 @@ const getStudentGGBOptions = (identifiers) => {
             point: true,
         }),
     });
+    const { pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    const B = vector.getEndPoint(point);
     return ggb.getOptions({
-        coords: [-10, 10, -10, 10],
+        coords: ggb.getCoordsForPoints([point, B]),
     });
 };
 const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
@@ -42,7 +48,6 @@ const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
     //transformer en vrai droite
     // checker si A et B sont sur la droite
     const lines = ans.filter((s) => isGGBLine(s));
-    console.log(lines);
     if (lines.length !== 1)
         return false;
     const pointNames = lines[0]
@@ -51,9 +56,7 @@ const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
         .replace("]", "")
         .replace(" ", "")
         .split(",");
-    console.log(pointNames);
     const pointCmds = ans.filter((s) => s.startsWith(pointNames[0] + "=") || s.startsWith(pointNames[1] + "="));
-    console.log(pointCmds);
     const pointsCoords = pointCmds.map((cmd) => cmd
         .split("=")[1]
         .replace("(", "")
@@ -62,28 +65,34 @@ const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
         .map((n) => Number(n)));
     const points = pointsCoords.map((coord) => new Point("A", coord[0], coord[1]));
     const line = new Line(points[0], points[1]);
-    // console.log(points);
-    const A = PointConstructor.fromIdentifiers(identifiers.AIds);
-    const B = PointConstructor.fromIdentifiers(identifiers.BIds);
-    return line.includes(A, 10) && line.includes(B, 10);
+    const { pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    const B = vector.getEndPoint(point);
+    return line.includes(point, 0.5) && line.includes(B, 0.5);
 };
 const getDrawLineFromCartesianEquationQuestion = () => {
-    const A = PointConstructor.random("A");
-    let B;
-    const isVertical = probaFlip(0.1);
-    const isHorizontal = probaFlip(0.1);
-    if (isVertical) {
-        B = new Point("B", A.x, add(A.y, 2));
-    }
-    else if (isHorizontal) {
-        B = new Point("B", add(A.x, 2), A.y);
-    }
-    else {
-        B = new Point("B", add(A.x, randint(-3, 4, [0])), add(A.y, randint(-3, 4, [0])));
-    }
+    const A = new Point("A", (0).toTree(), randint(-6, 7).toTree());
+    // let B: Point;
+    // const isVertical = probaFlip(0.1);
+    // const isHorizontal = probaFlip(0.1);
+    // if (isVertical) {
+    //   B = new Point("B", A.x, add(A.y, 2));
+    // } else if (isHorizontal) {
+    //   B = new Point("B", add(A.x, 2), A.y);
+    // } else {
+    //   B = new Point(
+    //     "B",
+    //     add(A.x, randint(-3, 4, [0])),
+    //     add(A.y, randint(-3, 4, [0])),
+    //   );
+    // }
+    const x = randint(-3, 4);
+    const y = randint(-3, 4, x === 0 ? [0] : undefined);
+    const vec = new Vector("u", x.toTree(), y.toTree());
     const identifiers = {
-        AIds: A.toIdentifiers(),
-        BIds: B.toIdentifiers(),
+        pointIds: A.toIdentifiers(),
+        vectorIds: vec.toIdentifiers(),
     };
     return getQuestionFromIdentifiers(identifiers);
 };

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { VectorIdentifiers } from "../../../../math/geometry/vector.js";
+type Identifiers = {
+    pointIds: PointIdentifiers;
+    vectorIds: VectorIdentifiers;
+};
+export declare const drawLineFromPointAndVector: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=drawLineFromPointAndVector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drawLineFromPointAndVector.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/drawLineFromPointAndVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAIvC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,EAAE,iBAAiB,CAAC;CAC9B,CAAC;AA0HF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}

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

@@ -0,0 +1,123 @@
+import { isGGBLine } from "../../../../exercises/utils/geogebra/isGGBLine.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Line, LineConstructor } from "../../../../math/geometry/line.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector, VectorConstructor, } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    return `Soit $d$ la droite passant par le point $${point.toTexWithCoords()}$ et ayant pour vecteur directeur $${vector.toTexWithCoords()}$. 
+    
+  Tracer la droite $d$.`;
+};
+const getHint = (identifiers) => {
+    return `Placer le point $A$. Puis, déterminer l'image du point $A$ par la translation de vecteur $\\overrightarrow{u}$. La droite recherchée passe par ces deux points.`;
+};
+const getCorrection = (identifiers) => {
+    const { pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    const B = vector.getEndPoint(point);
+    return `On place d'abord le point $A$. Puis, on détermine l'image du point $A$ par la translation de vecteur $\\overrightarrow{u}$. Cela nous donne le point  $${B.toTexWithCoords()}$. 
+  
+On relie alors les points $A$ et $B$ par une droite.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    const line = LineConstructor.fromPointAndVector(point, vector);
+    return line.toGGBCommands(true);
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    const B = vector.getEndPoint(point);
+    const ggb = new GeogebraConstructor({
+        customToolBar: toolBarConstructor({
+            point: true,
+            join: true,
+        }),
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([point, B]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    try {
+        //parse la line (si +1, faux)
+        // parse le spoints de la line
+        //transformer en vrai droite
+        // checker si A et B sont sur la droite
+        const lines = ans.filter((s) => isGGBLine(s));
+        if (lines.length !== 1)
+            return false;
+        const pointNames = lines[0]
+            .split("Line")[1]
+            .replace("[", "")
+            .replace("]", "")
+            .replace(" ", "")
+            .split(",");
+        const pointCmds = ans.filter((s) => s.startsWith(pointNames[0] + "=") || s.startsWith(pointNames[1] + "="));
+        const pointsCoords = pointCmds.map((cmd) => cmd
+            .split("=")[1]
+            .replace("(", "")
+            .replace(")", "")
+            .split(",")
+            .map((n) => Number(n)));
+        const points = pointsCoords.map((coord) => new Point("A", coord[0], coord[1]));
+        const line = new Line(points[0], points[1]);
+        const { pointIds, vectorIds } = identifiers;
+        const A = PointConstructor.fromIdentifiers(pointIds);
+        const vector = VectorConstructor.fromIdentifiers(vectorIds);
+        const B = vector.getEndPoint(A);
+        return line.includes(A, 0.5) && line.includes(B, 0.5);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getDrawLineFromPointAndVectorQuestion = () => {
+    const point = PointConstructor.random("A");
+    const vecX = randint(-3, 4, [0]);
+    const vecY = randint(-3, 4);
+    const vector = new Vector("u", vecX.toTree(), vecY.toTree());
+    const identifiers = {
+        pointIds: point.toIdentifiers(),
+        vectorIds: vector.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const drawLineFromPointAndVector = {
+    id: "drawLineFromPointAndVector",
+    label: "Tracer une droite à partir d'un point et d'un vecteur directeur",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDrawLineFromPointAndVectorQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    bIds: NodeIdentifiers;
+    cIds: NodeIdentifiers;
+    colinearityCoeffIds: NodeIdentifiers;
+    fakeCIds: NodeIdentifiers;
+};
+export declare const findParallelLineFromCartesianEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findParallelLineFromCartesianEquation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findParallelLineFromCartesianEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/findParallelLineFromCartesianEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,mBAAmB,EAAE,eAAe,CAAC;IACrC,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAgIF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAmBvE,CAAC"}

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

@@ -0,0 +1,130 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { LineConstructor } from "../../../../math/geometry/line.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { equal } from "../../../../tree/nodes/equations/equalNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getFakeEquation = (identifiers) => {
+    const { aIds, bIds, cIds, colinearityCoeffIds, fakeCIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fakeC = reifyAlgebraic(fakeCIds);
+    const coeff = reifyAlgebraic(colinearityCoeffIds);
+    const vec = new Vector("u", opposite(b), a);
+    const kVec = vec.times(coeff);
+    const fakeA = kVec.y;
+    const fakeB = opposite(kVec.x);
+    const equation = equal(add(add(multiply(fakeA, "x"), multiply(fakeB, "y")), fakeC), 0).simplify({
+        forbidFactorize: true,
+    });
+    return equation;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const equa = getFakeEquation(identifiers);
+    addValidProp(propositions, equa.toTex());
+    const goodLine = LineConstructor.fromCartesian(equa);
+    while (propositions.length < n) {
+        const line = doWhile(() => LineConstructor.random(), (l) => l.isParallele(goodLine));
+        tryToAddWrongProp(propositions, line.getCartesianEquation().toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    const equation = equal(add(add(multiply(a, "x"), multiply(b, "y")), c), 0).simplify({
+        forbidFactorize: true,
+    });
+    return `Soit $d$ une droite dont une équation cartésienne est : 
+  
+$$
+${equation.toTex()}
+$$
+
+Parmi les équations cartésiennes de droite suivantes, laquelle est celle d'une droite parallèle à $d$ ?`;
+};
+const getHint = (identifiers) => {
+    return `Deux droites sont parallèles si un vecteur directeur de l'un est colinéaire à un vecteur directeur de l'autre. On peut donc déterminer un vecteur directeur $\\overrightarrow{u}$ de $d$, puis déterminer un vecteur directeur de chacune des droites proposées, afin de trouver celui qui est colinéaire à $\\overrightarrow{u}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, cIds, colinearityCoeffIds, fakeCIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fakeC = reifyAlgebraic(fakeCIds);
+    const coeff = reifyAlgebraic(colinearityCoeffIds);
+    const fakeEqua = getFakeEquation(identifiers);
+    const vec = new Vector("u", opposite(b), a).simplify();
+    const kVec = vec.times(coeff, "v");
+    return `La droite $d$ admet pour vecteur directeur $${vec.toTexWithCoords()}$. Parmi les droites proposées, on cherche donc une droite qui a un vecteur directeur colinéaire à $${vec.toTex()}$.
+
+On remarque que la droite d'équation cartésienne :
+  
+$$
+${fakeEqua.toTex()}
+$$
+
+admet pour vecteur directeur $${kVec.toTexWithCoords()}$.
+
+Or les vecteurs $${vec.toTex()}$ et $${kVec.toTex()}$ sont colinéaires, puisque leur déterminant est nul :
+
+${alignTex([
+        ["", `\\det(${vec.toTex()},${kVec.toTex()})`],
+        ["=", vec.determinant(kVec).toTex()],
+        ["=", vec.determinant(kVec).simplify().toTex()],
+    ])}
+
+La droite parallèle à $d$ est donc la droite d'équation cartésienne :
+
+$$
+${fakeEqua.toTex()}
+$$
+`;
+};
+const getFindParallelLineFromCartesianEquationQuestion = (ops) => {
+    const line = LineConstructor.random();
+    const [a, b, c] = line.toCartesianCoeffs();
+    const coeff = randint(-3, 4, [0, 1]);
+    const fakeC = randint(-9, 10);
+    const identifiers = {
+        aIds: a.toIdentifiers(),
+        bIds: b.toIdentifiers(),
+        cIds: c.toIdentifiers(),
+        colinearityCoeffIds: coeff.toTree().toIdentifiers(),
+        fakeCIds: fakeC.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const findParallelLineFromCartesianEquation = {
+    id: "findParallelLineFromCartesianEquation",
+    label: "Droites parallèles via leurs équations cartésiennes",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindParallelLineFromCartesianEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    bIds: NodeIdentifiers;
+    fakeBIds: NodeIdentifiers;
+};
+export declare const findParallelLineFromReductEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findParallelLineFromReductEquation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findParallelLineFromReductEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/findParallelLineFromReductEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAqGF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAmBpE,CAAC"}

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

@@ -0,0 +1,109 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { equal } from "../../../../tree/nodes/equations/equalNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+const getEquation = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    return equal("y", add(multiply(a, "x"), b)).simplify({
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { aIds, bIds, fakeBIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const aEv = a.evaluate();
+    const b = reifyAlgebraic(bIds);
+    const fakeB = reifyAlgebraic(fakeBIds);
+    const ans = equal("y", add(multiply(a, "x"), fakeB)).simplify({
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+    });
+    addValidProp(propositions, ans.toTex());
+    while (propositions.length < n) {
+        const randA = randint(-9, 10, [aEv]);
+        const randB = randint(-9, 10);
+        const fakeEq = equal("y", add(multiply(randA, "x"), randB)).simplify({
+            forbidFactorize: true,
+            forceDistributeFractions: true,
+        });
+        tryToAddWrongProp(propositions, fakeEq.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getInstruction = (identifiers) => {
+    return `Soit $d$ la droite d'équation réduite : 
+  
+$$
+${getEquation(identifiers).toTex()}
+$$
+
+Parmi les équations réduites de droite suivantes, laquelle est celle d'une droite parallèle à $d$ ?`;
+};
+const getHint = (identifiers) => {
+    return `Deux droites sont parallèles si et seulement si leurs coefficients directeurs sont égaux.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, fakeBIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const fakeB = reifyAlgebraic(fakeBIds);
+    return `Deux droites sont parallèles si et seulement si leurs coefficients directeurs sont égaux.
+  
+Le coefficient directeur de $d$ est $${a.toTex()}$.
+
+Parmi les équations proposées, la seule qui représente une droite de coefficient directeur $${a.toTex()}$ est :
+
+$$
+${equal("y", add(multiply(a, "x"), fakeB))
+        .simplify({
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+    })
+        .toTex()}
+$$
+
+C'est donc cette équation qui représente une droite parallèle à $d$.
+`;
+};
+const getFindParallelLineFromReductEquationQuestion = (ops) => {
+    const a = randint(-9, 10);
+    const b = randint(-9, 10);
+    const fakeB = randint(-9, 10, [b]);
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        bIds: b.toTree().toIdentifiers(),
+        fakeBIds: fakeB.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const findParallelLineFromReductEquation = {
+    id: "findParallelLineFromReductEquation",
+    label: "Droites parallèles via leur équation réduite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindParallelLineFromReductEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -4,9 +4,14 @@ export * from "./cartesianEquationToReduced.js";
 export * from "./findPointOnLineWithCartesianEquation.js";
 export * from "./isPointOnLine.js";
 export * from "./isPointOnCartesianLine.js";
+export * from "./drawLineFromCartesianEquation.js";
 export * from "./reductEquationFindY.js";
 export * from "./reductEquationReading.js";
 export * from "./aAndBFromReductEquation.js";
 export * from "./reductEquationFromTwoPoints.js";
 export * from "./directorVectorFromReductEquation.js";
+export * from "./findParallelLineFromReductEquation.js";
+export * from "./findParallelLineFromCartesianEquation.js";
+export * from "./drawLineFromPointAndVector.js";
+export * from "./cartesianEquationsIntersection.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;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,iCAAiC,CAAC;AAChD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAE5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,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;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC"}

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

@@ -4,9 +4,13 @@ export * from "./cartesianEquationToReduced.js";
 export * from "./findPointOnLineWithCartesianEquation.js";
 export * from "./isPointOnLine.js";
 export * from "./isPointOnCartesianLine.js";
-// export * from "./drawLineFromCartesianEquation.js";
+export * from "./drawLineFromCartesianEquation.js";
 export * from "./reductEquationFindY.js";
 export * from "./reductEquationReading.js";
 export * from "./aAndBFromReductEquation.js";
 export * from "./reductEquationFromTwoPoints.js";
 export * from "./directorVectorFromReductEquation.js";
+export * from "./findParallelLineFromReductEquation.js";
+export * from "./findParallelLineFromCartesianEquation.js";
+export * from "./drawLineFromPointAndVector.js";
+export * from "./cartesianEquationsIntersection.js";

package/lib/exercises/math/geometry/perimeters/circleCircumference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circleCircumference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/circleCircumference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2CF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}
+{"version":3,"file":"circleCircumference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/circleCircumference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAmGF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}

package/lib/exercises/math/geometry/perimeters/circleCircumference.js

@@ -4,24 +4,73 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getCircleCircumference = () => {
-    const radius = randint(1, 13);
-    const diametre = randint(1, 21);
-    const coin = coinFlip();
+const getInstruction = (identifiers) => {
+    const { coin, radius, diametre } = identifiers;
+    return `Calculer la circonférence d'un cercle de ${coin ? "rayon " + `$${radius}$` : "diamètre " + `$${diametre}$`} cm.
+  
+Donner une réponse arrondie au centième.`;
+};
+const getAnswer = (identifiers) => {
+    const { coin, radius, diametre } = identifiers;
     const answerNb = coin
         ? round(2 * Math.PI * radius, 2)
         : round(Math.PI * diametre, 2);
     const answer = (answerNb + "").replace(".", ",");
     const answerTex = answer + "\\text{cm}";
+    return answerTex;
+};
+const getHint = (identifiers) => {
+    return `La circonférence d'un cercle de rayon $r$ est donnée par : 
+  
+$$
+C = 2\\pi r
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { coin, radius, diametre } = identifiers;
+    const isRadius = coin;
+    return `La circonférence d'un cercle de ${isRadius ? "rayon $r$" : "diamètre $d$"} est donnée par : 
+  
+$$
+C = ${isRadius ? "2\\pi r" : "\\pi\\times d"}
+$$
+
+${isRadius
+        ? `Ici, on a $r = ${radius}$ cm.
+  
+La circonférence est donc égale à : 
+
+$$
+C = 2\\pi \\times ${radius} \\approx ${getAnswer(identifiers)}
+$$`
+        : `Ici, on a  $d = ${diametre}$ cm.
+
+La circonférence est donc égale à : 
+
+$$
+C = \\pi \\times ${diametre} \\approx ${getAnswer(identifiers)}
+$$
+`}`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Calculer la circonférence d'un cercle de ${coin ? "rayon " + `$${radius}$` : "diamètre " + `$${diametre}$`} cm.`,
-        answer: answerTex,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         answerFormat: "tex",
         keys: ["cm", "cm2"],
-        identifiers: { coin, diametre, radius },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getCircleCircumference = () => {
+    const radius = randint(1, 13);
+    const diametre = randint(1, 21);
+    const coin = coinFlip();
+    const identifiers = { coin, diametre, radius };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -38,13 +87,13 @@ export const circleCircumference = {
     id: "circleCircumference",
     connector: "=",
     label: "Calculer la circonférence d'un cercle",
-    levels: ["4ème", "3ème", "2nde"],
     isSingleStep: false,
-    sections: ["Périmètres", "Géométrie euclidienne"],
     generator: (nb) => getDistinctQuestions(getCircleCircumference, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };