math-exercises 2.2.65 → 2.2.67

package/lib/exercises/math/percent/applyPercent.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyPercent = void 0;
+const numberVEA_1 = require("../../../exercises/vea/numberVEA");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const shuffle_1 = require("../../../utils/alea/shuffle");
 const exercise_1 = require("../../exercise");
@@ -74,9 +74,7 @@ const getPropositions = (n, { answer }) => {
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    const answerTree = new numberNode_1.NumberNode(Number(answer.replace(",", ".")));
-    const texs = answerTree.toAllValidTexs();
-    return texs.includes(ans);
+    return (0, numberVEA_1.numberVEA)(ans, answer);
 };
 exports.applyPercent = {
     id: "applyPercent",

package/lib/exercises/math/probaStat/probabilityTree.d.ts

@@ -1,15 +1,18 @@
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor";
 import { Exercise } from "../../exercise";
 type Identifiers = {
-    type: number;
-    A: number;
-    B: number;
-    AC: number;
-    AD: number;
-    BC: number;
-    BD: number;
+    A: NodeIdentifiers;
+    B: NodeIdentifiers;
+    AC: NodeIdentifiers;
+    AD: NodeIdentifiers;
+    BC: NodeIdentifiers;
+    BD: NodeIdentifiers;
+    probaName: string;
 };
 type Options = {
     allowApproximate: string;
+    eventTypes: string[];
+    probaType: string;
 };
 export declare const probabilityTree: Exercise<Identifiers, Options>;
 export {};

package/lib/exercises/math/probaStat/probabilityTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probabilityTree.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probabilityTree.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,QAAQ,EAWT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwIF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AA0CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwB1D,CAAC"}
+{"version":3,"file":"probabilityTree.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probabilityTree.ts"],"names":[],"mappings":"AAYA,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAY1C,OAAO,EACL,QAAQ,EAeT,MAAM,gBAAgB,CAAC;AAmCxB,KAAK,WAAW,GAAG;IAIjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4MF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB1D,CAAC"}

package/lib/exercises/math/probaStat/probabilityTree.js

@@ -1,72 +1,181 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.probabilityTree = void 0;
+const rationalVEA_1 = require("../../../exercises/vea/rationalVEA");
 const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
-const gcd_1 = require("../../../math/utils/arithmetic/gcd");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
+const nodeConstructor_1 = require("../../../tree/nodes/nodeConstructor");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
 const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
-const latexParser_1 = require("../../../tree/parsers/latexParser");
+const substractNode_1 = require("../../../tree/nodes/operators/substractNode");
+const random_1 = require("../../../utils/alea/random");
 const shuffle_1 = require("../../../utils/alea/shuffle");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
