math-exercises 2.2.51 → 2.2.53

package/lib/exercises/math/functions/basics/imageFunctionGeogebra.js

@@ -3,62 +3,64 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.imageFunctionGeogebra = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
-const colors_1 = require("../../../../geogebra/colors");
+const numberVEA_1 = require("../../../../exercises/vea/numberVEA");
 const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
-const polynomial_1 = require("../../../../math/polynomials/polynomial");
+const lagrange_1 = require("../../../../geogebra/lagrange");
+const spline_1 = require("../../../../geogebra/spline");
+const point_1 = require("../../../../math/geometry/point");
 const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const closure_1 = require("../../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
 const coinFlip_1 = require("../../../../utils/alea/coinFlip");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getImageFunctionGeogebra = () => {
-    const rand = (0, coinFlip_1.coinFlip)();
-    const xValue = (0, randint_1.randint)(-5, 6);
-    let polynome1;
-    do {
-        polynome1 = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
-    } while (polynome1.calculate(xValue) > 10 ||
-        polynome1.calculate(xValue) < -10);
-    let polynome2;
-    do {
-        polynome2 = new polynomial_1.Polynomial([
-            (0, randint_1.randint)(-9, 10),
-            (0, randint_1.randint)(-9, 10),
-            (0, randint_1.randint)(-4, 5, [0]),
-        ]);
-    } while (polynome2.calculate(xValue) > 10 ||
-        polynome2.calculate(xValue) < -10);
-    const statement = `Quelle est l'image de $${xValue}$ par la fonction $f$ représentée ci dessous ?`;
-    const answer = rand
-        ? polynome1.calculate(xValue)
-        : polynome2.calculate(xValue);
-    const xMin = xValue;
-    const xMax = xValue;
-    const yMin = answer;
-    const yMax = answer;
-    const commands = [
-        `f(x) = ${rand ? polynome1.toString() : polynome2.toString()}`,
-        `SetColor(f, "${(0, colors_1.randomColor)()}")`,
-    ];
-    const ggb = new geogebraConstructor_1.GeogebraConstructor({ commands });
-    const answerTex = answer + "";
+    const x = (0, randint_1.randint)(-8, 9);
+    const y = (0, randint_1.randint)(-8, 9);
+    const isSpline = (0, coinFlip_1.coinFlip)();
+    const spline = new (isSpline ? spline_1.Spline : lagrange_1.Lagrange)(new intervalNode_1.IntervalNode((-10).toTree(), (10).toTree(), closure_1.ClosureType.FF), [
+        new point_1.Point("A", x.toTree(), y.toTree()),
+        //distractor point with ordonnée = x
+        new point_1.Point("B", (y + (0, randint_1.randint)(-3, 4, [0, x - y, 10 - y, -10 - y])).toTree(), x.toTree()),
+    ]);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({ commands: spline.getCommands() });
+    const xMin = spline.points[0][0];
+    const xMax = spline.points[spline.points.length - 1][0];
+    const yMin = Math.min(...spline.points.map((p) => p[1])) - 1;
+    const yMax = Math.max(...spline.points.map((p) => p[1])) + 1;
+    const instruction = `Quelle est l'image de $${x}$ par la fonction $f$ représentée ci dessous ?`;
     const question = {
-        instruction: statement,
-        startStatement: `f(${xValue})`,
-        answer: answerTex,
+        instruction,
+        startStatement: `f(${x})`,
+        answer: y.frenchify(),
         keys: [],
-        ggbOptions: ggb.getOptions({ coords: [-10, 10, -10, 10] }),
+        ggbOptions: ggb.getOptions({
+            coords: ggb.getAdaptedCoords({
+                forceShowAxes: true,
+                xMax,
+                xMin,
+                yMax,
+                yMin,
+            }),
+        }),
         answerFormat: "tex",
         identifiers: {
-            poly1: polynome1.coefficients,
-            poly2: polynome2.coefficients,
-            rand,
-            xValue,
+            splinePoints: spline.points,
+            x,
+            y,
+            isSpline,
         },
     };
     return question;
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, splinePoints, x, y }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
+    //old questions have spline POint undefined
+    (splinePoints ?? [])
+        .filter((p) => p[1] === x)
+        .map((e) => (0, round_1.round)(e[0], 0))
+        .forEach((y) => (0, exercise_1.tryToAddWrongProp)(propositions, y.frenchify()));
     while (propositions.length < n) {
         const wrongAnswer = Number(answer) + (0, randint_1.randint)(-10, 11, [0]);
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer + "");
@@ -66,7 +68,7 @@ const getPropositions = (n, { answer }) => {
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return (0, numberVEA_1.numberVEA)(ans, answer);
 };
 exports.imageFunctionGeogebra = {
     id: "imageFunctionGeogebra",

package/lib/exercises/math/functions/parity/parityFromGraph.js

@@ -105,7 +105,7 @@ const getPropositions = (n, { answer }) => {
     (0, exercise_1.addValidProp)(propositions, answer, "raw");
     (0, exercise_1.tryToAddWrongProp)(propositions, "Paire", "raw");
     (0, exercise_1.tryToAddWrongProp)(propositions, "Impaire", "raw");
-    (0, exercise_1.tryToAddWrongProp)(propositions, "Ni paire ni impaire", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Ni paire, ni impaire", "raw");
     (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
     return (0, exercise_1.shuffleProps)(propositions, n);
 };

package/lib/exercises/math/functions/trinoms/secondDegreeInequation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secondDegreeInequation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/secondDegreeInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAsHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"secondDegreeInequation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/secondDegreeInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAe3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAsHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

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

@@ -8,6 +8,9 @@ type Identifiers = {
     type: string;
     probaFrac: number[];
 };
-export declare const probaFromTableWithContext: Exercise<Identifiers>;
+type Options = {
+    allowNonIrreductible?: boolean;
+};
+export declare const probaFromTableWithContext: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=probaFromTableWithContext.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAoIF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAgB3D,CAAC"}
+{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA2HF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAsBF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBpE,CAAC"}

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

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.probaFromTableWithContext = void 0;
 const exercise_1 = require("../../../exercises/exercise");
+const allowNonIrreductibleFractions_1 = require("../../../exercises/options/allowNonIrreductibleFractions");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const rational_1 = require("../../../math/numbers/rationals/rational");
 const randint_1 = require("../../../math/utils/random/randint");
 const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const rationalParser_1 = require("../../../tree/parsers/rationalParser");
 const random_1 = require("../../../utils/alea/random");
 const dollarize_1 = require("../../../utils/latex/dollarize");
 const mdTable_1 = require("../../../utils/markdown/mdTable");
@@ -107,11 +109,20 @@ const getPropositions = (n, { answer, aBarreCapB, aBarreCapBBarre, aCapB, aCapBB
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const isAnswerValid = (ans, { answer, probaFrac }) => {
-    const fracTexs = new fractionNode_1.FractionNode(probaFrac[0].toTree(), probaFrac[1].toTree())
-        .simplify()
-        .toAllValidTexs();
-    return fracTexs.includes(ans);
+const options = [allowNonIrreductibleFractions_1.allowNonIrreductibleOption];
+const isAnswerValid = (ans, { answer, probaFrac }, options) => {
+    if (options?.allowNonIrreductible) {
+        const parsed = (0, rationalParser_1.rationalParser)(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    else {
+        const fracTexs = new fractionNode_1.FractionNode(probaFrac[0].toTree(), probaFrac[1].toTree())
+            .simplify()
+            .toAllValidTexs();
+        return fracTexs.includes(ans);
+    }
 };
 exports.probaFromTableWithContext = {
     id: "probaFromTableWithContext",
@@ -120,11 +131,12 @@ exports.probaFromTableWithContext = {
     levels: ["1rePro", "1reSpé", "1reTech", "1reESM", "2ndPro"],
     isSingleStep: true,
     sections: ["Probabilités"],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getProbaFromTableWithContextQuestion, nb),
+    generator: (nb, options) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getProbaFromTableWithContextQuestion(options), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
+    options,
 };

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

@@ -8,6 +8,9 @@ type Identifiers = {
     BC: number;
     BD: number;
 };
-export declare const probabilityTree: Exercise<Identifiers>;
+type Options = {
+    allowApproximate: string;
+};
+export declare const probabilityTree: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=probabilityTree.d.ts.map

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":"AAMA,OAAO,EACL,QAAQ,EAQT,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;AA+IF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAsBjD,CAAC"}
+{"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"}

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

@@ -2,33 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.probabilityTree = void 0;
 const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
-const integer_1 = require("../../../math/numbers/integer/integer");
-const rational_1 = require("../../../math/numbers/rationals/rational");
 const gcd_1 = require("../../../math/utils/arithmetic/gcd");
 const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const latexParser_1 = require("../../../tree/parsers/latexParser");
 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 = new rational_1.Rational(A, A + B).simplify();
-    const pB = new rational_1.Rational(B, A + B).simplify();
-    const pA_C = new rational_1.Rational(AC, AC + AD).simplify();
-    const pA_D = new rational_1.Rational(AD, AC + AD).simplify();
-    const pB_C = new rational_1.Rational(BC, BC + BD).simplify();
-    const pB_D = new rational_1.Rational(BD, BC + BD).simplify();
+    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) {
         case 1:
-            return pA.multiply(pA_C);
+            return (0, multiplyNode_1.multiply)(pA, pA_C).simplify();
         case 2:
-            return pA.multiply(pA_D);
+            return (0, multiplyNode_1.multiply)(pA, pA_D).simplify();
         case 3:
-            return pB.multiply(pB_C);
+            return (0, multiplyNode_1.multiply)(pB, pB_C).simplify();
         case 4:
         default:
-            return pB.multiply(pB_D);
+            return (0, multiplyNode_1.multiply)(pB, pB_D).simplify();
     }
 };
-const getProbabilityTree = () => {
+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);
@@ -39,7 +41,7 @@ const getProbabilityTree = () => {
     let startStatement = "";
     const type = (0, randint_1.randint)(1, 5);
     const answer = getAnswerNode({ type, A, AC, AD, B, BC, BD });
-    const answerTex = answer.toTree().toTex();
+    const answerTex = answer.toTex();
     switch (type) {
         case 1: {
             instruction += `calculer $P(A \\cap C)$.`;
@@ -62,6 +64,9 @@ const getProbabilityTree = () => {
             break;
         }
     }
+    if (opts?.allowApproximate) {
+        instruction += ` Donner la valeur exacte ou une valeur arrondie au ${opts.allowApproximate}.`;
+    }
     let commands = [
         "A = Point({2,2})",
         "B = Point({2,-2})",
@@ -111,16 +116,41 @@ const getPropositions = (n, { answer, A, AC, AD, B, BC, BD, type }) => {
     (0, exercise_1.addValidProp)(propositions, answer);
     const answerNode = getAnswerNode({ A, AC, AD, B, BC, BD, type });
     while (propositions.length < n) {
-        const wrongAnswer = answerNode.multiply(new integer_1.Integer((0, randint_1.randint)(2, 11)));
-        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTree().toTex());
+        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, { A, AC, AD, B, BC, BD, type }) => {
-    const answer = getAnswerNode({ type, A, AC, AD, B, BC, BD });
-    const texs = answer.toTree({ allowFractionToDecimal: true }).toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, A, AC, AD, B, BC, BD, type }, 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();
+    }
+    catch (err) {
+        return false;
+    }
 };
+const options = [
+    {
+        id: "allowApproximate",
+        label: "Autoriser les valeurs approchées au : ",
+        target: exercise_1.GeneratorOptionTarget.vea,
+        type: exercise_1.GeneratorOptionType.select,
+        defaultValue: "centieme",
+        values: ["dixième", "centième", "millième"],
+    },
+];
 exports.probabilityTree = {
     id: "probabilityTree",
     connector: "=",
@@ -136,11 +166,12 @@ exports.probabilityTree = {
     ],
     isSingleStep: false,
     sections: ["Probabilités"],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getProbabilityTree, nb),
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getProbabilityTree(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    options,
 };

package/lib/exercises/math/probaStat/stats1var/averageWithTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averageWithTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageWithTable.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAST,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAgFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}
+{"version":3,"file":"averageWithTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageWithTable.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAST,MAAM,mBAAmB,CAAC;AAI3B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAgFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

package/lib/exercises/math/probaStat/stats1var/averageWithTable.js

@@ -8,6 +8,7 @@ const mdTable_1 = require("../../../../utils/markdown/mdTable");
 const dollarize_1 = require("../../../../utils/latex/dollarize");
 const exercise_1 = require("../../../exercise");
 const getDistinctQuestions_1 = require("../../../utils/getDistinctQuestions");
+const numberVEA_1 = require("../../../../exercises/vea/numberVEA");
 const getInstruction = ({ randomEffectives, randomValues, }) => {
     return `On considère le tableau d'effectifs suivant : 
 
@@ -58,7 +59,7 @@ const getPropositions = (n, { answer }) => {
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return (0, numberVEA_1.numberVEA)(ans, answer);
 };
 exports.averageWithTable = {
     id: "averageWithTable",

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

@@ -3,4 +3,5 @@ export * from "./squareRootEquation";
 export * from "./squareRootIdentities";
 export * from "./squareRootsDistributivity";
 export * from "./squareRootsSum";
+export * from "./squareRootsProducts";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC"}

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

@@ -19,3 +19,4 @@ __exportStar(require("./squareRootEquation"), exports);
 __exportStar(require("./squareRootIdentities"), exports);
 __exportStar(require("./squareRootsDistributivity"), exports);
 __exportStar(require("./squareRootsSum"), exports);
+__exportStar(require("./squareRootsProducts"), exports);

package/lib/exercises/math/squareRoots/squareRootsProducts.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+};
+export declare const squareRootsProducts: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=squareRootsProducts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"squareRootsProducts.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsProducts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAQlC,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;AAmEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAerD,CAAC"}

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareRootsProducts = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const real_1 = require("../../../math/numbers/reals/real");
+const randint_1 = require("../../../math/utils/random/randint");
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const int = (0, randint_1.randint)(-30, 30, [0]);
+        const sqrt = real_1.SquareRootConstructor.randomIrreductible().toTree();
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, multiplyNode_1.multiply)(int, sqrt).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    return (0, multiplyNode_1.multiply)((0, multiplyNode_1.multiply)(a, (0, sqrtNode_1.sqrt)(b)), (0, multiplyNode_1.multiply)(c, (0, sqrtNode_1.sqrt)(d)))
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    return `Ecrire sous la forme $a\\sqrt{b}$, avec $b$ le plus petit possible : 
+
+$$
+${(0, multiplyNode_1.multiply)((0, multiplyNode_1.multiply)(a, (0, sqrtNode_1.sqrt)(b)), (0, multiplyNode_1.multiply)(c, (0, sqrtNode_1.sqrt)(d)), {
+        forceTimesSign: true,
+    }).toTex()}
+$$
+  `;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+// a
+const getSquareRootsProductsQuestion = () => {
+    const a = (0, randint_1.randint)(-10, 10, [0]);
+    const b = (0, randint_1.randint)(2, 10);
+    const c = (0, randint_1.randint)(-10, 10, [0]);
+    const d = (0, coinFlip_1.coinFlip)()
+        ? (0, randint_1.randint)(2, 10)
+        : real_1.SquareRootConstructor.randomSimplifiable({
+            allowPerfectSquare: false,
+            maxSquare: 5,
+        }).operand;
+    const identifiers = { a, b, c, d };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.squareRootsProducts = {
+    id: "squareRootsProducts",
+    connector: "=",
+    label: "Produits de racines carrées",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSquareRootsProductsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

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

@@ -0,0 +1,3 @@
+import { GeneratorOption } from "../exercise";
+export declare const allowNonIrreductibleOption: GeneratorOption;
+//# sourceMappingURL=allowNonIrreductibleFractions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"allowNonIrreductibleFractions.d.ts","sourceRoot":"","sources":["../../../src/exercises/options/allowNonIrreductibleFractions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAGhB,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,0BAA0B,EAAE,eAKxC,CAAC"}

package/lib/exercises/options/allowNonIrreductibleFractions.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowNonIrreductibleOption = void 0;
+const exercise_1 = require("../exercise");
+exports.allowNonIrreductibleOption = {
+    id: "allowNonIrreductible",
+    label: "Autoriser les fractions non réduites",
+    target: exercise_1.GeneratorOptionTarget.vea,
+    type: exercise_1.GeneratorOptionType.checkbox,
+};

package/lib/geogebra/geogebraConstructor.js

@@ -21,15 +21,16 @@ class GeogebraConstructor {
         const showAxes = forceShowAxes ?? (this.hideAxes ? false : true);
         const xDelta = xMax - xMin;
         const yDelta = yMax - yMin;
+        const coeff = 0.1;
         if (this.is3D && zMin !== undefined && zMax !== undefined) {
             const zDelta = zMax - zMin;
             const coords = [
-                xMin === xMax ? xMin - 1 : xMin - Math.max(1, 0.2 * Math.abs(xDelta)),
-                xMin === xMax ? xMax + 1 : xMax + Math.max(1, 0.2 * Math.abs(xDelta)),
-                yMin === yMax ? yMin - 1 : yMin - Math.max(1, 0.2 * Math.abs(yDelta)),
-                yMin === yMax ? yMax + 1 : yMax + Math.max(1, 0.2 * Math.abs(yDelta)),
-                zMin === zMax ? zMin - 1 : zMin - Math.max(1, 0.2 * Math.abs(zDelta)),
-                zMin === zMax ? zMax + 1 : zMax + Math.max(1, 0.2 * Math.abs(zDelta)),
+                xMin === xMax ? xMin - 1 : xMin - Math.max(1, coeff * Math.abs(xDelta)),
+                xMin === xMax ? xMax + 1 : xMax + Math.max(1, coeff * Math.abs(xDelta)),
+                yMin === yMax ? yMin - 1 : yMin - Math.max(1, coeff * Math.abs(yDelta)),
+                yMin === yMax ? yMax + 1 : yMax + Math.max(1, coeff * Math.abs(yDelta)),
+                zMin === zMax ? zMin - 1 : zMin - Math.max(1, coeff * Math.abs(zDelta)),
+                zMin === zMax ? zMax + 1 : zMax + Math.max(1, coeff * Math.abs(zDelta)),
             ];
             if (showAxes) {
                 coords[0] = Math.min(-1, coords[0]);
@@ -43,10 +44,10 @@ class GeogebraConstructor {
         }
         else {
             const coords = [
-                xMin === xMax ? xMin - 1 : xMin - Math.max(1, 0.2 * Math.abs(xDelta)),
-                xMin === xMax ? xMax + 1 : xMax + Math.max(1, 0.2 * Math.abs(xDelta)),
-                yMin === yMax ? yMin - 1 : yMin - Math.max(1, 0.2 * Math.abs(yDelta)),
-                yMin === yMax ? yMax + 1 : yMax + Math.max(1, 0.2 * Math.abs(yDelta)),
+                xMin === xMax ? xMin - 1 : xMin - Math.max(1, coeff * Math.abs(xDelta)),
+                xMin === xMax ? xMax + 1 : xMax + Math.max(1, coeff * Math.abs(xDelta)),
+                yMin === yMax ? yMin - 1 : yMin - Math.max(1, coeff * Math.abs(yDelta)),
+                yMin === yMax ? yMax + 1 : yMax + Math.max(1, coeff * Math.abs(yDelta)),
             ];
             if (showAxes) {
                 coords[0] = Math.min(-1, coords[0]);

package/lib/geogebra/lagrange.d.ts

@@ -0,0 +1,8 @@
+import { Point } from "../math/geometry/point";
+import { IntervalNode } from "../tree/nodes/sets/intervalNode";
+export declare class Lagrange {
+    points: number[][];
+    constructor(interval: IntervalNode, points?: Point[]);
+    getCommands(): string[];
+}
+//# sourceMappingURL=lagrange.d.ts.map

package/lib/geogebra/lagrange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lagrange.d.ts","sourceRoot":"","sources":["../../src/geogebra/lagrange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKlD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAelE,qBAAa,QAAQ;IACnB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}

package/lib/geogebra/lagrange.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lagrange = void 0;
+const randfloat_1 = require("../math/utils/random/randfloat");
+const randint_1 = require("../math/utils/random/randint");
+const colors_1 = require("./colors");
+// export abstract class LagrangeConstructor {
+//   random() {
+//     const a = randint(-10, 0);
+//     const b = doWhile(
+//       () => randint(0, 10),
+//       (x) => Math.abs(x - a) < 5,
+//     );
+//     return new Spline(new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF));
+//   }
+// }
+class Lagrange {
+    constructor(interval, points) {
+        const a = interval.a.evaluate({});
+        const b = interval.b.evaluate();
+        this.points = [];
+        const sortedPoints = points
+            ?.map((a) => [a.x.evaluate({}), a.y.evaluate({})])
+            .sort((a, b) => a[0] - b[0]);
+        if (!Number.isFinite(a) || !Number.isFinite(b))
+            throw Error("unimplement infinity lagrange");
+        const length = Math.abs(b - a);
+        const nbOfSlices = sortedPoints?.length
+            ? sortedPoints.length + 5
+            : (0, randint_1.randint)(4, 8);
+        const step = length / nbOfSlices;
+        const yCoeff = 1 / nbOfSlices;
+        for (let i = 0; i < nbOfSlices; i++) {
+            const xMin = a + i * step;
+            const xMax = xMin + step;
+            if (i === 0) {
+                const pointInSlice = sortedPoints?.length && sortedPoints[0][0] < xMax;
+                this.points.push([
+                    a,
+                    pointInSlice
+                        ? sortedPoints[0][1] + yCoeff * (0, randfloat_1.randfloat)(-2, 3)
+                        : (0, randfloat_1.randfloat)(-10, 10),
+                ]);
+            }
+            const fittedPoints = sortedPoints?.filter((point) => point[0] >= xMin && point[0] < xMax);
+            this.points.push(...(fittedPoints ?? []));
+            if (!fittedPoints?.length && i > 0 && i < nbOfSlices - 1) {
+                const nextYInSlice = sortedPoints?.find((p) => p[0] >= xMax && p[0] < xMax + step)?.[1];
+                const x = (0, randfloat_1.randfloat)(xMin + step / 4, xMax - step / 4, 6);
+                const prevy = this.points[this.points.length - 1][1];
+                const y = nextYInSlice !== undefined
+                    ? prevy + (nextYInSlice - prevy) / 2
+                    : prevy + yCoeff * (0, randfloat_1.randfloat)(-3, 4, 5);
+                this.points.push([x, y]);
+            }
+            if (i === nbOfSlices - 1) {
+                const prevY = this.points[this.points.length - 1][1];
+                this.points.push([b, prevY + yCoeff * (0, randfloat_1.randfloat)(-2, 3)]);
+            }
+        }
+    }
+    getCommands() {
+        const commands = [
+            `P = Polynomial(${this.points
+                .map((point) => `(${point[0]},${point[1]})`)
+                .join(",")})`,
+            "SetFixed(P, true)",
+            `SetColor(P, "${(0, colors_1.randomColor)()}")`,
+        ];
+        return commands;
+    }
+}
+exports.Lagrange = Lagrange;