math-exercises 3.0.88 → 3.0.89

package/lib/exercises/math/geometry/vectors/colinearity/colinearity.js

@@ -0,0 +1,118 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Vector, VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { RationalConstructor } from "../../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds.xu?.id)
+        return oldIds;
+    return {
+        xu: oldIds.xu.toTree().toIdentifiers(),
+        yu: oldIds.yu.toTree().toIdentifiers(),
+        xv: oldIds.xv.toTree().toIdentifiers(),
+        yv: oldIds.yv.toTree().toIdentifiers(),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { xu, yu, xv, yv } = identifiers;
+    const u = new Vector("u", reifyAlgebraic(xu), reifyAlgebraic(yu));
+    const v = new Vector("v", reifyAlgebraic(xv), reifyAlgebraic(yv));
+    return `Soit deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. 
+  
+Les vecteurs $${u.toTex()}$ et $${v.toTex()}$ sont-ils colinéaires ?`;
+};
+const getHint = (identifiers) => {
+    const u = new Vector("u", "x".toTree(), "y".toTree());
+    const v = new Vector("v", "x'".toTree(), "y'".toTree());
+    return `Deux vecteurs sont colinéaires si et seulement si leur déterminant est nul. 
+  
+Le déterminant de deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$ est :
+
+$$
+\\det(${u.toTex()}, ${v.toTex()}) = ${u.determinant(v).simplify().toTex()}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { xu, yu, xv, yv } = identifiers;
+    const u = new Vector("u", reifyAlgebraic(xu), reifyAlgebraic(yu));
+    const v = new Vector("v", reifyAlgebraic(xv), reifyAlgebraic(yv));
+    const det = u.determinant(v);
+    const detSimp = det.simplify();
+    const isCol = detSimp.evaluate() === 0;
+    return `On calcule le déterminant de $${u.toTex()}$ et $${v.toTex()}$ : 
+
+${alignTex([
+        ["", `\\det(${u.toTex()}, ${v.toTex()})`],
+        ["=", det.toTex()],
+        ["=", detSimp.toTex()],
+    ])}
+
+${isCol
+        ? `Puisque le déterminant est nul, les vecteurs sont bien colinéaires.`
+        : `Puisque le déterminant n'est pas nul, les vecteurs ne sont pas colinéaires.`}`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getColinearityQuestion = () => {
+    const u = VectorConstructor.random("u", false);
+    const isColinear = coinFlip();
+    let v;
+    if (isColinear) {
+        const coeff = coinFlip()
+            ? new NumberNode(randint(-5, 5, [0, 1]))
+            : RationalConstructor.randomIrreductible(5).toTree();
+        v = u.times(coeff, "v");
+    }
+    else {
+        do {
+            v = VectorConstructor.random("v", false);
+        } while (u.isColinear(v));
+    }
+    const identifiers = {
+        xu: u.x.toIdentifiers(),
+        xv: v.x.toIdentifiers(),
+        yu: u.y.toIdentifiers(),
+        yv: v.y.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    // addValidProp(propositions, answer, "raw");
+    const { xu, yu, xv, yv } = identifiers;
+    const u = new Vector("u", reifyAlgebraic(xu), reifyAlgebraic(yu));
+    const v = new Vector("v", reifyAlgebraic(xv), reifyAlgebraic(yv));
+    const isCol = u.isColinear(v);
+    addValidProp(propositions, isCol ? "Oui" : "Non", "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffle(propositions);
+};
+export const colinearity = {
+    id: "colinearity",
+    label: "Déterminer si deux vecteurs sont colinéaires (par les coordonnées)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getColinearityQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    rebuildIdentifiers,
+};

package/lib/exercises/math/geometry/vectors/colinearity/colinearityFromBasis.d.ts

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

package/lib/exercises/math/geometry/vectors/colinearity/colinearityFromBasis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colinearityFromBasis.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/colinearity/colinearityFromBasis.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IAEjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAgKF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAmBtD,CAAC"}

package/lib/exercises/math/geometry/vectors/colinearity/colinearityFromBasis.js

@@ -0,0 +1,158 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.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 { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const coeffs = [a, b, c, d].map((e) => reifyAlgebraic(e));
+    const det = substract(multiply(coeffs[0], coeffs[3]), multiply(coeffs[1], coeffs[2])).simplify({ forceDistributeFractions: true, forbidFactorize: true });
+    return Math.abs(det.evaluate()) < 0.001 ? "Oui" : "Non";
+};
+const getUNode = (identifiers) => {
+    const { a, b } = identifiers;
+    const coeffs = [a, b].map((e) => reifyAlgebraic(e));
+    return add(multiply(coeffs[0], "\\overrightarrow{AB}"), multiply(coeffs[1], "\\overrightarrow{AC}")).simplify({ forceDistributeFractions: true, forbidFactorize: true });
+};
+const getVNode = (identifiers) => {
+    const { c, d } = identifiers;
+    const coeffs = [c, d].map((e) => reifyAlgebraic(e));
+    return add(multiply(coeffs[0], "\\overrightarrow{AB}"), multiply(coeffs[1], "\\overrightarrow{AC}")).simplify({ forceDistributeFractions: true, forbidFactorize: true });
+};
+const getInstruction = (identifiers) => {
+    return `$A$, $B$ et $C$ sont trois points distincts et non alignés. 
+ 
+On considère les vecteurs : 
+
+$$
+\\overrightarrow{u} = ${getUNode(identifiers).toTex()} 
+$$
+
+et
+
+$$
+\\overrightarrow{v} = ${getVNode(identifiers).toTex()}
+$$
+
+Les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ sont-ils colinéaires ?`;
+};
+const getHint = (identifiers) => {
+    return `Peux-tu trouver un nombre $k$ tel que $\\overrightarrow{u} = k \\overrightarrow{v}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const coeffs = [a, b, c, d].map((e) => reifyAlgebraic(e));
+    const det = substract(multiply(coeffs[0], coeffs[3]), multiply(coeffs[1], coeffs[2])).simplify({ forceDistributeFractions: true, forbidFactorize: true });
+    const isColinear = Math.abs(det.evaluate()) < 0.001;
+    const k = frac(coeffs[2], coeffs[0]).simplify();
+    const k2 = frac(coeffs[3], coeffs[1]).simplify();
+    return `On cherche un nombre $k$ tel que $\\overrightarrow{u} = k \\overrightarrow{v}$.
+  
+Puisque les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{AC}$ ne sont pas colinéaires, ce nombre $k$ doit vérifier :
+
+$$
+${multiply(coeffs[0], "\\overrightarrow{AB}").toTex()} \\times k = ${multiply(coeffs[2], "\\overrightarrow{AB}").toTex()}
+$$
+
+ce qui donne $k = ${k.toTex()}$, et : 
+
+$$
+${multiply(coeffs[1], "\\overrightarrow{AC}").toTex()} \\times k = ${multiply(coeffs[3], "\\overrightarrow{AC}").toTex()}
+$$
+
+ce qui donne $k = ${k2.toTex()}$.
+
+${isColinear
+        ? `Les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ sont donc colinéaires.
+`
+        : `
+On en conclut que les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ ne sont pas colinéaires.`}
+
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getColinearityFromBasisQuestion = (ops) => {
+    const isColinear = coinFlip();
+    let a;
+    let b;
+    let c;
+    let d;
+    if (isColinear) {
+        const k = coinFlip()
+            ? randint(-5, 5, [0, 1]).toTree()
+            : RationalConstructor.randomIrreductible().toTree();
+        a = randint(-8, 8, [0]).toTree();
+        b = randint(-8, 8, [0]).toTree();
+        c = multiply(a, k).simplify();
+        d = multiply(b, k).simplify();
+    }
+    else {
+        do {
+            a = randint(-8, 8, [0]).toTree();
+            b = randint(-8, 8, [0]).toTree();
+            c = randint(-8, 8, [0]).toTree();
+            d = randint(-8, 8, [0]).toTree();
+        } while (substract(multiply(a, d), multiply(b, c)).evaluate() === 0);
+    }
+    const identifiers = {
+        a: a.toIdentifiers(),
+        b: b.toIdentifiers(),
+        c: c.toIdentifiers(),
+        d: d.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 colinearityFromBasis = {
+    id: "colinearityFromBasis",
+    connector: "=",
+    label: "Reconnaître des vecteurs colinéaires (à partir d'expressions)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getColinearityFromBasisQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/geometry/vectors/colinearity/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./colinearity.js";
+export * from "./alignementViaColinearity.js";
+export * from "./colinearityFromBasis.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/vectors/colinearity/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/colinearity/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC"}

package/lib/exercises/math/geometry/vectors/colinearity/index.js

@@ -0,0 +1,3 @@
+export * from "./colinearity.js";
+export * from "./alignementViaColinearity.js";
+export * from "./colinearityFromBasis.js";

package/lib/exercises/math/geometry/vectors/distributeAndReduceVectors.d.ts

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

package/lib/exercises/math/geometry/vectors/distributeAndReduceVectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributeAndReduceVectors.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/distributeAndReduceVectors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA4LF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}

package/lib/exercises/math/geometry/vectors/distributeAndReduceVectors.js

@@ -0,0 +1,155 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, type }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        switch (type) {
+            case 1:
+            case 2:
+                const a = randint(-9, 10, [0]);
+                const b = randint(-9, 10, [0]);
+                tryToAddWrongProp(propositions, add(multiply(a, "\\overrightarrow{u}"), multiply(b, "\\overrightarrow{v}")).toTex());
+                break;
+            case 3:
+            default:
+                const a2 = randint(-9, 10, [0]);
+                const b2 = randint(-9, 10, [0]);
+                const c2 = randint(-9, 10, [0]);
+                tryToAddWrongProp(propositions, add(add(multiply(a2, "\\overrightarrow{u}"), multiply(b2, "\\overrightarrow{u}")), multiply(c2, "\\overrightarrow{w}")).toTex());
+                break;
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const node = reifyAlgebraic(identifiers.expression);
+    const simp = node
+        .simplify({ towardsDistribute: true, forbidFactorize: true })
+        .toTex();
+    if (simp === "0")
+        return "\\overrightarrow{0}";
+    return simp;
+};
+const getInstruction = (identifiers) => {
+    const node = reifyAlgebraic(identifiers.expression);
+    return `Simplifier : 
+  
+$$
+${node.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    if (identifiers.type === 0) {
+        return `Regroupe les termes de même vecteur entre eux.`;
+    }
+    return `Utilise la propriété : 
+
+$$
+k(a+b) = ka+kb
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const node = reifyAlgebraic(identifiers.expression);
+    if (identifiers.type === 0) {
+        return `On regroupe les termes de même vecteur entre eux : 
+    
+$$
+${node.toTex()} = ${getAnswer(identifiers)}
+$$`;
+    }
+    return `On distribue, puis on réduit : 
+  
+$$
+
+$$
+`;
+};
+const getKeys = (identifiers) => {
+    return ["vectorU", "vectorV", "vectorW", "vectorNul"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        console.log(parsed.toTex());
+        return (parsed
+            .simplify({
+            forbidFactorize: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getDistributeAndReduceVectorsQuestion = (ops) => {
+    const type = randint(0, 3);
+    let expression;
+    switch (type) {
+        case 0:
+            const a = randint(-9, 10, [0]);
+            const b = randint(-9, 10, [0]);
+            const c = randint(-9, 10, [0]);
+            const d = randint(-9, 10, [0]);
+            const vecs = shuffle(["u", "u", "v", "v"]);
+            expression = add(multiply(a, `\\overrightarrow{${vecs[0]}}`), add(multiply(b, `\\overrightarrow{${vecs[1]}}`), add(multiply(c, `\\overrightarrow{${vecs[2]}}`), multiply(d, `\\overrightarrow{${vecs[3]}}`)))).toIdentifiers();
+            break;
+        case 1:
+            const k = randint(-9, 10, [0, 1]);
+            const a2 = randint(-9, 10, [0]);
+            const b2 = randint(-9, 10, [0]);
+            expression = multiply(k, add(multiply(a2, `\\overrightarrow{u}`), multiply(b2, `\\overrightarrow{v}`))).toIdentifiers();
+            break;
+        case 2:
+        default:
+            const k2 = randint(-9, 10, [0, 1]);
+            const k3 = randint(-9, 10, [0, 1]);
+            const a3 = randint(-9, 10, [0]);
+            const b3 = randint(-9, 10, [0]);
+            const a4 = randint(-9, 10, [0]);
+            const b4 = randint(-9, 10, [0]);
+            expression = add(multiply(k2, add(multiply(a3, `\\overrightarrow{u}`), multiply(b3, `\\overrightarrow{v}`))), multiply(k3, add(multiply(a4, `\\overrightarrow{v}`), multiply(b4, `\\overrightarrow{w}`)))).toIdentifiers();
+            break;
+    }
+    const identifiers = {
+        type,
+        expression,
+    };
+    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 distributeAndReduceVectors = {
+    id: "distributeAndReduceVectors",
+    connector: "=",
+    label: "Simplifier une expression avec des vecteurs (distributivité)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDistributeAndReduceVectorsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -2,8 +2,6 @@ export * from "./chasles.js";
 export * from "./coordinatesReading.js";
 export * from "./determinant.js";
 export * from "./vectorCoordinatesFromTwoPoints.js";
-export * from "./colinearity.js";
-export * from "./alignementViaColinearity.js";
 export * from "./paralellismViaColinearity.js";
 export * from "./parallelogramViaEqualVectors.js";
 export * from "./fourthParallelogramPoint.js";
@@ -18,4 +16,5 @@ export * from "./traceVectorDifference.js";
 export * from "./traceOppositeVector.js";
 export * from "./traceVectorMultiple.js";
 export * from "./findCoordForAligment.js";
+export * from "./colinearity/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qCAAqC,CAAC;AACpD,cAAc,kBAAkB,CAAC;AACjC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC"}

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

@@ -2,8 +2,6 @@ export * from "./chasles.js";
 export * from "./coordinatesReading.js";
 export * from "./determinant.js";
 export * from "./vectorCoordinatesFromTwoPoints.js";
-export * from "./colinearity.js";
-export * from "./alignementViaColinearity.js";
 export * from "./paralellismViaColinearity.js";
 export * from "./parallelogramViaEqualVectors.js";
 export * from "./fourthParallelogramPoint.js";
@@ -18,3 +16,5 @@ export * from "./traceVectorDifference.js";
 export * from "./traceOppositeVector.js";
 export * from "./traceVectorMultiple.js";
 export * from "./findCoordForAligment.js";
+export * from "./colinearity/index.js";
+// export * from "./distributeAndReduceVectors.js";

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

@@ -22,4 +22,5 @@ export * from "./trigonometry/index.js";
 export * from "./python/index.js";
 export * from "./sampling/index.js";
 export * from "./dataRepresentations/index.js";
+export * from "./tests/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC"}

package/lib/exercises/math/index.js

@@ -22,3 +22,4 @@ export * from "./trigonometry/index.js";
 export * from "./python/index.js";
 export * from "./sampling/index.js";
 export * from "./dataRepresentations/index.js";
+export * from "./tests/index.js";

package/lib/exercises/math/primitive/polynomialPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAKjE,CAAC;AAEF,eAAO,MAAM,6CAA6C,EAAE,0BAA0B,CACpF,WAAW,CAYZ,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CAqB7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}
+{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAKjE,CAAC;AAEF,eAAO,MAAM,6CAA6C,EAAE,0BAA0B,CACpF,WAAW,CAYZ,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CA8B7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}

package/lib/exercises/math/primitive/polynomialPrimitive.js

@@ -51,6 +51,7 @@ export const isPolynomialPrimitiveAnswerValid = (ans, { coeffs, answer }) => {
         const parsed = parseAlgebraic(ans);
         if (!parsed)
             return false;
+        const ansParsed = parseAlgebraic(ans);
         return (parsed
             .simplify({
             towardsDistribute: true,
@@ -58,7 +59,15 @@ export const isPolynomialPrimitiveAnswerValid = (ans, { coeffs, answer }) => {
             forceDistributeFractions: true,
             decimalToFractions: true,
         })
-            .toTex() === answer);
+            .toTex() ===
+            ansParsed
+                .simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+                forceDistributeFractions: true,
+                decimalToFractions: true,
+            })
+                .toTex());
     }
     catch (err) {
         return handleVEAError(err);

package/lib/exercises/math/probaStat/basicProbas/rouletteProbas.js

@@ -9,7 +9,7 @@ const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     while (propositions.length < n) {
-        tryToAddWrongProp(propositions, randint(0, 36) + "");
+        tryToAddWrongProp(propositions, frac(randint(0, 36), 37).toTex());
     }
     return shuffleProps(propositions, n);
 };

package/lib/exercises/math/python/variableAffectation.js

@@ -36,8 +36,8 @@ const getInstruction = (identifiers) => {
     return `On exécute le script Python ci-dessous. Quelle est la valeur de \`${variableName}\` à la fin du script ?
 
 \`\`\`
-${variableName} = ${initialVariable};
-${variableName} = ${affinePythonStrings};
+${variableName} = ${initialVariable}
+${variableName} = ${affinePythonStrings}
 \`\`\`
 `;
 };

package/lib/exercises/math/tests/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./testSignTable.js";
+export * from "./testVarTable.js";
+export * from "./testMultiLineSignTable.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/tests/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/tests/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/tests/index.js

@@ -0,0 +1,3 @@
+export * from "./testSignTable.js";
+export * from "./testVarTable.js";
+export * from "./testMultiLineSignTable.js";

package/lib/exercises/math/tests/testMultiLineSignTable.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    affine1Coeffs: number[];
+    affine2Coeffs: number[];
+    initTable: string[][];
+};
+export declare const testMultiLineSignTable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=testMultiLineSignTable.d.ts.map

package/lib/exercises/math/tests/testMultiLineSignTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testMultiLineSignTable.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/tests/testMultiLineSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AAiJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}