math-exercises 3.0.53 → 3.0.55

package/lib/exercises/math/geometry/areas/circleArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circleArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/circleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAmDF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}
+{"version":3,"file":"circleArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/circleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAsGF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}

package/lib/exercises/math/geometry/areas/circleArea.js

@@ -17,17 +17,60 @@ const getAnswer = (identifiers) => {
     const answerTex = answer + "\\text{cm}^2";
     return answerTex;
 };
+const getHint = (identifiers) => {
+    return `La formule de l'aire d'un disque est : 
+  
+$$
+A = \\pi\\times r^2
+$$
+
+où $r$ est le rayon du disque.`;
+};
+const getCorrection = (identifiers) => {
+    const { coin, radius, diametre } = identifiers;
+    const isRadius = coin;
+    return `La formule de l'aire d'un disque est : 
+  
+$$
+A = \\pi\\times r^2
+$$
+
+où $r$ est le rayon du disque.
+
+${isRadius
+        ? `On remplace donc $r$ par $${radius}$ : 
+  
+$$
+A = \\pi \\times ${radius}^2 \\approx ${getAnswer(identifiers)}
+$$`
+        : `Puisque le diamètre est de $${diametre}$ cm, le rayon vaut : 
+
+$$
+r = \\frac{${diametre}}{2} = ${(diametre / 2).frenchify()} \\ \\text{cm}
+$$
+
+L'aire du disque vaut donc : 
+
+$$
+A = \\pi \\times ${(diametre / 2).frenchify()}^2 \\approx ${getAnswer(identifiers)}
+$$`}`;
+};
 const getCircleArea = () => {
     const radius = randint(1, 13);
     const diametre = randint(1, 21);
     const coin = coinFlip();
     const identifiers = { coin, diametre, radius };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         answer: getAnswer(identifiers),
         answerFormat: "tex",
         keys: ["cm", "cm2"],
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -47,9 +90,7 @@ export const circleArea = {
     id: "circleArea",
     connector: "=",
     label: "Calculer l'aire d'un disque",
-    levels: ["4ème", "3ème", "2nde"],
     isSingleStep: false,
-    sections: ["Aires", "Géométrie euclidienne"],
     generator: (nb) => getDistinctQuestions(getCircleArea, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -58,4 +99,6 @@ export const circleArea = {
     subject: "Mathématiques",
     getInstruction,
     getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/areas/squareArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/squareArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAgCF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAc5C,CAAC"}
+{"version":3,"file":"squareArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/squareArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAqEF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAc5C,CAAC"}

package/lib/exercises/math/geometry/areas/squareArea.js

@@ -2,19 +2,52 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getSquareArea = () => {
-    const side = randint(1, 21);
+const getInstruction = (identifiers) => {
+    const { side } = identifiers;
+    return `Calculer l'aire d'un carré de $${side}$ cm de côté.`;
+};
+const getAnswer = (identifiers) => {
+    const { side } = identifiers;
     const answer = side ** 2 + "";
     const answerTex = answer + "\\text{cm}^2";
+    return answerTex;
+};
+const getHint = (identifiers) => {
+    return `L'aire d'un carré s'obtient en multipliant la longueur d'un côté par elle-même.`;
+};
+const getCorrection = (identifiers) => {
+    const { side } = identifiers;
+    return `L'aire d'un carré de côté $c$ est : 
+  
+$$
+A = c\\times c
+$$
+
+Ici, on a $c = ${side}$ cm.
+
+L'aire du carré vaut donc : 
+
+$$
+A = ${side}\\times${side} = ${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Calculer l'aire d'un carré de $${side}$ cm de côté.`,
-        answer: answerTex,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         answerFormat: "tex",
         keys: ["cm", "cm2"],
-        identifiers: { side },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getSquareArea = () => {
+    const side = randint(1, 21);
+    const identifiers = { side };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -31,9 +64,7 @@ export const squareArea = {
     id: "squareArea",
     connector: "=",
     label: "Calculer l'aire d'un carré",
-    levels: ["4ème", "3ème", "2nde"],
     isSingleStep: false,
-    sections: ["Aires", "Géométrie euclidienne"],
     generator: (nb) => getDistinctQuestions(getSquareArea, nb, 20),
     qcmTimer: 60,
     freeTimer: 60,
@@ -41,4 +72,6 @@ export const squareArea = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/areas/triangleArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangleArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/triangleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AASnD,OAAO,EAGL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAKxC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,kBAAkB,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA6GF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAiB9C,CAAC"}
+{"version":3,"file":"triangleArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/triangleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAOnD,OAAO,EAGL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAKxC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,kBAAkB,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA4GF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAiB9C,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"cartesianEquationOfLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianEquationOfLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAqBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA0KF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}
+{"version":3,"file":"cartesianEquationOfLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianEquationOfLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAqBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAyNF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

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

@@ -3,12 +3,13 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { Line } from "../../../../math/geometry/line.js";
 import { Point } from "../../../../math/geometry/point.js";
-import { Vector } from "../../../../math/geometry/vector.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
@@ -24,6 +25,43 @@ const getAnswer = (identifiers) => {
     const correctAnswer = line.getCartesianEquation();
     return correctAnswer.toTex();
 };
+const getHint = (identifiers) => {
+    return `Détermine un vecteur directeur de $d$. Cela permet de trouver les coefficients $a$ et $b$ dans l'équation cartésienne $ax+by+c=0$. Puis, utilise un point appartenant à $d$ pour obtenir $c$. `;
+};
+const getCorrection = (identifiers) => {
+    const { aX, aY, bX, bY } = identifiers;
+    const A = new Point("A", aX, aY);
+    const B = new Point("B", bX, bY);
+    const vec = VectorConstructor.fromPoints(A, B);
+    const partial = add(multiply(opposite(vec.y), "x"), multiply(vec.x, "y")).simplify({
+        forbidFactorize: true,
+    });
+    const partialEv = partial.toDetailedEvaluation({ x: A.x, y: A.y });
+    const partialEvSimp = partialEv.simplify();
+    const c = opposite(partialEvSimp).simplify();
+    return `On lit graphiquement que la droite passe par les points $${A.toTexWithCoords()}$ et $${B.toTexWithCoords()}$. On en déduit qu'un vecteur directeur de $d$ est $${vec.toTexWithCoords()}$.
+  
+Une équation cartésienne de $d$ est donc de la forme : 
+
+$$
+${partial.toTex()}+c = 0
+$$
+
+Pour déterminer $c$, on utilise le fait que le point $${A.toTexWithCoords()}$ appartient à $d$ : 
+
+$$
+${partialEv.toTex()}+c = 0
+$$
+
+ce qui donne $c=${c.toTex()}$.
+
+Ainsi, une équation cartésienne de $d$ est : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
 const getGGBOptions = (identifiers) => {
     const { aX, aY, bX, bY } = identifiers;
     const a = new Point("a", aX, aY);
@@ -40,10 +78,14 @@ const getGGBOptions = (identifiers) => {
     });
 };
 const getCartesianEquationOfLineQuestion = () => {
-    const aX = randint(-5, 6);
-    const aY = randint(-5, 6);
-    const bX = randint(-5, 6, [aX]);
-    const bY = randint(-5, 6, [aY]);
+    let aX = randint(-5, 6);
+    let aY = randint(-5, 6);
+    let bX = randint(-5, 6, [aX]);
+    let bY = randint(-5, 6, [aY]);
+    if (aX > bX) {
+        [aX, bX] = [bX, aX];
+        [aY, bY] = [bY, aY];
+    }
     const identifiers = { aX, aY, bX, bY };
     return getQuestionFromIdentifiers(identifiers);
 };
@@ -55,6 +97,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "y", "equal"],
         answerFormat: "tex",
         identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -135,5 +179,6 @@ export const cartesianEquationOfLine = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    // hasHintAndCorrection: true,
     getQuestionFromIdentifiers,
 };

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

@@ -56,7 +56,7 @@ const getCorrection = (identifiers) => {
         forbidFactorize: true,
     });
     const line = LineConstructor.fromPointAndVector(point, vector);
-    const { a, b, c } = line.toCartesianCoeffs();
+    const [a, b, c] = line.toCartesianCoeffs();
     const [aEv, bEv, cEv] = [a.evaluate(), b.evaluate(), c.evaluate()];
     const allNeg = aEv < 0 && bEv < 0 && cEv < 0;
     const pgcd = gcd(aEv, bEv, cEv);

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

@@ -53,7 +53,7 @@ const getCorrection = (identifiers) => {
         forbidFactorize: true,
     });
     const line = LineConstructor.fromPointAndVector(point, vector);
-    const { a, b, c } = line.toCartesianCoeffs();
+    const [a, b, c] = line.toCartesianCoeffs();
     const [aEv, bEv, cEv] = [a.evaluate(), b.evaluate(), c.evaluate()];
     const allNeg = aEv < 0 && bEv < 0 && cEv < 0;
     const pgcd = gcd(aEv, bEv, cEv);

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,EAYT,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"}
+{"version":3,"file":"directionVectorEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/directionVectorEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AAqKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAiBzD,CAAC"}

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

@@ -3,10 +3,14 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 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 { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { isBinomialCoefficientNode } from "../../../../tree/nodes/operators/binomialCoefficientNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { vectorParser } from "../../../../tree/parsers/vectorParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const rebuildIdentifiers = (oldIds) => {
     if (oldIds.c !== undefined)
         return oldIds;
@@ -27,10 +31,13 @@ $$
     
 Déterminez les coordonnées d'un vecteur directeur de $d$.`;
 };
+const getKeys = (identifiers) => {
+    return ["binom", "semicolon"];
+};
 const getAnswer = (identifiers) => {
     const { xValue, yValue, c } = identifiers;
     const vector = new Vector("v", xValue.toTree(), yValue.toTree());
-    return vector.toInlineCoordsTex();
+    return vector.toBinomCoords().toTex();
 };
 const getDirectionVectorEquationQuestion = () => {
     let x1 = randint(-8, 8);
@@ -43,13 +50,40 @@ const getDirectionVectorEquationQuestion = () => {
     const identifiers = { xValue, yValue, c };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const vec = new Vector("u", opposite("b"), "a".toTree());
+    return `Si une droite $d$ admet une équation cartésienne de la forme : 
+  
+$$
+ax+by+c=0
+$$
+
+alors un vecteur directeur de $d$ est $${vec.toTexWithCoords()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { xValue, yValue, c } = identifiers;
+    const vec = new Vector("u", opposite("b"), "a".toTree());
+    return `Si une droite $d$ admet une équation cartésienne de la forme : 
+  
+$$
+ax+by+c=0
+$$
+
+alors un vecteur directeur de $d$ est $${vec.toTexWithCoords()}$.
+
+Ici, $a = ${yValue}$ et $b = ${-xValue}$. 
+
+On en déduit qu'un vecteur directeur de $d$ est $\\overrightarrow{u}${getAnswer(identifiers)}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     return {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: ["semicolon", "x", "y"],
+        keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
 };
 const getPropositions = (n, { answer, xValue, yValue }) => {
@@ -77,16 +111,25 @@ const getPropositions = (n, { answer, xValue, yValue }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer, xValue, yValue }) => {
-    const parsed = vectorParser(ans);
-    if (!parsed)
-        return false;
-    const { x, y } = parsed;
-    const correctVector = new Vector("u", xValue.toTree(), yValue.toTree());
-    const studentVector = new Vector("v", x, y);
-    if (!studentVector.isColinear(correctVector)) {
-        return false;
+    try {
+        const solVector = new Vector("v", xValue.toTree(), yValue.toTree());
+        if (ans.includes("binom")) {
+            const parsed = parseAlgebraic(ans);
+            if (!isBinomialCoefficientNode(parsed))
+                return false;
+            const vec = new Vector("u", parsed.leftChild, parsed.rightChild);
+            return solVector.isColinear(vec);
+        }
+        else {
+            const vec = vectorParser(ans);
+            if (!vec)
+                return false;
+            return solVector.isColinear(vec);
+        }
+    }
+    catch (err) {
+        return handleVEAError(err);
     }
-    return true;
 };
 export const directionVectorEquation = {
     id: "directionVectorEquation",
@@ -102,4 +145,5 @@ export const directionVectorEquation = {
     getInstruction,
     getQuestionFromIdentifiers,
     rebuildIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +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"}
+{"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;AAgBrC,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;AA0MF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}

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

@@ -70,9 +70,27 @@ ${toReduced
         : `Donner une équation cartésienne de $d$.`}`;
 };
 // const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return "";
+//   if (identifiers.toReduced)
+//     return `Pour déterminer l'équation réduite de $d$, il faut isoler la variable $y$ à gauche de l'équation, afin d'obtenir une équation de la forme :
+// $$
+// y = ax+b
+// $$`;
+//   return `Pour déterminer une équation cartésienne de $d$, il faut transformer son équation réduite en une équation de la forme :
+// $$
+// ax+by+c = 0
+// $$`;
 // };
 // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   const { a, b, c, toReduced } = identifiers;
+//   const cartesian = new EqualNode(
+//     getCartesianEquation(identifiers),
+//     (0).toTree(),
+//   );
+//   if (toReduced)
+//     return `On isole $y$ à gauche de l'équation :
+// $$
+// ${cartesian.isolate("y").toTex()}
+// $$`;
 //   return "";
 // };
 const getKeys = (identifiers) => {
@@ -168,4 +186,5 @@ export const cartesianEquationToReduced = {
     // getCorrection,
     getAnswer,
     getQuestionFromIdentifiers,
+    // hasHintAndCorrection: true,
 };

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    cartesianCoeffs1: NodeIdentifiers[];
+    cartesianCoeffs2: NodeIdentifiers[];
+};
+export declare const cartesianEquationsIntersection: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=cartesianEquationsIntersection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianEquationsIntersection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/cartesianEquationsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,gBAAgB,EAAE,eAAe,EAAE,CAAC;CACrC,CAAC;AAkHF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAoBhE,CAAC"}

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

@@ -0,0 +1,115 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { LineConstructor } from "../../../../math/geometry/line.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { GeneralSystem } from "../../../../math/systems/generalSystem.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode } 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 { pointParser } from "../../../../tree/parsers/pointParser.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getEquation = (coeffs) => {
+    const [a, b, c] = coeffs;
+    return new EqualNode(add(add(multiply(a, "x"), multiply(b, "y")), c).simplify({
+        forbidFactorize: true,
+    }), (0).toTree());
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, PointConstructor.random("A").toCoords());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { cartesianCoeffs1, cartesianCoeffs2 } = identifiers;
+    const coeffs1 = cartesianCoeffs1.map((c) => reifyAlgebraic(c));
+    coeffs1[2] = opposite(coeffs1[2]).simplify();
+    const coeffs2 = cartesianCoeffs2.map((c) => reifyAlgebraic(c));
+    coeffs2[2] = opposite(coeffs2[2]).simplify();
+    const sys = new GeneralSystem([coeffs1, coeffs2]);
+    const { x, y } = sys.solve();
+    const point = new Point("A", x, y);
+    return point.toCoords();
+};
+const getInstruction = (identifiers) => {
+    const { cartesianCoeffs1, cartesianCoeffs2 } = identifiers;
+    const coeffs1 = cartesianCoeffs1.map((c) => reifyAlgebraic(c));
+    const coeffs2 = cartesianCoeffs2.map((c) => reifyAlgebraic(c));
+    return `Soit $d_1$ une droite d'équation cartésienne : 
+  
+$$
+${getEquation(coeffs1).toTex()}
+$$
+
+et $d_2$ une droite d'équation cartésienne : 
+
+$$
+${getEquation(coeffs2).toTex()}
+$$
+
+Déterminer les coordonnées du point d'intersection de $d_1$ et $d_2$.`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = pointParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toCoords() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCartesianEquationsIntersectionQuestion = (ops) => {
+    const inter = PointConstructor.random("A");
+    const randVec = new Vector("u", randint(-10, 11, [0]).toTree(), randint(-10, 11, [0]).toTree());
+    const randVec2 = doWhile(() => new Vector("v", randint(-10, 11, [0]).toTree(), randint(-10, 11, [0]).toTree()), (v) => v.isColinear(randVec));
+    const line1 = LineConstructor.fromPointAndVector(inter, randVec);
+    const line2 = LineConstructor.fromPointAndVector(inter, randVec2);
+    const coeffs1 = line1.toCartesianCoeffs();
+    const coeffs2 = line2.toCartesianCoeffs();
+    const identifiers = {
+        cartesianCoeffs1: coeffs1.map((e) => e.toIdentifiers()),
+        cartesianCoeffs2: coeffs2.map((e) => e.toIdentifiers()),
+    };
+    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 cartesianEquationsIntersection = {
+    id: "cartesianEquationsIntersection",
+    label: "Déterminer l'intersection de deux droites à partir de leur équation cartésienne",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCartesianEquationsIntersectionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+};

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

@@ -1,8 +1,9 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { VectorIdentifiers } from "../../../../math/geometry/vector.js";
 type Identifiers = {
-    AIds: PointIdentifiers;
-    BIds: PointIdentifiers;
+    pointIds: PointIdentifiers;
+    vectorIds: VectorIdentifiers;
 };
 export declare const drawLineFromCartesianEquation: Exercise<Identifiers>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"drawLineFromCartesianEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/drawLineFromCartesianEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAQtC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAAC;AAwHF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAmB/D,CAAC"}
+{"version":3,"file":"drawLineFromCartesianEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/drawLineFromCartesianEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAQvC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,EAAE,iBAAiB,CAAC;CAC9B,CAAC;AA+HF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAmB/D,CAAC"}