math-exercises 3.0.22 → 3.0.24

package/lib/exercises/math/dataRepresentations/pieChartReading.js

@@ -0,0 +1,171 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { blueExtraDark, colorWithOpacity, greenDark, orange, pinkDark, purpleDark, red, } from "../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { Angle } from "../../../math/geometry/angle.js";
+import { Point } from "../../../math/geometry/point.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+import { percentParser } from "../../../tree/parsers/percentParser.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { getLetter } from "../../../utils/strings/getLetter.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { points } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const angleValue = angle.evaluate();
+    tryToAddWrongProp(propositions, angleValue.frenchify() + "\\%");
+    tryToAddWrongProp(propositions, `${round(100 / points.length, 1)}\\%`);
+    tryToAddWrongProp(propositions, round((angleValue * 100) / 180, 2).frenchify() + "\\%");
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randfloat(8, 80, 2).frenchify() + "\\%");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { points } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const angleValue = angle.evaluate();
+    return round((angleValue * 100) / 360, 2).frenchify() + "\\%";
+};
+const getInstruction = (identifiers) => {
+    return `Ci-dessous est donnée la répartition des communications effectuées par des lycéens avec leur téléphone portable. 
+  
+Quelle proportion des communications effectuées, les communications audio représentent-elles ?
+  
+Arrondir au centième.`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBOptions = (identifiers) => {
+    const { points, labels } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    // const reversedPoints = pointsObj.reverse();
+    const colors = [greenDark, orange, pinkDark, purpleDark, red];
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const getMidPoint = (nextPoint, prevPoint) => {
+        const [xA, yA] = prevPoint;
+        const angleA = Math.atan2(yA, xA);
+        const [xB, yB] = nextPoint;
+        const angleB = Math.atan2(yB, xB);
+        // const angleM = (angleA + angleB) / 2;
+        const angleM = angleA +
+            Math.atan2(Math.sin(angleB - angleA), Math.cos(angleB - angleA)) / 2;
+        return [1.2 * Math.cos(angleM), 1.2 * Math.sin(angleM)];
+        return [
+            (1.2 * (xA + xB)) / Math.sqrt((xA + xB) ** 2 + (yA + yB) ** 2 + 0.1),
+            (1.2 * (yA + yB)) / Math.sqrt((xA + xB) ** 2 + (yA + yB) ** 2 + 0.1),
+        ];
+    };
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `C = Circle((0,0), 1)`,
+            `SetLineThickness(C, 1)`,
+            // ...pointsObj.flatMap((p) => p.toGGBCommand()),
+            ...pointsObj.flatMap((p, i) => [
+                `C_${i} = CircularSector((0,0), ${pointsObj[(i + 1 + pointsObj.length) % pointsObj.length].toMathString()}, ${p.toMathString()})`,
+                `SetColor(C_${i}, "${colorWithOpacity(colors[i], 80)}")`,
+                `SetLineThickness(C_${i}, 0)`,
+                // `SetCaption(C_${i}, "$\\tiny \\text{${labels[i]}}$")`,
+                // `ShowLabel(C_${i}, true)`,
+                // `Text("$\\tiny \\text{${labels[i]
+                //   .split(" ")
+                //   .join("\\\\")}}$", (${getMidPoint(
+                //   points[(i + 1 + points.length) % points.length],
+                //   points[i],
+                // ).join(",")}), true, true, 1, 0)`,
+                `Text("$\\tiny \\text{${labels[i]
+                    .split(" ")
+                    .join("\\\\")}}$", (${getMidPoint(points[(i + 1 + points.length) % points.length], points[i]).join(",")}), true, true, 0, 0)`,
+            ]),
+            ...angle.toCommands({
+                showValue: points[1][0] === 1 ? false : true,
+                pointsAreNotBuilt: true,
+                thickness: 1,
+                color: blueExtraDark,
+            }),
+        ],
+        hideAxes: true,
+        hideGrid: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-1.4, 1.4, -1.4, 1.4],
+    });
+};
+const getKeys = (identifiers) => {
+    return ["percent"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = percentParser(ans, true);
+        return parsed === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPieChartReadingQuestion = (opts) => {
+    const labels = [
+        "communications audio",
+        "communications vidéo",
+        "messagerie électronique",
+        "autre",
+        "messages SMS",
+    ];
+    const getPointFromPrev = (prevPoint, degAngle) => {
+        const radAngle = -(degAngle * Math.PI) / 180;
+        return [
+            round(prevPoint[0] * Math.cos(radAngle) - prevPoint[1] * Math.sin(radAngle), 6),
+            round(prevPoint[0] * Math.sin(radAngle) + prevPoint[1] * Math.cos(radAngle), 6),
+        ];
+    };
+    const angles = [5 * randint(6, 30)];
+    for (let i = 0; i < labels.length - 1; i++) {
+        const remaining = 360 - angles.reduce((acc, curr) => acc + curr);
+        if (i === labels.length - 1)
+            angles.push(remaining);
+        else
+            angles.push(randint(30, Math.min(100, remaining - 30)));
+    }
+    const points = [[0, 1]];
+    for (let i = 0; i < angles.length - 1; i++) {
+        points.push(getPointFromPrev(points[i], angles[i]));
+    }
+    const identifiers = {
+        labels,
+        points,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const pieChartReading = {
+    id: "pieChartReading",
+    label: "Convertir un angle en pourcentage dans un diagramme circulaire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPieChartReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+};

package/lib/exercises/math/derivation/derivative/constanteDerivative.js

@@ -12,10 +12,10 @@ const getAnswer = () => "0";
 const getInstruction = (identifiers) => {
     const tex = identifiers.tex;
     return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par : 
-  
+
 $$
 f(x) = ${tex}
-$$.`;
+$$`;
 };
 export const getConstanteDerivative = () => {
     const c = NombreConstructor.random();

package/lib/exercises/math/derivation/derivative/secondDegreeDerivative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secondDegreeDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/secondDegreeDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAMR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA4CF,eAAO,MAAM,yBAAyB,EAAE,iBAAiB,CAAC,WAAW,CAgBpE,CAAC;AAEF,eAAO,MAAM,qCAAqC,EAAE,YAAY,CAC9D,WAAW,CA+BZ,CAAC;AACF,eAAO,MAAM,mCAAmC,EAAE,GAAG,CAAC,WAAW,CAQhE,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAyBxD,CAAC"}
+{"version":3,"file":"secondDegreeDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/secondDegreeDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAMR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA8CF,eAAO,MAAM,yBAAyB,EAAE,iBAAiB,CAAC,WAAW,CAgBpE,CAAC;AAEF,eAAO,MAAM,qCAAqC,EAAE,YAAY,CAC9D,WAAW,CA+BZ,CAAC;AACF,eAAO,MAAM,mCAAmC,EAAE,GAAG,CAAC,WAAW,CAQhE,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAyBxD,CAAC"}

package/lib/exercises/math/derivation/derivative/secondDegreeDerivative.js

@@ -40,9 +40,11 @@ $$
 };
 const getInstruction = (identifiers) => {
     const polynomial = new Polynomial(identifiers.coefficients);
-    return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par $f(x) = ${polynomial
-        .toTree()
-        .toTex()}$.`;
+    return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${polynomial.toTree().toTex()}
+$$`;
 };
 export const getSecondDegreeDerivative = () => {
     const coefficients = [randint(-9, 10), randint(-9, 10), randint(-9, 10, [0])];

package/lib/exercises/math/derivation/derivative/thirdDegreeDerivative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thirdDegreeDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/thirdDegreeDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAMR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA4CF,eAAO,MAAM,wBAAwB,EAAE,iBAAiB,CAAC,WAAW,CAmBnE,CAAC;AAEF,eAAO,MAAM,oCAAoC,EAAE,YAAY,CAAC,WAAW,CAwC1E,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,GAAG,CAAC,WAAW,CAe/D,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CA0BvD,CAAC"}
+{"version":3,"file":"thirdDegreeDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/thirdDegreeDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAMR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA8CF,eAAO,MAAM,wBAAwB,EAAE,iBAAiB,CAAC,WAAW,CAmBnE,CAAC;AAEF,eAAO,MAAM,oCAAoC,EAAE,YAAY,CAAC,WAAW,CAwC1E,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,GAAG,CAAC,WAAW,CAe/D,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CA0BvD,CAAC"}

package/lib/exercises/math/derivation/derivative/thirdDegreeDerivative.js

@@ -36,9 +36,11 @@ $$
 };
 const getInstruction = (identifiers) => {
     const polynomial = new Polynomial(identifiers.coefficients);
-    return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par $f(x) = ${polynomial
-        .toTree()
-        .toTex()}$.`;
+    return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par :
+  
+$$
+f(x) = ${polynomial.toTree().toTex()}
+$$`;
 };
 const getAnswer = (identifiers) => {
     const polynomial = new Polynomial(identifiers.coefficients);

package/lib/exercises/math/functions/exponential/expFactorization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expFactorization.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/expFactorization.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwJF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAiBlD,CAAC"}
+{"version":3,"file":"expFactorization.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/expFactorization.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA6JF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAiBlD,CAAC"}

package/lib/exercises/math/functions/exponential/expFactorization.js

@@ -3,12 +3,13 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 // import { expressionVEA } from "#root/exercises/vea/expressionVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
-import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { exp, isExpNode } from "../../../../tree/nodes/functions/expNode.js";
 import { isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
 // import { variable } from "../../../../tree/nodes/variables/variableNode.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
 const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     const { uA } = identifiers;
@@ -82,7 +83,9 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
         const parsed = parseAlgebraic(ans);
         if (!parsed)
             return false;
-        if (!isMultiplyNode(parsed))
+        if (!isMultiplyNode(parsed) &&
+            !isExpNode(parsed) &&
+            !(isOppositeNode(parsed) && isExpNode(parsed.child)))
             return false;
         const simp = parsed.simplify({
             forbidFactorize: true,

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAkBtC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IAEzB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CAQnB,CAAC;AA+MF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}
+{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAkBtC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IAEzB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CAQnB,CAAC;AA+MF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAqBnD,CAAC"}

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.js

@@ -191,6 +191,9 @@ export const pythagoreOrThales = {
     getGGBOptions,
     hasGeogebra: true,
     answerType: "QCU",
+    pdfOptions: {
+        shouldSpreadPropositions: true,
+    },
 };
 const getSubTriangle = ({ triangle, insidePointsNames, ratio, isPapillon, }) => {
     const [A, B, C] = triangle.points;

package/lib/exercises/math/geometry/quadrilaterals/quadrilateralRecognition.js

@@ -149,9 +149,10 @@ const getGGBOptions = (identifiers) => {
                 shapeObject.drawSidesDecoration();
     }
     const cmds = shapeObject.toGGBCommands();
+    shapeObject.points;
     const ggb = new GeogebraConstructor({ hideAxes: true, hideGrid: true });
     ggb.commands = cmds;
-    return ggb.getOptions({ coords: [-10, 10, -10, 10] });
+    return ggb.getOptions({ coords: ggb.getCoordsForPoints(shapeObject.points) });
 };
 const getKeys = (identifiers) => {
     return [];

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

@@ -1 +1 @@
-{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAER,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAiBjE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CAa7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}
+{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAcjE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CA8B7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAWrD,CAAC"}

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

@@ -2,19 +2,34 @@ import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/polynomial.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const polynomial = new Polynomial(identifiers.coeffs);
+    return `Déterminer la forme générale des primitives de la fonction polynomiale $f$ définie par : 
+
+$$
+f(x) = ${polynomial.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const polynomial = new Polynomial(identifiers.coeffs);
+    const integralPolynomial = polynomial.integrateToNode();
+    const answer = `${integralPolynomial.toTex()}`;
+    return answer;
+};
 export const getPolynomialPrimitive = () => {
     const degree = randint(1, 4);
     const polynomial = PolynomialConstructor.randomWithOrder(degree);
-    const integralPolynomial = polynomial.integrateToNode();
-    const answer = `${integralPolynomial.toTex()}`;
+    const identifiers = { coeffs: polynomial.coefficients };
     const question = {
-        instruction: `Déterminer la forme générale des primitives de la fonction polynomiale $f$ définie par $f(x) = ${polynomial.toTex()}$.`,
+        instruction: getInstruction(identifiers),
         startStatement: `F(x)`,
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["x", "C"],
         answerFormat: "tex",
-        identifiers: { coeffs: polynomial.coefficients },
+        identifiers,
     };
     return question;
 };
@@ -28,22 +43,38 @@ export const getPolynomialPrimitivePropositions = (n, { answer, coeffs }) => {
     }
     return shuffle(propositions);
 };
-export const isPolynomialPrimitiveAnswerValid = (ans, { coeffs }) => {
-    const opts = {
-        allowFractionToDecimal: true,
-        forbidPowerToProduct: true,
-    };
-    const polynomial = new Polynomial(coeffs);
-    const integralPolynomial = polynomial.integrateToNode(opts);
-    const texs = integralPolynomial.toAllValidTexs(opts);
-    return texs.includes(ans);
+export const isPolynomialPrimitiveAnswerValid = (ans, { coeffs, answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        // console.log(
+        //   parsed
+        //     .simplify({
+        //       towardsDistribute: true,
+        //       forbidFactorize: true,
+        //       decimalToFractions: true,
+        //       forceDistributeFractions: true,
+        //       forceIsolateMonomCoeffs: true,
+        //     })
+        //     .toTex(),
+        // );
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+            forceDistributeFractions: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const polynomialPrimitive = {
     id: "polynomialPrimitive",
     connector: "=",
     label: "Primitive d'une fonction polynomiale",
-    levels: ["TermSpé", "MathComp"],
-    sections: ["Primitives"],
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getPolynomialPrimitive, nb),
     qcmTimer: 60,

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

@@ -46,9 +46,9 @@ const getAnswer = (identifiers) => {
 };
 const getProbaFromTableWithContextQuestion = () => {
     const aCapB = randint(1, 20);
-    const aCapBBarre = randint(1, 20);
-    const aBarreCapB = randint(1, 20);
-    const aBarreCapBBarre = randint(1, 20);
+    const aCapBBarre = randint(1, 20, [aCapB]);
+    const aBarreCapB = randint(1, 20, [aCapB, aCapBBarre]);
+    const aBarreCapBBarre = randint(1, 20, [aCapB, aCapBBarre, aBarreCapB]);
     const total = aBarreCapB + aBarreCapBBarre + aCapB + aCapBBarre;
     const aTotal = aCapB + aCapBBarre;
     const bTotal = aCapB + aBarreCapB;

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

@@ -31,7 +31,7 @@ const getAverageListQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers,
-        hint: "La moyenne d'une liste de valeurs est la somme de ses valeurs divisé par le nombre de valeurs.",
+        hint: "La moyenne d'une liste de valeurs est la somme des valeurs divisée par le nombre de valeurs.",
         correction: `
 On additionne toutes les valeurs :
 

package/lib/exercises/math/probaStat/stats1var/choseReasoningForIndicator.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"choseReasoningForIndicator.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/choseReasoningForIndicator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAuHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAgB5D,CAAC"}

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

@@ -0,0 +1,105 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { average } from "../../../../utils/average.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const { values, indicatorAsked } = identifiers;
+    const avg = average(values);
+    const max = Math.max(...values);
+    tryToAddWrongProp(propositions, `La ${indicatorAsked} est $${avg}$ car $\\frac{${operatorComposition(AddNode, values.map((v) => v.toTree())).toTex()}}{${values.length}} = ${avg}$`, "raw");
+    tryToAddWrongProp(propositions, `La ${indicatorAsked} est $${avg}$ car c'est la moitié de $${max}$.`, "raw");
+    tryToAddWrongProp(propositions, `La ${indicatorAsked} est $${avg}$ car la valeur $${avg}$ est au milieu de la série.`, "raw");
+    tryToAddWrongProp(propositions, `La ${indicatorAsked} est $${avg}$ car il y a dans la série autant de valeurs inférieures à $${avg}$ que de valeurs supérieures à $${avg}$.`, "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { values, indicatorAsked } = identifiers;
+    const avg = average(values);
+    return indicatorAsked === "moyenne"
+        ? `La moyenne est $${avg}$ car $\\frac{${operatorComposition(AddNode, values.map((v) => v.toTree())).toTex()}}{${values.length}} = ${avg}$`
+        : `La médiane est $${avg}$ car il y a dans la série autant de valeurs inférieures à $${avg}$ que de valeurs supérieures à $${avg}$.`;
+};
+const getInstruction = (identifiers) => {
+    const { values, indicatorAsked } = identifiers;
+    const avg = average(values);
+    return `Voici une série de valeurs : 
+  
+$$
+${values.join("\\ ; \\ ")}
+$$
+
+La ${indicatorAsked} de cette série est $${avg}$. 
+
+Quelle est la justification correcte ?`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getChoseReasoningForIndicatorQuestion = (ops) => {
+    const max = 2 * randint(5, 20);
+    const x = max / 2;
+    let otherValues = [];
+    const miserablyDo = () => {
+        const b = randint(x + 1, 2 * x);
+        const c = randint(x + 1, 2 * x);
+        let remaining = 4 * x - b - c;
+        const d = randint(0, Math.min(remaining + 1, x));
+        remaining -= d;
+        const e = randint(0, Math.min(remaining + 1, x));
+        remaining -= e;
+        const f = remaining;
+        otherValues = [max, b, c, d, e, f];
+    };
+    do {
+        miserablyDo();
+    } while (otherValues[otherValues.length - 1] >= x);
+    const shuffled = shuffle(otherValues);
+    shuffled.splice(3, 0, x);
+    const identifiers = {
+        values: shuffled,
+        indicatorAsked: random(["moyenne", "médiane"]),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const choseReasoningForIndicator = {
+    id: "choseReasoningForIndicator",
+    label: "Trouver le bon raisonnement pour déterminer une moyenne/une médiane",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getChoseReasoningForIndicatorQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    answerType: "QCU",
+};

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

@@ -12,4 +12,5 @@ export * from "./standardDeviationList.js";
 export * from "./standardDeviationTable.js";
 export * from "./interquartilesList.js";
 export * from "./interquartilesTable.js";
+export * from "./choseReasoningForIndicator.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC"}

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

@@ -12,3 +12,4 @@ export * from "./standardDeviationList.js";
 export * from "./standardDeviationTable.js";
 export * from "./interquartilesList.js";
 export * from "./interquartilesTable.js";
+export * from "./choseReasoningForIndicator.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC"}

package/lib/exercises/math/spaceGeometry/basis/index.js

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

package/lib/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    l: number;
+    L: number;
+    h: number;
+    askedPoint: string;
+    givenPoints: string[];
+};
+export declare const spaceCoordinatesInPrism: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=spaceCoordinatesInPrism.d.ts.map

package/lib/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaceCoordinatesInPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAyKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAiBzD,CAAC"}