-const getAnswerNode = ({ type, A, B, AC, AD, BC, BD }) => {
-    const pA = (0, fractionNode_1.frac)(A, A + B);
-    const pB = (0, fractionNode_1.frac)(B, A + B);
-    const pA_C = (0, fractionNode_1.frac)(AC, AC + AD);
-    const pA_D = (0, fractionNode_1.frac)(AD, AC + AD);
-    const pB_C = (0, fractionNode_1.frac)(BC, BC + BD);
-    const pB_D = (0, fractionNode_1.frac)(BD, BC + BD);
-    switch (type) {
+const rebuildIdentifiers = (oldIdentifiers) => {
+    if (oldIdentifiers.probaName)
+        return oldIdentifiers;
+    const ABTotal = oldIdentifiers.A + oldIdentifiers.B;
+    const ASubTotal = oldIdentifiers.AC + oldIdentifiers.AD;
+    const BSubTotal = oldIdentifiers.BC + oldIdentifiers.BD;
+    let probaName = "";
+    switch (oldIdentifiers.type) {
         case 1:
-            return (0, multiplyNode_1.multiply)(pA, pA_C).simplify();
+            probaName = "P(A\\cap C)";
+            break;
         case 2:
-            return (0, multiplyNode_1.multiply)(pA, pA_D).simplify();
+            probaName = "P(A\\cap D)";
+            break;
         case 3:
-            return (0, multiplyNode_1.multiply)(pB, pB_C).simplify();
+            probaName = "P(B\\cap C)";
+            break;
         case 4:
+            probaName = "P(B\\cap D)";
+            break;
+    }
+    return {
+        probaName,
+        A: (0, fractionNode_1.frac)(oldIdentifiers.A, ABTotal).simplify().toIdentifiers(),
+        B: (0, fractionNode_1.frac)(oldIdentifiers.B, ABTotal).simplify().toIdentifiers(),
+        AC: (0, fractionNode_1.frac)(oldIdentifiers.AC, ASubTotal).simplify().toIdentifiers(),
+        AD: (0, fractionNode_1.frac)(oldIdentifiers.AD, ASubTotal).simplify().toIdentifiers(),
+        BC: (0, fractionNode_1.frac)(oldIdentifiers.BC, BSubTotal).simplify().toIdentifiers(),
+        BD: (0, fractionNode_1.frac)(oldIdentifiers.BD, BSubTotal).simplify().toIdentifiers(),
+    };
+};
+const optionValues = [
+    "Probabilité d'intersection $P(A\\cap C)$",
+    "Probabilité totale $P(C)$",
+    "Probabilité conditionnelle $P_B(A)$",
+    "Probabilité 'simple' $P(A)$",
+];
+const defaultOptionValues = [
+    "Probabilité d'intersection $P(A\\cap C)$",
+    "Probabilité totale $P(C)$",
+    "Probabilité conditionnelle $P_B(A)$",
+];
+const buildAll = (identifiers) => {
+    return {
+        pA: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.A),
+        pAC: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.AC),
+        pAD: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.AD),
+        pB: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.B),
+        pBC: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.BC),
+        pBD: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.BD),
+    };
+};
+const getAnswerNode = (identifiers) => {
+    const probas = buildAll(identifiers);
+    switch (identifiers.probaName) {
+        case "P(A)":
+            return probas.pA;
+        case "P(B)":
+            return probas.pB;
+        case "P(A\\cap C)":
+            return (0, multiplyNode_1.multiply)(probas.pA, probas.pAC).simplify();
+        case "P(A\\cap D)":
+            return (0, multiplyNode_1.multiply)(probas.pA, probas.pAD).simplify();
+        case "P(B\\cap C)":
+            return (0, multiplyNode_1.multiply)(probas.pB, probas.pBC).simplify();
+        case "P(B\\cap D)":
+            return (0, multiplyNode_1.multiply)(probas.pB, probas.pBD).simplify();
+        case "P_A(C)":
+            return probas.pAC;
+        case "P_A(D)":
+            return probas.pAD;
+        case "P_B(C)":
+            return probas.pBC;
+        case "P_B(D)":
+            return probas.pBD;
+        case "P(C)":
+            return (0, addNode_1.add)((0, multiplyNode_1.multiply)(probas.pA, probas.pAC), (0, multiplyNode_1.multiply)(probas.pB, probas.pBC)).simplify();
+        case "P(D)":
         default:
-            return (0, multiplyNode_1.multiply)(pB, pB_D).simplify();
+            return (0, addNode_1.add)((0, multiplyNode_1.multiply)(probas.pA, probas.pAD), (0, multiplyNode_1.multiply)(probas.pB, probas.pBD)).simplify();
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers, options) => {
+    let instr = `On considère l'arbre de probabilités ci-dessous. Calculer : 
+  
+$$
+${identifiers.probaName}
+$$`;
+    if (options?.allowApproximate) {
+        instr += `
+
+Donner la valeur exacte ou une valeur arrondie au ${options.allowApproximate}.`;
+    }
+    return instr;
+};
+const getProbaAndOpposite = (decimal = false) => {
+    if (!decimal) {
+        const proba = rational_1.RationalConstructor.randomIrreductibleProba().toTree();
+        return [proba, (0, substractNode_1.substract)(1, proba).simplify()];
+    }
+    else {
+        const proba = (0, round_1.round)((0, randfloat_1.randfloat)(0.01, 1, 2), 2);
+        return [proba.toTree(), (0, round_1.round)(1 - proba, 2).toTree()];
     }
 };
 const getProbabilityTree = (opts) => {
-    const A = (0, randint_1.randint)(2, 9);
-    const B = (0, randint_1.randint)(2, 10 - A);
-    const AC = (0, randint_1.randint)(2, 9);
-    const AD = (0, randint_1.randint)(2, 10 - AC);
-    const BC = (0, randint_1.randint)(2, 9);
-    const BD = (0, randint_1.randint)(2, 10 - BC);
-    let instruction = `En utilisant l'arbre de probabilité suivant, `;
-    let startStatement = "";
-    const type = (0, randint_1.randint)(1, 5);
-    const answer = getAnswerNode({ type, A, AC, AD, B, BC, BD });
-    const answerTex = answer.toTex();
-    switch (type) {
-        case 1: {
-            instruction += `calculer $P(A \\cap C)$.`;
-            startStatement = `P(A \\cap C)`;
+    const isDecimal = opts?.probaType === "Décimales";
+    const [pA, pB] = getProbaAndOpposite(isDecimal);
+    const [pC_A, pD_A] = getProbaAndOpposite(isDecimal);
+    const [pC_B, pD_B] = getProbaAndOpposite(isDecimal);
+    const eventTypes = opts?.eventTypes?.length
+        ? opts.eventTypes
+        : defaultOptionValues;
+    const type = (0, random_1.random)(eventTypes);
+    const index = optionValues.indexOf(type);
+    let probaName = "";
+    switch (index) {
+        case 0: //inter
+            probaName = (0, random_1.random)([
+                "P(A\\cap C)",
+                "P(A\\cap D)",
+                "P(B\\cap C)",
+                "P(B\\cap D)",
+            ]);
             break;
-        }
-        case 2: {
-            instruction += `calculer $P(A \\cap D)$.`;
-            startStatement = `P(A \\cap D)`;
+        case 1: //totale
+            probaName = (0, random_1.random)(["P(C)", "P(D)"]);
             break;
-        }
-        case 3: {
-            instruction += `calculer $P(B \\cap C)$.`;
-            startStatement = `P(B \\cap C)`;
+        case 2: //conditionnal
+            probaName = (0, random_1.random)(["P_A(C)", "P_A(D)", "P_B(C)", "P_B(D)"]);
             break;
-        }
-        case 4: {
-            instruction += `calculer $P(B \\cap D)$.`;
-            startStatement = `P(B \\cap D)`;
+        case 3: //simple
+            probaName = (0, random_1.random)(["P(A)", "P(B)"]);
             break;
-        }
-    }
-    if (opts?.allowApproximate) {
-        instruction += ` Donner la valeur exacte ou une valeur arrondie au ${opts.allowApproximate}.`;
     }
+    const identifiers = {
+        A: pA.toIdentifiers(),
+        B: pB.toIdentifiers(),
+        AC: pC_A.toIdentifiers(),
+        AD: pD_A.toIdentifiers(),
+        BC: pC_B.toIdentifiers(),
+        BD: pD_B.toIdentifiers(),
+        probaName,
+    };
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: probaName,
+        answer: getAnswer(identifiers),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getGGBOptions = (identifiers, opts) => {
+    const probas = buildAll(identifiers);
     let commands = [
         "A = Point({2,2})",
         "B = Point({2,-2})",
@@ -80,12 +189,12 @@ const getProbabilityTree = (opts) => {
         "Segment(Point({0,0}),B)",
         "Segment(B,BC)",
         "Segment(B,BD)",
-        `Text("\\scriptsize ${A / (0, gcd_1.gcd)(A, A + B)}/${(A + B) / (0, gcd_1.gcd)(A, A + B)}", (0.3, 2.1), true, true)`,
-        `Text("\\scriptsize ${AC / (0, gcd_1.gcd)(AC, AC + AD)}/${(AC + AD) / (0, gcd_1.gcd)(AC, AC + AD)}", (2.8, 3.5), true, true)`,
-        `Text("\\scriptsize ${AD / (0, gcd_1.gcd)(AD, AC + AD)}/${(AC + AD) / (0, gcd_1.gcd)(AD, AC + AD)}", (2.8, 1.4), true, true)`,
-        `Text("\\scriptsize ${B / (0, gcd_1.gcd)(B, A + B)}/${(A + B) / (0, gcd_1.gcd)(B, A + B)}", (0.3, -1.2), true, true)`,
-        `Text("\\scriptsize ${BC / (0, gcd_1.gcd)(BC, BC + BD)}/${(BC + BD) / (0, gcd_1.gcd)(BC, BC + BD)}", (2.8, -0.6), true, true)`,
-        `Text("\\scriptsize ${BD / (0, gcd_1.gcd)(BD, BC + BD)}/${(BC + BD) / (0, gcd_1.gcd)(BD, BC + BD)}", (2.8, -2.5), true, true)`,
+        `Text("\\scriptsize ${probas.pA.toTex()}", (0.1, 2.2), true, true)`,
+        `Text("\\scriptsize ${probas.pAC.toTex()}", (2.8, 4), true, true)`,
+        `Text("\\scriptsize ${probas.pAD.toTex()}", (2.8, 1.6), true, true)`,
+        `Text("\\scriptsize ${probas.pB.toTex()}", (0.1, -0.8), true, true)`,
+        `Text("\\scriptsize ${probas.pBC.toTex()}", (2.8, -0.6), true, true)`,
+        `Text("\\scriptsize ${probas.pBD.toTex()}", (2.8, -2.5), true, true)`,
         'Text("A", (1.85 , 2.5))',
         'Text("B", (1.85 , -2.8))',
         'Text("C", (5.5 , 2.85))',
@@ -98,44 +207,30 @@ const getProbabilityTree = (opts) => {
         hideAxes: true,
         hideGrid: true,
     });
-    const question = {
-        instruction,
-        startStatement,
-        answer: answerTex,
-        keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: [-2, 8, -5, 5],
-        }),
-        answerFormat: "tex",
-        identifiers: { A, AC, AD, B, BC, BD, type },
-    };
-    return question;
+    return ggb.getOptions({
+        coords: [-2, 8, -5, 5],
+    });
 };
-const getPropositions = (n, { answer, A, AC, AD, B, BC, BD, type }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const answerNode = getAnswerNode({ A, AC, AD, B, BC, BD, type });
+    const answerNode = getAnswerNode(identifiers);
     while (propositions.length < n) {
         const wrongAnswer = (0, multiplyNode_1.multiply)(answerNode, (0, randint_1.randint)(2, 11)).simplify();
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex());
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { answer, A, AC, AD, B, BC, BD, type }, opts) => {
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
     try {
-        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
-        if (!parsed)
-            return false;
-        const simplified = parsed.simplify();
-        if (opts?.allowApproximate) {
-            const rank = ["dixième", "centième", "millième"].indexOf(opts.allowApproximate);
-            return (answer === simplified.toTex() ||
-                simplified.evaluate() ===
-                    (0, round_1.round)(getAnswerNode({ type, A, AC, AD, B, BC, BD }).evaluate(), rank + 1));
-        }
-        return answer === simplified.toTex();
-        // const answer = getAnswerNode({ type, A, AC, AD, B, BC, BD });
-        // const texs = answer.toTree({ allowFractionToDecimal: true }).toAllValidTexs();
+        const rank = opts?.allowApproximate
+            ? ["dixième", "centième", "millième"].indexOf(opts.allowApproximate) + 1
+            : undefined;
+        return (0, rationalVEA_1.rationalVEA)(ans, answer, {
+            allowNonIrreductible: true,
+            allowDecimal: true,
+            decimalPrecision: rank,
+        });
     }
     catch (err) {
         return false;
@@ -147,25 +242,31 @@ const options = [
         label: "Autoriser les valeurs approchées au : ",
         target: exercise_1.GeneratorOptionTarget.vea,
         type: exercise_1.GeneratorOptionType.select,
-        defaultValue: "centieme",
+        defaultValue: "centième",
         values: ["dixième", "centième", "millième"],
     },
+    {
+        id: "eventTypes",
+        label: "Types de questions",
+        target: exercise_1.GeneratorOptionTarget.generation,
+        type: exercise_1.GeneratorOptionType.multiselect,
+        defaultValue: defaultOptionValues,
+        values: optionValues,
+    },
+    {
+        id: "probaType",
+        label: "Format des probabilités",
+        target: exercise_1.GeneratorOptionTarget.generation,
+        type: exercise_1.GeneratorOptionType.select,
+        defaultValue: "Fractions",
+        values: ["Fractions", "Décimales"],
+    },
 ];
 exports.probabilityTree = {
     id: "probabilityTree",
     connector: "=",
     label: "Calculs de probabilités à l'aide d'un arbre pondéré",
-    levels: [
-        "2nde",
-        "1reESM",
-        "1reSpé",
-        "1reTech",
-        "1rePro",
-        "TermPro",
-        "TermTech",
-    ],
     isSingleStep: false,
-    sections: ["Probabilités"],
     generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getProbabilityTree(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -174,4 +275,7 @@ exports.probabilityTree = {
     hasGeogebra: true,
     subject: "Mathématiques",
     options,
+    rebuildIdentifiers,
+    getInstruction,
+    getAnswer,
 };

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceVectorNormCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}
+{"version":3,"file":"spaceVectorNormCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.js

@@ -10,11 +10,11 @@ const addNode_1 = require("../../../../tree/nodes/operators/addNode");
 const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const getHint = (identifiers) => {
-    return "La norme d'un vecteur de l'espace est la racine carrée de la somme des carrés de ses coordonnées.";
+    return "Dans un repère dans l'espace orthonormé, la norme d'un vecteur  est la racine carrée de la somme des carrés de ses coordonnées.";
 };
 const getCorrection = ({ x, y, z }) => {
     const answer = getAnswer({ x, y, z });
-    return `La norme d'un vecteur de l'espace est la racine carrée de la somme des carrés de ses coordonnées. Ici, on a donc : 
+    return `Dans un repère de l'espace orthonormé, la norme d'un vecteur  est la racine carrée de la somme des carrés de ses coordonnées. Ici, on a donc : 
  
 ${(0, alignTex_1.alignTex)([
         [
@@ -35,7 +35,11 @@ const getAnswer = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const u = new spaceVector_1.SpaceVector("u", identifiers.x.toTree(), identifiers.y.toTree(), identifiers.z.toTree());
-    return `Cacluler la norme du vecteur $${u.toTexWithCoords()}$`;
+    return `On se place dans un repère de l'espace orthonormé. Calculer la norme du vecteur : 
+
+$$
+${u.toTexWithCoords()}
+$$`;
 };
 const getSpaceVectorNormCalculationQuestion = () => {
     const u = spaceVector_1.SpaceVectorConstructor.random("u", false);

package/lib/exercises/math/squareRoots/squareRootIdentities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootIdentities.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootIdentities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAmBlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2KF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"squareRootIdentities.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootIdentities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAmBlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+KF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/squareRoots/squareRootIdentities.js

@@ -57,7 +57,11 @@ const getSquareRootIdentitiesQuestion = () => {
     const answer = getAnswer(type, firstTerm, secondTerm).toTex();
     const question = {
         answer,
-        instruction: `Développer et simplifier : $${statement.toTex()}$`,
+        instruction: `Développer et simplifier : 
+    
+$$
+${statement.toTex()}
+$$`,
         keys: [],
         answerFormat: "tex",
         identifiers: { type, a: a.operand, b: b?.operand, x, y },

package/lib/exercises/math/squareRoots/squareRootsDistributivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootsDistributivity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"squareRootsDistributivity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}

package/lib/exercises/math/squareRoots/squareRootsDistributivity.js

@@ -27,7 +27,11 @@ const getSquareRootsDistributivityQuestion = () => {
         .toTex();
     const question = {
         answer,
-        instruction: `Développer et simplifier : $${statement.toTex()}$`,
+        instruction: `Développer et simplifier : 
+    
+$$
+${statement.toTex()}
+$$`,
         keys: [],
         answerFormat: "tex",
         identifiers: { a, b: b.operand, c, d },

package/lib/exercises/pc/calibrationCurveOfSolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calibrationCurveOfSolution.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/calibrationCurveOfSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA0FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}
+{"version":3,"file":"calibrationCurveOfSolution.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/calibrationCurveOfSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA0FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/pc/calibrationCurveOfSolution.js

@@ -89,8 +89,7 @@ exports.calibrationCurveOfSolution = {
     isSingleStep: true,
     sections: ["Spectrophotométrie"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCalibrationCurveOfSolutionQuestion, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
+    ggbTimer: 60,
     isGGBAnswerValid,
     answerType: "GGB",
     subject: "Physique",

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

@@ -1,2 +1,8 @@
-export declare const rationalVEA: (studentAns: string, answer: string) => boolean;
+type Opts = {
+    allowNonIrreductible?: boolean;
+    allowDecimal?: boolean;
+    decimalPrecision?: number;
+};
+export declare const rationalVEA: (studentAns: string, answer: string, { allowNonIrreductible, decimalPrecision, allowDecimal }?: Opts) => boolean;
+export {};
 //# sourceMappingURL=rationalVEA.d.ts.map

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":"AAIA,eAAO,MAAM,WAAW,eAAgB,MAAM,UAAU,MAAM,YAK7D,CAAC"}
+{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAKA,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,eACV,MAAM,UACV,MAAM,6DAC4C,IAAI,YAqC/D,CAAC"}

package/lib/exercises/vea/rationalVEA.js

@@ -1,14 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rationalVEA = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const latexParser_1 = require("../../tree/parsers/latexParser");
 const rationalParser_1 = require("../../tree/parsers/rationalParser");
-//return true if studentAns is a number or rational, and if it evaluates to answer
-const rationalVEA = (studentAns, answer) => {
+const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalPrecision, allowDecimal } = {
+    allowNonIrreductible: true,
+    decimalPrecision: undefined,
+    allowDecimal: true,
+}) => {
+    allowDecimal = allowDecimal ?? true;
+    allowNonIrreductible = allowNonIrreductible ?? true;
+    decimalPrecision = decimalPrecision ?? undefined;
     const parsed = (0, rationalParser_1.rationalParser)(studentAns);
     if (!parsed)
         return false;
-    const parsedAnswer = (0, latexParser_1.parseAlgebraic)(answer);
-    return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+    try {
+        const parsedAnswer = (0, latexParser_1.parseAlgebraic)(answer);
+        if ((0, numberNode_1.isNumberNode)(parsed)) {
+            if (!allowDecimal)
+                return false;
+            if (decimalPrecision === undefined)
+                return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001);
+            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 - 1));
+            }
+        }
+        else if (allowNonIrreductible) {
+            return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+        }
+        else {
+            //parsed est une fraction ou opposite(frac)
+            return parsed.equals(parsedAnswer);
+        }
+    }
+    catch (err) {
+        return false;
+    }
 };
 exports.rationalVEA = rationalVEA;

package/lib/index.d.ts

@@ -35,6 +35,7 @@ declare const mathExercises: (Exercise<{
 }, {
     allowNonIrreductible?: boolean | undefined;
 }> | Exercise<{
+    isIntegerFirst: boolean;
     integer: number;
     rational: [number, number];
 }, {
@@ -233,9 +234,13 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
 }, {}> | Exercise<{
-    a: number;
-    b: number;
-}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    b: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    isXRight: boolean;
+    aNumberType: string;
+}, {
+    aNumberType: string[];
+}> | Exercise<{
     a: number;
     b: number;
     c: number;
@@ -1323,15 +1328,17 @@ declare const mathExercises: (Exercise<{
     nbFaces: number;
     faceAsked: number;
 }, {}> | Exercise<{
-    type: number;
-    A: number;
-    B: number;
-    AC: number;
-    AD: number;
-    BC: number;
-    BD: number;
+    A: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    B: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    AC: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    AD: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    BC: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    BD: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    probaName: string;
 }, {
     allowApproximate: string;
+    eventTypes: string[];
+    probaType: string;
 }> | Exercise<{
     randomValues: number[];
     randomEffectives: number[];
@@ -1711,9 +1718,13 @@ declare const pcExercises: (Exercise<{
     a: number;
     b: number;
 }, {}> | Exercise<{
-    a: number;
-    b: number;
-}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    b: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    isXRight: boolean;
+    aNumberType: string;
+}, {
+    aNumberType: string[];
+}> | Exercise<{
     a: number;
     b: number;
     c: number;