math-exercises 3.0.171 → 3.0.173

package/lib/exercises/math/sequences/seqArithmGeom/seqArithmGeomRecurrenceFormulaUsage.js

@@ -0,0 +1,202 @@
+import { addValidProp, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../exercises/options/optionFirstTermRankOne.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { unfrenchify } from "../../../../math/utils/latex/unfrenchify.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getNodeUNext = (coeffs) => {
+    const [a, b] = coeffs;
+    const nodeUn = "u_{n}".toTree();
+    return add(multiply(a, nodeUn), b);
+};
+const computeNodeNext = (nodeUNext, nodeU) => {
+    return nodeBySubstitutingVar(nodeUNext, nodeU, "u_{n}".toTree());
+};
+const getDictSequenceSlice = (coeffs, rank1, value1, rankAsked) => {
+    const nodeUNext = getNodeUNext(coeffs);
+    return [...Array(rankAsked - rank1).keys()]
+        .map((i) => rank1 + 1 + i)
+        .reduce((acc, rank) => {
+        acc[rank] = computeNodeNext(nodeUNext, acc[rank - 1].simplify());
+        return acc;
+    }, { [rank1]: value1.toTree() });
+};
+const getInstruction = (identifiers) => {
+    const { rank1, value1, coeffs, rankAsked } = identifiers;
+    return `$(u_n)$ est une suite définie par, pour $n\\geq 1$ :
+  
+$$
+u_{n+1} = ${getNodeUNext(coeffs).toTex()}
+$$
+
+et $u_{${rank1}} = ${value1}$. 
+
+Calculer le terme $u_{${rankAsked}}$.`;
+};
+const getStartStatement = (identifiers) => {
+    const { rank1 } = identifiers;
+    const askedRank = rank1 + 1;
+    return `u_{${askedRank}}`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { rank1, value1, coeffs, rankAsked } = identifiers;
+    const dictSequenceSlice = getDictSequenceSlice(coeffs, rank1, value1, rankAsked);
+    return {
+        dictSequenceSlice,
+        answerNode: dictSequenceSlice[rankAsked],
+    };
+};
+const getAnswer = (identifiers) => {
+    return getAnswerStuff(identifiers).answerNode.simplify().toTex();
+};
+const getHint = (identifiers) => {
+    const { rank1, rankAsked } = identifiers;
+    const distanceRankAsked = rankAsked - rank1;
+    if (distanceRankAsked === 1) {
+        return `Il suffit de remplacer $n$ par $${rankAsked - 1}$ dans la formule de récurrence de la suite $u$.`;
+    }
+    else {
+        return `Remplace $n$ par $${rank1}$ dans la formule de récurrence de la suite $u$ pour calculer $u_{${rank1 + 1}}$.
+Puis continue ainsi de suite jusqu'à trouver $u_{${rankAsked}}$`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { rank1, rankAsked, coeffs } = identifiers;
+    const answerStuff = getAnswerStuff(identifiers);
+    const dictSequenceSlice = answerStuff.dictSequenceSlice;
+    delete dictSequenceSlice[rank1];
+    return `On utilise la formule de récurrence, jusqu'à trouver $u_{${rankAsked}}$ : 
+  
+${Object.entries(dictSequenceSlice).map(([strRank, node]) => {
+        const nodeUPrev = `u_{${Number(strRank) - 1}}`.toTree();
+        return `${alignTex([
+            [
+                `u_{${strRank}}`,
+                "=",
+                computeNodeNext(getNodeUNext(coeffs), nodeUPrev).toTex(),
+            ],
+            ["", "=", node.toTex()],
+            ["", "=", node.simplify().toTex()],
+        ])}`;
+    }).join(`
+
+`)}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { rank1, rankAsked, coeffs } = identifiers;
+    const arrAnswerWrong = [];
+    //too short / too far
+    {
+        const arrRankBelow = [...Array(2).keys()]
+            .map((i) => i + 1)
+            .map((i) => rankAsked - i)
+            .filter((rank) => rank > rank1);
+        const arrRankAbove = [rankAsked + 1];
+        [...arrRankBelow, ...arrRankAbove].forEach((rankWrong) => {
+            const identifiersWrong = Object.assign({}, identifiers, {
+                rankAsked: rankWrong,
+            });
+            const texWrong = getAnswer(identifiersWrong);
+            tryToAddWrongProp(propositions, texWrong);
+            arrAnswerWrong.push(texWrong);
+        });
+    }
+    //student: u_n -> n
+    {
+        const nodeWrong = computeNodeNext(getNodeUNext(coeffs), (rankAsked - 1).toTree()).simplify();
+        const texWrong = nodeWrong.toTex();
+        tryToAddWrongProp(propositions, texWrong);
+        arrAnswerWrong.push(texWrong);
+    }
+    //student: u_{rank1} -> u_{firstRank}
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            rank1: firstRank,
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+        arrAnswerWrong.push(texWrong);
+    }
+    //terror
+    if (coinFlip()) {
+        const answerRandom = random([answer, ...arrAnswerWrong]);
+        const answerTerror = unfrenchify(answerRandom) + randint(-25, 26, [0]).frenchify();
+        tryToAddWrongProp(propositions, answerTerror);
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, rank1 }) => {
+    return [
+        answer,
+        `u_${rank1 + 1}=${answer}`,
+        `u_{${rank1 + 1}}=${answer}`,
+    ].includes(ans);
+};
+const getSeqArithmGeomRecurrenceFormulaUsageQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const distanceOfRankAsked = Number(opts.distanceOfRankAsked);
+    const rank1 = randint(firstRank, 20);
+    const value1 = randint(-10, 10);
+    const a = randint(-10, 10, [0]);
+    const b = randint(-10, 10, [0]);
+    const coeffs = [a, b];
+    const rankAsked = rank1 + distanceOfRankAsked;
+    const identifiers = { rank1, value1, coeffs, rankAsked };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne, {
+    distanceOfRankAsked: "1",
+});
+const options = [
+    generatorOptionFirstTermRankOne,
+    {
+        id: "distanceOfRankAsked",
+        label: "nombre de rangs d'écart",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["1", "2", "3"],
+        defaultValue: optsDefault.distanceOfRankAsked,
+    },
+];
+export const seqArithmGeomRecurrenceFormulaUsage = {
+    id: "seqArithmGeomRecurrenceFormulaUsage",
+    connector: "=",
+    label: "Utiliser la formule de récurrence d'une suite arithmético-géométrique",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getSeqArithmGeomRecurrenceFormulaUsageQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/trigonometry/circle/placeAssociateAngleOnCircle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placeAssociateAngleOnCircle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/placeAssociateAngleOnCircle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AA4LF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAqB7D,CAAC"}
+{"version":3,"file":"placeAssociateAngleOnCircle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/placeAssociateAngleOnCircle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AA0LF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAqB7D,CAAC"}

package/lib/exercises/math/trigonometry/circle/placeAssociateAngleOnCircle.js

@@ -124,8 +124,6 @@ const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
         .map((p) => ggbPointToCoords(p))
         .map((coords, i) => new Point(`K_${i}`, coords.x, coords.y));
     const answerPoint = getAnswerPoint(identifiers);
-    console.log(points.map((e) => [e.x.toTex(), e.y.toTex()]));
-    console.log(answerPoint.x.toTex(), answerPoint.y.toTex());
     return (points.length < 5 &&
         points.some((point) => point.distanceTo(answerPoint) < 0.1));
 };

package/lib/exercises/options/optionFirstTermRankOne.d.ts

@@ -0,0 +1,16 @@
+import { GeneratorOptionTarget, GeneratorOptionType } from "../exercise.js";
+export type OptionFirstTermRankOne = {
+    firstTermRankOne: boolean;
+};
+export declare const getOptionFirstTermRankOneStuff: (isFirstTermRankOneDefault?: boolean) => {
+    generatorOptionFirstTermRankOne: {
+        id: string;
+        label: string;
+        type: GeneratorOptionType.checkbox;
+        target: GeneratorOptionTarget;
+        tooltipText?: string;
+        defaultValue?: boolean;
+    };
+    optsDefaultFirstTermRankOne: OptionFirstTermRankOne;
+};
+//# sourceMappingURL=optionFirstTermRankOne.d.ts.map

package/lib/exercises/options/optionFirstTermRankOne.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optionFirstTermRankOne.d.ts","sourceRoot":"","sources":["../../../src/exercises/options/optionFirstTermRankOne.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,gBAAgB,CAAC;AAExB,MAAM,MAAM,sBAAsB,GAAG;IACnC,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,8BAA8B,GACzC,4BAA2B,OAAe;;;;;;;;;;CAkB3C,CAAC"}

package/lib/exercises/options/optionFirstTermRankOne.js

@@ -0,0 +1,17 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../exercise.js";
+export const getOptionFirstTermRankOneStuff = (isFirstTermRankOneDefault = false) => {
+    const optsDefaultFirstTermRankOne = {
+        firstTermRankOne: isFirstTermRankOneDefault,
+    };
+    const generatorOptionFirstTermRankOne = {
+        id: "firstTermRankOne",
+        label: "Utiliser $u_1$ comme premier terme",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: isFirstTermRankOneDefault,
+    };
+    return {
+        generatorOptionFirstTermRankOne,
+        optsDefaultFirstTermRankOne,
+    };
+};

package/lib/exercises/options/optionIsUsePythonDef.d.ts

@@ -0,0 +1,16 @@
+import { GeneratorOptionTarget, GeneratorOptionType } from "../exercise.js";
+export type OptionIsUsePythonDef = {
+    isUsePythonDef: boolean;
+};
+export declare const getOptionIsUsePythonDefStuff: (isUsePythonDefDefault?: boolean) => {
+    generatorOptionIsUsePythonDef: {
+        id: string;
+        label: string;
+        type: GeneratorOptionType.checkbox;
+        target: GeneratorOptionTarget;
+        tooltipText?: string;
+        defaultValue?: boolean;
+    };
+    optsDefaultIsUsePythonDef: OptionIsUsePythonDef;
+};
+//# sourceMappingURL=optionIsUsePythonDef.d.ts.map

package/lib/exercises/options/optionIsUsePythonDef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optionIsUsePythonDef.d.ts","sourceRoot":"","sources":["../../../src/exercises/options/optionIsUsePythonDef.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,gBAAgB,CAAC;AAExB,MAAM,MAAM,oBAAoB,GAAG;IACjC,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,4BAA4B,GACvC,wBAAuB,OAAe;;;;;;;;;;CAkBvC,CAAC"}

package/lib/exercises/options/optionIsUsePythonDef.js

@@ -0,0 +1,17 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../exercise.js";
+export const getOptionIsUsePythonDefStuff = (isUsePythonDefDefault = false) => {
+    const optsDefaultIsUsePythonDef = {
+        isUsePythonDef: isUsePythonDefDefault,
+    };
+    const generatorOptionIsUsePythonDef = {
+        id: "isUsePythonDef",
+        label: "Utiliser def <fonction>:",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefaultIsUsePythonDef.isUsePythonDef,
+    };
+    return {
+        generatorOptionIsUsePythonDef,
+        optsDefaultIsUsePythonDef,
+    };
+};

package/lib/exercises/options/optionIsWithSuperfluousData.d.ts

@@ -0,0 +1,16 @@
+import { GeneratorOptionTarget, GeneratorOptionType } from "../exercise.js";
+export type OptionIsWithSuperfluousData = {
+    isWithSuperfluousData: boolean;
+};
+export declare const getOptionIsWithSuperfluousData: (isWithSuperfluousData?: boolean) => {
+    generatorOptionIsWithSuperfluousData: {
+        id: string;
+        label: string;
+        type: GeneratorOptionType.checkbox;
+        target: GeneratorOptionTarget;
+        tooltipText?: string;
+        defaultValue?: boolean;
+    };
+    optsDefaultIsWithSuperfluousData: OptionIsWithSuperfluousData;
+};
+//# sourceMappingURL=optionIsWithSuperfluousData.d.ts.map

package/lib/exercises/options/optionIsWithSuperfluousData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optionIsWithSuperfluousData.d.ts","sourceRoot":"","sources":["../../../src/exercises/options/optionIsWithSuperfluousData.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,gBAAgB,CAAC;AAExB,MAAM,MAAM,2BAA2B,GAAG;IACxC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF,eAAO,MAAM,8BAA8B,GACzC,wBAAuB,OAAe;;;;;;;;;;CAkBvC,CAAC"}

package/lib/exercises/options/optionIsWithSuperfluousData.js

@@ -0,0 +1,17 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../exercise.js";
+export const getOptionIsWithSuperfluousData = (isWithSuperfluousData = false) => {
+    const optsDefaultIsWithSuperfluousData = {
+        isWithSuperfluousData,
+    };
+    const generatorOptionIsWithSuperfluousData = {
+        id: "isWithSuperfluousData",
+        label: "Ajouter des données superflues",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefaultIsWithSuperfluousData.isWithSuperfluousData,
+    };
+    return {
+        generatorOptionIsWithSuperfluousData,
+        optsDefaultIsWithSuperfluousData,
+    };
+};

package/lib/exercises/utils/geogebra/toGGBCommandsProps.d.ts

@@ -10,5 +10,6 @@ export type ToGGBCommandsProps = {
     showLength?: boolean;
     label?: string;
     thickness?: number;
+    isVisible?: boolean;
 };
 //# sourceMappingURL=toGGBCommandsProps.d.ts.map

package/lib/exercises/utils/geogebra/toGGBCommandsProps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC"}
+{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC"}

package/lib/exercises/vea/colinearVectorVEA.d.ts

@@ -0,0 +1,2 @@
+export declare const colinearVectorVEA: (studentAns: string, answer: string) => boolean;
+//# sourceMappingURL=colinearVectorVEA.d.ts.map

package/lib/exercises/vea/colinearVectorVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colinearVectorVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/colinearVectorVEA.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,EAAE,QAAQ,MAAM,YAQnE,CAAC"}

package/lib/exercises/vea/colinearVectorVEA.js

@@ -0,0 +1,11 @@
+import { vectorParser } from "../../tree/parsers/vectorParser.js";
+export const colinearVectorVEA = (studentAns, answer) => {
+    const vec = vectorParser(studentAns);
+    if (!vec) {
+        return false;
+    }
+    const solVector = vectorParser(answer);
+    if (!solVector)
+        throw new Error("answer malformed in colinearVectorVEA");
+    return solVector.isColinear(vec);
+};

package/lib/exercises/vea/rationalVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAMA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,WAAW,GACtB,YAAY,MAAM,EAClB,QAAQ,MAAM,EACd,2DAA0D,IAIzD,YAgCF,CAAC"}
+{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAOA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,WAAW,GACtB,YAAY,MAAM,EAClB,QAAQ,MAAM,EACd,2DAA0D,IAIzD,YAkCF,CAAC"}

package/lib/exercises/vea/rationalVEA.js

@@ -1,10 +1,11 @@
+import { round } from "../../math/utils/round.js";
 import { isNumberNode } from "../../tree/nodes/numbers/numberNode.js";
 import { parseAlgebraic } from "../../tree/parsers/latexParser.js";
 import { rationalParser } from "../../tree/parsers/rationalParser.js";
 import { handleVEAError } from "../../utils/errors/handleVEAError.js";
 export const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalPrecision, allowDecimal } = {
     allowNonIrreductible: true,
-    decimalPrecision: undefined,
+    decimalPrecision: 2,
     allowDecimal: true,
 }) => {
     allowDecimal = allowDecimal ?? true;
@@ -23,8 +24,11 @@ export const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalP
             else {
                 //! accepte bien les arrondis au centième par ex, mais va aussi accepter les arrondis au millième
                 //! je juge ca ok
-                return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) <
-                    Math.pow(10, -decimalPrecision));
+                return (round(parsed.evaluate(), decimalPrecision) ===
+                    round(parsedAnswer.evaluate(), decimalPrecision)
+                // Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) <
+                // Math.pow(10, -decimalPrecision)
+                );
             }
         }
         else if (allowNonIrreductible) {

package/lib/exercises/vea/varLineVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"varLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/varLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAiClE,CAAC"}
+{"version":3,"file":"varLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/varLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAmClE,CAAC"}

package/lib/exercises/vea/varLineVEA.js

@@ -12,9 +12,12 @@ export const varLineVEA = (ans, answerTable) => {
         for (let i = 1; i < table[0].length; i++) {
             const value = [table[0][i], table[1][i], table[2][i]].filter(isValue);
             //plusieurs valeurs dans une même colonne
-            if (value.length !== 1)
+            if (value.every((el) => el === "\\ "))
+                flattenedAns.push("\\ ");
+            else if (value.length !== 1)
                 return false;
-            flattenedAns.push(value[0]);
+            else
+                flattenedAns.push(value[0]);
         }
         return flattenedAns;
     };
@@ -37,7 +40,8 @@ export const varLineVEA = (ans, answerTable) => {
             continue;
         }
         else {
-            return rationalVEA(value, flattenedAnswerTable[i]);
+            return ((!isValue(value) && !isValue(flattenedAnswerTable[i])) ||
+                rationalVEA(value, flattenedAnswerTable[i]));
         }
     }
     return true;

package/lib/exercises/vea/varSignTableVEA.d.ts

@@ -1,2 +1,10 @@
+/**
+ *
+ * @param ans
+ * @param answerTable
+ * @returns
+ * gère les trois lignes de variation comme une seule
+ * par défaut rationalVEA un peu partout
+ */
 export declare const varSignTableVEA: (ans: string[][], answerTable: string[][]) => boolean;
 //# sourceMappingURL=varSignTableVEA.d.ts.map

package/lib/exercises/vea/varSignTableVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"varSignTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/varSignTableVEA.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAMvE,CAAC"}
+{"version":3,"file":"varSignTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/varSignTableVEA.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAMvE,CAAC"}

package/lib/exercises/vea/varSignTableVEA.js

@@ -1,6 +1,14 @@
 import { signLineVEA } from "./signLineVEA.js";
 import { varLineVEA } from "./varLineVEA.js";
 import { xTableLineVEA } from "./xTableLineVEA.js";
+/**
+ *
+ * @param ans
+ * @param answerTable
+ * @returns
+ * gère les trois lignes de variation comme une seule
+ * par défaut rationalVEA un peu partout
+ */
 export const varSignTableVEA = (ans, answerTable) => {
     return (xTableLineVEA(ans[0], answerTable[0]) &&
         signLineVEA(ans[1], answerTable[1]) &&

package/lib/exercises/vea/xTableLineVEA.d.ts

@@ -3,6 +3,7 @@
  * @param ans ligne des x du student
  * @param answerTable ligne des x de la réponse
  * cette fonction ne check que la ligne des x dans un tableau de variations / signes
+ * TODO passer en argument le VEA check qui est ajd fixé à rationalVEA
  */
 export declare const xTableLineVEA: (ans: string[], answerTable: string[]) => boolean;
 //# sourceMappingURL=xTableLineVEA.d.ts.map

package/lib/exercises/vea/xTableLineVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xTableLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/xTableLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,EAAE,aAAa,MAAM,EAAE,YAYjE,CAAC"}
+{"version":3,"file":"xTableLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/xTableLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,EAAE,aAAa,MAAM,EAAE,YAYjE,CAAC"}

package/lib/exercises/vea/xTableLineVEA.js

@@ -3,6 +3,7 @@
  * @param ans ligne des x du student
  * @param answerTable ligne des x de la réponse
  * cette fonction ne check que la ligne des x dans un tableau de variations / signes
+ * TODO passer en argument le VEA check qui est ajd fixé à rationalVEA
  */
 import { rationalVEA } from "./rationalVEA.js";
 export const xTableLineVEA = (ans, answerTable) => {

package/lib/index.d.ts

@@ -1504,8 +1504,11 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
-    isDevForm: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+    isDevForm?: boolean;
+    form: "cano" | "dev" | "facto";
+}, {
+    form: string[];
+}> | Exercise<{
     a: number;
     b: number;
     c: number;
@@ -1537,6 +1540,17 @@ declare const mathExercises: (Exercise<{
     x1: number;
     x2: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    coeffs: number[];
+    initTable: string[][];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    k: number;
+}, {
+    isAskingRoots: boolean;
+    nbSols: string[];
+}> | Exercise<{
     width: number;
     height: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -2103,17 +2117,75 @@ declare const mathExercises: (Exercise<{
     rotationAngle: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    uIds: import("./math/geometry/vector.js").VectorIdentifiers;
+    vIds: import("./math/geometry/vector.js").VectorIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    vecIds1: import("./math/geometry/vector.js").VectorIdentifiers;
+    vecIds2: import("./math/geometry/vector.js").VectorIdentifiers;
+    pointIds1A: import("./math/geometry/point.js").PointIdentifiers;
+    pointIds2A: import("./math/geometry/point.js").PointIdentifiers;
+    isVec1OnAxis: boolean;
+    isOnAxisX: boolean;
+}, {
+    isSameStartPoint: boolean;
+}> | Exercise<{
+    pointIds: import("./math/geometry/point.js").PointIdentifiers[];
+}, {
+    sectorOfPointH: string;
+    isPositiveCoordsOnly: boolean;
+}> | Exercise<{
+    pointIds: import("./math/geometry/point.js").PointIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     type: number;
     normU: number;
     normV: number;
     udotv: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
+    nodeIdsUDotV: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    isSignOnly: boolean;
+}> | Exercise<{
+    nodeIdsU: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    nodeIdsV: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    uIds: import("./math/geometry/vector.js").VectorIdentifiers;
-    vIds: import("./math/geometry/vector.js").VectorIdentifiers;
+    nodeIdsU: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    nodeIdsV: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    vecIdsU: import("./math/geometry/vector.js").VectorIdentifiers;
+    vecIdsV: import("./math/geometry/vector.js").VectorIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    vecIdsU: import("./math/geometry/vector.js").VectorIdentifiers;
+    vecIdsV: import("./math/geometry/vector.js").VectorIdentifiers;
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+    pointNames: string[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    vecIdsU: import("./math/geometry/vector.js").VectorIdentifiers;
+    vecIdsV: import("./math/geometry/vector.js").VectorIdentifiers;
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+    pointNames: string[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    vecIdsU: import("./math/geometry/vector.js").VectorIdentifiers;
+    vecIdsV: import("./math/geometry/vector.js").VectorIdentifiers;
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+    pointNames: string[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    triangleIds: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+    indexAngle: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    triangleIds: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+    indexSide: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    sectorOfPointH: string;
+    triangleIds: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+    pointIdsH: import("./math/geometry/point.js").PointIdentifiers;
+}, {
+    sectorOfPointH: string;
+}> | Exercise<{
     xA: number;
     xB: number;
     xC: number;
@@ -2503,6 +2575,12 @@ declare const mathExercises: (Exercise<{
     BIds: import("./math/geometry/point.js").PointIdentifiers;
     CIds: import("./math/geometry/point.js").PointIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    point1Ids: import("./math/geometry/point.js").PointIdentifiers;
+    point2Ids: import("./math/geometry/point.js").PointIdentifiers;
+    point3Ids?: import("./math/geometry/point.js").PointIdentifiers;
+}, {
+    withoutPerp: boolean;
+}> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     type: number;
     useAngles: boolean;
@@ -3002,6 +3080,27 @@ declare const mathExercises: (Exercise<{
     valuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     probasIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     intervalIds: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").SituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").SituationParams;
+    xi: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").SituationParams;
+}, {
+    averageFormulation: string;
+}> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").SituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").SituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").SituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").SituationParams;
+    initTable: string[][];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    pValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     pA: number;
     pB: number;