math-exercises 3.0.158 → 3.0.159

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

@@ -0,0 +1,230 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { LineConstructor } from "../../../../math/geometry/line.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, pointIds, aIds, bIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const normal = new Vector("n", opposite(b), a).simplify();
+    const goodLine = LineConstructor.fromPointAndNormalVector(point, normal);
+    propWhile(propositions, n, () => {
+        const fakePoint = PointConstructor.random("A");
+        const fakeVec = VectorConstructor.random("u");
+        const line = LineConstructor.fromPointAndNormalVector(fakePoint, fakeVec);
+        if (line.isCoincident(goodLine))
+            return;
+        tryToAddWrongProp(propositions, line.getCartesianEquation().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, bIds, pointIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const normal = new Vector("n", opposite(b), a).simplify();
+    const eqNoC = add(multiply(normal.x, "x"), multiply(normal.y, "y")).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const c = opposite(eqNoC.toDetailedEvaluation({
+        x: point.x,
+        y: point.y,
+    })).simplify();
+    return `${add(eqNoC.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    }), c).toTex()} = 0`;
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds, cIds, pointIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    return `Soit $d$ une droite passant par le point $${point.toTexWithCoords()}$ et qui est perpendiculaire à la droite $\\Delta$ dont une équation cartésienne est : 
+  
+$$
+\\Delta : ${add(add(multiply(a, "x"), multiply(b, "y")), c)
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex()} = 0
+$$
+
+Déterminer une équation cartésienne de la droite $d$.`;
+};
+const getHint = () => {
+    const dir = new Vector("u", opposite("b"), "a".toTree());
+    const normal = new Vector("n", "a".toTree(), "b".toTree());
+    return `Si $d$ est perpendiculaire à $\\Delta$, les vecteurs directeurs de $\\Delta$ sont des vecteurs normaux de $d$.
+  
+On rappelle que si une droite $d$ a pour équation cartésienne : 
+
+$$
+ax+by+c = 0
+$$
+
+alors $${dir.toTexWithBinomCoords()}$ est un vecteur directeur de $d$, et $${normal.toTexWithBinomCoords()}$ est un vecteur normal de $d$.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, cIds, pointIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const normal = new Vector("n", opposite(b), a).simplify();
+    const eqNoC = add(multiply(normal.x, "x"), multiply(normal.y, "y")).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    return `Puisque $d$ est perpendiculaire à $\\Delta$, les vecteurs directeurs de $\\Delta$ sont des vecteurs normaux de $d$.
+
+Or, comme une équation cartésienne de $\\Delta$ est : 
+
+$$
+\\Delta : ${add(add(multiply(a, "x"), multiply(b, "y")), c)
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex()} = 0
+$$
+
+alors un vecteur directeur de $\\Delta$ est $${normal.toTexWithBinomCoords()}$.
+  
+Donc, une équation cartésienne de $d$ est de la forme : 
+
+$$
+${eqNoC.toTex()}+c = 0
+$$
+
+Pour déterminer $c$, on utilise le fait que $d$ passe par le point $
+${point.toTexWithCoords()}$. On a donc : 
+
+$$
+${eqNoC
+        .toDetailedEvaluation({
+        x: point.x,
+        y: point.y,
+    })
+        .toTex()} + c = 0
+$$
+
+d'où 
+
+$$
+c = ${opposite(eqNoC.toDetailedEvaluation({
+        x: point.x,
+        y: point.y,
+    }))
+        .simplify()
+        .toTex()}
+$$
+
+Ainsi, une équation cartésienne de $d$ est : 
+
+$$
+${getAnswer(identifiers)}
+$$
+  `;
+};
+const getKeys = () => {
+    return ["x", "y", "equal"];
+};
+const isAnswerValid = (ans, { answer: _answer, pointIds, aIds, bIds }) => {
+    try {
+        const splitted = ans.split("=");
+        if (splitted.length !== 2)
+            return false;
+        const left = parseAlgebraic(splitted[0]);
+        const right = parseAlgebraic(splitted[1]);
+        const studentEq = substract(left, right);
+        const point = PointConstructor.fromIdentifiers(pointIds);
+        const a = reifyAlgebraic(aIds);
+        const b = reifyAlgebraic(bIds);
+        const normal = new Vector("n", opposite(b), a).simplify();
+        //le point est-il sur la droite ?
+        if (Math.abs(studentEq
+            .toDetailedEvaluation({
+            x: point.x,
+            y: point.y,
+        })
+            .evaluate()) > 0.0001)
+            return false;
+        //le vecteur est-il normal ?
+        const studentC = studentEq.toDetailedEvaluation({
+            x: (0).toTree(),
+            y: (0).toTree(),
+        });
+        const studentAXPlusBY = substract(studentEq, studentC);
+        const studentA = studentAXPlusBY.toDetailedEvaluation({
+            x: (1).toTree(),
+            y: (0).toTree(),
+        });
+        const studentB = studentAXPlusBY.toDetailedEvaluation({
+            x: (0).toTree(),
+            y: (1).toTree(),
+        });
+        const studentVecNormal = new Vector("m", studentA, studentB);
+        return studentVecNormal.isColinear(normal);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCartesianEquationOfLineFromPerpendicularLineQuestion = () => {
+    const point = PointConstructor.random("A");
+    const a = randint(-10, 10);
+    const b = randint(-10, 10, a === 0 ? [0] : undefined);
+    const c = randint(-10, 10);
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        bIds: b.toTree().toIdentifiers(),
+        cIds: c.toTree().toIdentifiers(),
+        pointIds: point.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 cartesianEquationOfLineFromPerpendicularLine = {
+    id: "cartesianEquationOfLineFromPerpendicularLine",
+    connector: "\\iff",
+    label: "Déterminer une équation cartésienne d'une droite perpendiculaire à une droite d'équation cartésienne donnée passant par un point donné.",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCartesianEquationOfLineFromPerpendicularLineQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/cartesian/cartesianEquationOfLineFromPointAndNormalVector.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;
+    vecIds: VectorIdentifiers;
+};
+export declare const cartesianEquationOfLineFromPointAndNormalVector: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=cartesianEquationOfLineFromPointAndNormalVector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianEquationOfLineFromPointAndNormalVector.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianEquationOfLineFromPointAndNormalVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAUvC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,MAAM,EAAE,iBAAiB,CAAC;CAC3B,CAAC;AAqKF,eAAO,MAAM,+CAA+C,EAAE,QAAQ,CAAC,WAAW,CAuB/E,CAAC"}

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

@@ -0,0 +1,167 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { LineConstructor } from "../../../../math/geometry/line.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector, VectorConstructor, } from "../../../../math/geometry/vector.js";
+import { equal } from "../../../../tree/nodes/equations/equalNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { pointIds, vecIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vecIds);
+    const goodLine = LineConstructor.fromPointAndNormalVector(point, vector);
+    propWhile(propositions, n, () => {
+        const fakePoint = PointConstructor.random("A");
+        const fakeVec = VectorConstructor.random("u");
+        const line = LineConstructor.fromPointAndNormalVector(fakePoint, fakeVec);
+        if (line.isCoincident(goodLine))
+            return;
+        tryToAddWrongProp(propositions, line.getCartesianEquation().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    //M(x;y) n(a;b)
+    //a*x + b*y + c = 0 donc c = - a*x - b*y
+    const { pointIds, vecIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vecIds);
+    const c = opposite(add(multiply(vector.x, point.x), multiply(vector.y, point.y))).simplify();
+    return equal(add(add(multiply(vector.x, "x"), multiply(vector.y, "y")), c).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    }), 0).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { pointIds, vecIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vecIds);
+    return `Soit $d$ une droite passant par le point $${point.toTexWithCoords()}$ et dont le vecteur $${vector.toTexWithBinomCoords()}$ est un vecteur normal.
+  
+Déterminer une équation cartésienne de $d$.`;
+};
+const getHint = () => {
+    return `Puisque la droite $d$ passe par le point $A$ et puisque $\\overrightarrow{n}$ est un vecteur normal de $d$, alors un point $M(x;y)$ appartient à $d$ si et seulement si $\\overrightarrow{n}\\cdot \\overrightarrow{AM} = 0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { pointIds, vecIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const normal = VectorConstructor.fromIdentifiers(vecIds);
+    const AM = new Vector("AM", substract("x", point.x), substract("y", point.y)).simplify();
+    return `On considère un point $M(x;y)$.
+  
+Les coordonnées du vecteur $\\overrightarrow{AM}$ sont alors $${AM.toBinomCoords().toTex()}$.
+
+Le point $M$ appartient à la droite $d$ si et seulement si :
+
+${alignTex([
+        [
+            "\\overrightarrow{n}\\cdot \\overrightarrow{AM}=0",
+            "\\iff",
+            `${normal.scalarProduct(AM).toTex()} = 0`,
+        ],
+        [
+            "",
+            "\\iff",
+            `${normal
+                .scalarProduct(AM)
+                .simplify({ forbidFactorize: true, towardsDistribute: true })
+                .toTex()} = 0`,
+        ],
+    ])}
+
+Une équation cartésienne de $d$ est donc :
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
+const getKeys = () => {
+    return ["x", "y", "equal"];
+};
+const isAnswerValid = (ans, { answer: _answer, pointIds, vecIds }) => {
+    try {
+        const splitted = ans.split("=");
+        if (splitted.length !== 2)
+            return false;
+        const left = parseAlgebraic(splitted[0]);
+        const right = parseAlgebraic(splitted[1]);
+        const studentEq = substract(left, right);
+        const point = PointConstructor.fromIdentifiers(pointIds);
+        const normal = VectorConstructor.fromIdentifiers(vecIds);
+        //le point est-il sur la droite ?
+        if (Math.abs(studentEq
+            .toDetailedEvaluation({
+            x: point.x,
+            y: point.y,
+        })
+            .evaluate()) > 0.0001)
+            return false;
+        //le vecteur est-il normal ?
+        const studentC = studentEq.toDetailedEvaluation({
+            x: (0).toTree(),
+            y: (0).toTree(),
+        });
+        const studentAXPlusBY = substract(studentEq, studentC);
+        const studentA = studentAXPlusBY.toDetailedEvaluation({
+            x: (1).toTree(),
+            y: (0).toTree(),
+        });
+        const studentB = studentAXPlusBY.toDetailedEvaluation({
+            x: (0).toTree(),
+            y: (1).toTree(),
+        });
+        const studentVecNormal = new Vector("m", studentA, studentB);
+        return studentVecNormal.isColinear(normal);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCartesianEquationOfLineFromPointAndNormalVectorQuestion = () => {
+    const point = PointConstructor.random("A");
+    const vec = VectorConstructor.random("n");
+    const identifiers = {
+        pointIds: point.toIdentifiers(),
+        vecIds: vec.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 cartesianEquationOfLineFromPointAndNormalVector = {
+    id: "cartesianEquationOfLineFromPointAndNormalVector",
+    connector: "\\iff",
+    label: "Déterminer une équation cartésienne d'une droite à partir d'un point et d'un vecteur normal",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCartesianEquationOfLineFromPointAndNormalVectorQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -14,4 +14,7 @@ export * from "./placeAbscissOnSemiLine.js";
 export * from "./placeAbscissOnSemiLineV2.js";
 export * from "./cartesianFromVectorAndPoint.js";
 export * from "./cartesianFromTwoPoints.js";
+export * from "./normalVectorFromCartesianLineEquation.js";
+export * from "./cartesianEquationOfLineFromPointAndNormalVector.js";
+export * from "./cartesianEquationOfLineFromPerpendicularLine.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mDAAmD,CAAC"}

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

@@ -15,3 +15,6 @@ export * from "./placeAbscissOnSemiLine.js";
 export * from "./placeAbscissOnSemiLineV2.js";
 export * from "./cartesianFromVectorAndPoint.js";
 export * from "./cartesianFromTwoPoints.js";
+export * from "./normalVectorFromCartesianLineEquation.js";
+export * from "./cartesianEquationOfLineFromPointAndNormalVector.js";
+export * from "./cartesianEquationOfLineFromPerpendicularLine.js";

package/lib/exercises/math/geometry/cartesian/normalVectorFromCartesianLineEquation.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;
+    cIds: NodeIdentifiers;
+};
+export declare const normalVectorFromCartesianLineEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=normalVectorFromCartesianLineEquation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalVectorFromCartesianLineEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/normalVectorFromCartesianLineEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA6HF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAsBvE,CAAC"}

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

@@ -0,0 +1,131 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Vector, VectorConstructor } 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 { 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 getPropositions = (n, { answer, aIds, bIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const solVec = new Vector("n", a, b);
+    const dirVec = new Vector("d", opposite(b), a).simplify();
+    if (!dirVec.isColinear(solVec))
+        tryToAddWrongProp(propositions, dirVec.toBinomCoords().toTex());
+    const fakeVec = new Vector("d", b, a).simplify();
+    if (!fakeVec.isColinear(solVec))
+        tryToAddWrongProp(propositions, fakeVec.toBinomCoords().toTex());
+    propWhile(propositions, n, () => {
+        const rand = VectorConstructor.random("a");
+        if (!rand.isColinear(solVec))
+            tryToAddWrongProp(propositions, rand.toBinomCoords().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const vec = new Vector("n", a, b);
+    return vec.toBinomCoords().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    const eq = equal(add(add(multiply(a, "x"), multiply(b, "y")), c), 0).simplify({ towardsDistribute: true, forbidFactorize: true });
+    return `Déterminer les coordonnées d'un vecteur normal à la droite $d$ d'équation cartésienne : 
+  
+$$
+d: ${eq.toTex()}
+$$`;
+};
+const getHint = () => {
+    const vec = new Vector("n", "a".toTree(), "b".toTree());
+    return `Une droite $d$ a pour équation cartésienne $ax+by+c = 0$ si et seulement si $${vec.toTexWithBinomCoords()}$ est un vecteur normal à $d$.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    const vec = new Vector("n", "a".toTree(), "b".toTree());
+    return `Une droite $d$ a pour équation cartésienne $ax+by+c = 0$ si et seulement si $${vec.toTexWithBinomCoords()}$ est un vecteur normal à $d$.
+  
+Ici, on identifie les coefficients : $a = ${a.toTex()}$, $b = ${b.toTex()}$ et $c = ${c.toTex()}$.
+
+On en conclut qu'un vecteur normal à $d$ est $\\overrightarrow{n}$ de coordonnées $${getAnswer(identifiers)}$.`;
+};
+const getKeys = () => {
+    return ["binom", "semicolon"];
+};
+const isAnswerValid = (ans, { answer: _answer, aIds, bIds }) => {
+    try {
+        const solVector = new Vector("n", reifyAlgebraic(aIds), reifyAlgebraic(bIds));
+        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);
+    }
+};
+const getNormalVectorFromCartesianLineEquationQuestion = () => {
+    const a = randint(-10, 10);
+    const b = randint(-10, 10, a === 0 ? [0] : undefined);
+    const c = randint(-10, 10);
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        bIds: b.toTree().toIdentifiers(),
+        cIds: c.toTree().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 normalVectorFromCartesianLineEquation = {
+    id: "normalVectorFromCartesianLineEquation",
+    connector: "=",
+    label: "Déterminer les coordonnées d'un vecteur normal à partir d'une équation cartésienne d'une droite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getNormalVectorFromCartesianLineEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,2 @@
+export * from "./isPointOnCircleFromCartesianEquation.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./isPointOnCircleFromCartesianEquation.js";

package/lib/exercises/math/geometry/circles/isPointOnCircleFromCartesianEquation.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    pointIds: PointIdentifiers;
+    radiusIds: NodeIdentifiers;
+    centreIds: PointIdentifiers;
+};
+export declare const isPointOnCircleFromCartesianEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isPointOnCircleFromCartesianEquation.d.ts.map

package/lib/exercises/math/geometry/circles/isPointOnCircleFromCartesianEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPointOnCircleFromCartesianEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/circles/isPointOnCircleFromCartesianEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,EAAE,eAAe,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;CAC7B,CAAC;AA8HF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAqBtE,CAAC"}