math-exercises 2.1.21 → 2.1.24

package/lib/exercises/math/suites/sequenceEvaluation.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequenceEvaluation = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const affine_1 = require("../../../math/polynomials/affine");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const getSequenceEvaluationQuestion = () => {
+    const termeid = (0, randint_1.randint)(1, 3);
+    const a = (0, randint_1.randint)(-10, 10, [0]);
+    const b = (0, randint_1.randint)(-10, 10);
+    const affine = new affine_1.Affine(a, b, "n");
+    let terme;
+    let termeAdd = 0;
+    let termeMult = 1;
+    if (termeid === 1) {
+        termeAdd = (0, randint_1.randint)(1, 4);
+        terme = new addNode_1.AddNode(new variableNode_1.VariableNode("n"), new numberNode_1.NumberNode(termeAdd));
+    }
+    else if (termeid === 2) {
+        termeMult = (0, randint_1.randint)(2, 4);
+        terme = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n"));
+    }
+    else {
+        termeAdd = (0, randint_1.randint)(1, 4);
+        termeMult = (0, randint_1.randint)(1, 4);
+        terme = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(termeAdd));
+    }
+    let answer;
+    if (termeid === 1) {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        answer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else if (termeid === 2) {
+        const innerTerm = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n"));
+        answer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        answer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    const question = {
+        answer: answer.toTex(),
+        instruction: `Soit $(u_n)$ une suite telle que $u_n = ${affine.toTex()}$. Exprimer $u_{${terme.toTex()}}$.`,
+        keys: ["n"],
+        answerFormat: "tex",
+        identifiers: {
+            termeid,
+            affine: [a, b],
+            termeAdd,
+            termeMult,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, termeid, affine, termeAdd, termeMult }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const a = affine[0];
+    const b = affine[1];
+    let wrongAnswer;
+    if (termeid === 1) {
+        const wrongInnerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * (termeAdd + (0, randint_1.randint)(-2, 2))));
+        wrongAnswer = new addNode_1.AddNode(wrongInnerTerm, new numberNode_1.NumberNode(b + (0, randint_1.randint)(-5, 5))).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else if (termeid === 2) {
+        const wrongInnerTerm = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * (termeMult + (0, randint_1.randint)(-1, 1))), new variableNode_1.VariableNode("n"));
+        wrongAnswer = new addNode_1.AddNode(wrongInnerTerm, new numberNode_1.NumberNode(b + (0, randint_1.randint)(-5, 5))).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else {
+        const wrongInnerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * (termeMult + (0, randint_1.randint)(-1, 1))), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * (termeAdd + (0, randint_1.randint)(-2, 2))));
+        wrongAnswer = new addNode_1.AddNode(wrongInnerTerm, new numberNode_1.NumberNode(b + (0, randint_1.randint)(-5, 5))).simplify({
+            forbidFactorize: true,
+        });
+    }
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new affine_1.Affine((0, randint_1.randint)(-10, 10, [0]), (0, randint_1.randint)(-10, 10), "n").toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { affine, termeid, termeAdd, termeMult }) => {
+    const a = affine[0];
+    const b = affine[1];
+    let terme;
+    if (termeid === 1) {
+        terme = new addNode_1.AddNode(new variableNode_1.VariableNode("n"), new numberNode_1.NumberNode(termeAdd));
+    }
+    else if (termeid === 2) {
+        terme = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n"));
+    }
+    else {
+        terme = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(termeAdd));
+    }
+    let validanswer;
+    if (termeid === 1) {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        validanswer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else if (termeid === 2) {
+        const innerTerm = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n"));
+        validanswer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        validanswer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    const latexs = validanswer.toAllValidTexs();
+    return latexs.includes(ans);
+};
+exports.sequenceEvaluation = {
+    id: "sequenceEvaluation",
+    label: "Évaluer un terme d'une suite",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequenceEvaluationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/suites/sequencePlot.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    nValue: number;
+    points: number[][];
+    isArithmetic: boolean;
+};
+export declare const sequencePlot: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sequencePlot.d.ts.map

package/lib/exercises/math/suites/sequencePlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencePlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/suites/sequencePlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAsFF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}

package/lib/exercises/math/suites/sequencePlot.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequencePlot = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const getSequencePlotQuestion = () => {
+    const isArithmetic = (0, coinFlip_1.coinFlip)();
+    const a = isArithmetic ? (0, randfloat_1.randfloat)(0.1, 0.5, 1) : (0, randfloat_1.randfloat)(1.01, 1.1, 2);
+    const b = (0, randint_1.randint)(2, 10);
+    const nMax = 10;
+    const points = [];
+    for (let n = 0; n <= nMax; n++) {
+        let u_n;
+        if (isArithmetic) {
+            const noise = (0, randfloat_1.randfloat)(-1, 1, 1);
+            u_n = a * n + b + noise;
+        }
+        else {
+            const noise = (0, randfloat_1.randfloat)(-1, 1, 1);
+            u_n = b * Math.pow(a, n) + noise;
+        }
+        points.push([n, Math.round(u_n)]);
+    }
+    const nValue = (0, randint_1.randint)(0, nMax);
+    const u_nValue = points[nValue][1];
+    const commands = points.map((point, index) => {
+        return `A${index}=(${point[0]},${point[1]})`;
+    });
+    commands.push(...points.map((_, index) => {
+        return `SetFixed(A${index},true)`;
+    }), ...points.map((_, index) => {
+        return `SetLabelMode(A${index},1)`;
+    }));
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideAxes: false,
+        hideGrid: false,
+        isXAxesNatural: true,
+        isGridSimple: true,
+    });
+    const sequenceType = isArithmetic ? "arithmétique" : "géométrique";
+    const question = {
+        answer: u_nValue.toString(),
+        instruction: `Ci-dessous est tracé un nuage de points représentant les valeurs d'une suite ${sequenceType} $(u_n)$. Quelle est la valeur de $u_{${nValue}}$ ?`,
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: ggb.getAdaptedCoords({
+            xMin: 0,
+            xMax: nMax,
+            yMin: Math.min(...points.map((p) => p[1])) - 2,
+            yMax: Math.max(...points.map((p) => p[1])) + 2,
+        }),
+        keys: [],
+        answerFormat: "raw",
+        identifiers: { nValue, points, isArithmetic },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, nValue, points }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const correctValue = parseInt(answer);
+    while (propositions.length < n) {
+        const wrongAnswer = (correctValue + (0, randint_1.randint)(-2, 2)).toString();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.sequencePlot = {
+    id: "sequencePlot",
+    label: "Lire graphiquement un terme d'une suite à partir d'un nuage de points",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    hasGeogebra: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequencePlotQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAiNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAuMF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.js

@@ -54,7 +54,7 @@ const getTrigonometrySideCalcul = () => {
     const question = {
         instruction: `Le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$ est tel que $${sides[randSide]} = ${(sideLengths[randSide] + "").replace(".", ",")}$ cm et $\\widehat{${angle[randAngle]}} = ${(angleValue[randAngle] + "").replace(".", ",")}^\\circ$. Calculer $${sides[randSideQuestion]}$ à $0,1$ cm près.`,
         answer,
-        hint: getHint(sides, angle[randAngle]),
+        hint: getHint(),
         correction: getCorrection(sides, sideLengths, randSideQuestion, randSide, angle[randAngle], angleValue[randAngle], answer),
         keys: [],
         commands: ggb.commands,
@@ -73,11 +73,7 @@ const getPropositions = (n, { answer }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const getHint = (sides, angle) => {
-    const hypothenus = sides[2];
-    const adjacent = sides.filter((value) => value !== hypothenus &&
-        [value.charAt(0), value.charAt(1)].includes(angle))[0];
-    const opposite = sides.filter((value) => value !== hypothenus && value !== adjacent[0])[0];
+const getHint = () => {
     return `Identifier le côté opposé, le côté adjacent et l'hypoténuse, puis utiliser la bonne formule de trigonométrie.`;
 };
 const getCorrection = (sides, sideLengths, randSideQuestion, randSide, angle, angleValue, answer) => {

package/lib/geogebra/geogebraConstructor.d.ts

@@ -7,12 +7,15 @@ type GeogebraOptions = {
     isGridSimple?: boolean;
     isXAxesNatural?: boolean;
     axisLabels?: string[];
+    is3D?: boolean;
 };
 type GetAdaptedCoords = {
     xMin: number;
     xMax: number;
     yMin: number;
     yMax: number;
+    zMin?: number;
+    zMax?: number;
     forceShowAxes?: boolean;
 };
 export declare class GeogebraConstructor {
@@ -22,11 +25,12 @@ export declare class GeogebraConstructor {
     hideAxes: boolean;
     isGridSimple: boolean;
     isGridBold: boolean;
+    is3D: boolean;
     isAxesRatioFixed: boolean;
     isXAxesNatural: boolean;
     axisLabels?: string[];
     constructor(commands: string[], options: GeogebraOptions | undefined);
-    getAdaptedCoords({ xMin, xMax, yMin, yMax, forceShowAxes, }: GetAdaptedCoords): number[];
+    getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }: GetAdaptedCoords): number[];
     getOptions(): GeogebraOptions;
 }
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;gBACV,QAAQ,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,eAAe,GAAG,SAAS;IAYpE,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAmBnB,UAAU,IAAI,eAAe;CAY9B"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;gBACV,QAAQ,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,eAAe,GAAG,SAAS;IAapE,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAyCnB,UAAU,IAAI,eAAe;CAa9B"}

package/lib/geogebra/geogebraConstructor.js

@@ -12,24 +12,47 @@ class GeogebraConstructor {
         this.isGridSimple = options?.isGridSimple ?? false;
         this.isXAxesNatural = options?.isXAxesNatural ?? false;
         this.axisLabels = options?.axisLabels ?? undefined;
+        this.is3D = options?.is3D ?? false;
     }
-    getAdaptedCoords({ xMin, xMax, yMin, yMax, forceShowAxes, }) {
+    getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }) {
         const showAxes = forceShowAxes ?? this.hideAxes ? false : true;
         const xDelta = xMax - xMin;
         const yDelta = yMax - yMin;
-        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)),
-        ];
-        if (showAxes) {
-            coords[0] = Math.min(-1, coords[0]);
-            coords[1] = Math.max(1, coords[1]);
-            coords[2] = Math.min(-1, coords[2]);
-            coords[3] = Math.max(1, coords[3]);
+        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)),
+            ];
+            if (showAxes) {
+                coords[0] = Math.min(-1, coords[0]);
+                coords[1] = Math.max(1, coords[1]);
+                coords[2] = Math.min(-1, coords[2]);
+                coords[3] = Math.max(1, coords[3]);
+                coords[4] = Math.min(-1, coords[4]);
+                coords[5] = Math.max(1, coords[5]);
+            }
+            return coords;
+        }
+        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)),
+            ];
+            if (showAxes) {
+                coords[0] = Math.min(-1, coords[0]);
+                coords[1] = Math.max(1, coords[1]);
+                coords[2] = Math.min(-1, coords[2]);
+                coords[3] = Math.max(1, coords[3]);
+            }
+            return coords;
         }
-        return coords;
     }
     getOptions() {
         return {
@@ -41,6 +64,7 @@ class GeogebraConstructor {
             isAxesRatioFixed: this.isAxesRatioFixed,
             isXAxesNatural: this.isXAxesNatural,
             axisLabels: this.axisLabels,
+            is3D: this.is3D,
         };
     }
 }

package/lib/index.d.ts

@@ -589,6 +589,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
         b: number;
         closure: import("./tree/nodes/sets/closure").ClosureType;
     }[];
+}> | import("./exercises/exercise").Exercise<{
+    xValues: number[];
+    imageValues: number[];
 }> | import("./exercises/exercise").Exercise<{
     k: number;
 }> | import("./exercises/exercise").Exercise<{
@@ -892,6 +895,38 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     askConvex: boolean;
     quadcoeffs: number[];
     inflexionPoint: number;
+}> | import("./exercises/exercise").Exercise<{
+    cubeSide: number;
+}> | import("./exercises/exercise").Exercise<{
+    h: number;
+    baseOfPyramid: {
+        type: string;
+        sideSizes: number[];
+    };
+}> | import("./exercises/exercise").Exercise<{
+    h: number;
+    baseOfPyramidSides: {
+        ABSide: number;
+        ACSide: number;
+        BCSide: number;
+    };
+}> | import("./exercises/exercise").Exercise<{
+    h: number;
+    baseOfPyramidSides: {
+        ABSide: number;
+        ACSide: number;
+        BCSide: number;
+    };
+}> | import("./exercises/exercise").Exercise<{
+    radius: number;
+    height: number;
+}> | import("./exercises/exercise").Exercise<{
+    radius: number;
+}> | import("./exercises/exercise").Exercise<{
+    length: number;
+    width: number;
+    height: number;
+    angle: number;
 }> | import("./exercises/exercise").Exercise<{
     coeffs: number[];
     to: string;
@@ -1330,6 +1365,15 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
         n: number;
         p: number;
     };
+}> | import("./exercises/exercise").Exercise<{
+    termeid: number;
+    affine: number[];
+    termeAdd: number;
+    termeMult: number;
+}> | import("./exercises/exercise").Exercise<{
+    nValue: number;
+    points: number[][];
+    isArithmetic: boolean;
 }>)[];
 declare const pcExercises: (import("./exercises/exercise").Exercise<{
     numbers: number[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.1.21",
+  "version": "2.1.24",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [

package/lib/exercises/calcul/addAndSub.d.ts

@@ -1,7 +0,0 @@
-import { MathExercise } from "../exercise";
-type Identifiers = {
-    numbers: number[];
-};
-export declare const addAndSubExercise: MathExercise<Identifiers>;
-export {};
-//# sourceMappingURL=addAndSub.d.ts.map

package/lib/exercises/calcul/addAndSub.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"addAndSub.d.ts","sourceRoot":"","sources":["../../../src/exercises/calcul/addAndSub.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EAQb,MAAM,aAAa,CAAC;AA8BrB,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAoBzC,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAYvD,CAAC"}

package/lib/exercises/calcul/addAndSub.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addAndSubExercise = void 0;
-const randint_1 = require("../../math/utils/random/randint");
-const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const addNode_1 = require("../../tree/nodes/operators/addNode");
-const shuffle_1 = require("../../utils/shuffle");
-const exercise_1 = require("../exercise");
-const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
-/**
- * a±b±c±d
- */
-const getAddAndSubQuestions = () => {
-    const nbOperations = (0, randint_1.randint)(2, 4);
-    const numbers = [];
-    for (let i = 0; i < nbOperations + 1; i++) {
-        numbers.push((0, randint_1.randint)(-15, 15, [0]));
-    }
-    const allNumbersNodes = numbers.map((nb) => new numberNode_1.NumberNode(nb));
-    let statementTree = new addNode_1.AddNode(allNumbersNodes[0], allNumbersNodes[1]);
-    for (let i = 2; i < allNumbersNodes.length; i++) {
-        statementTree = new addNode_1.AddNode(statementTree, allNumbersNodes[i]);
-    }
-    const answer = numbers.reduce((a, b) => a + b) + "";
-    const statement = statementTree.toTex();
-    const question = {
-        instruction: `Calculer : $${statement}$`,
-        startStatement: statement,
-        answer,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { numbers },
-    };
-    return question;
-};
-const getPropositions = (n, { answer }) => {
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    while (propositions.length < n) {
-        const randomOffset = (0, randint_1.randint)(-9, 10, [0]);
-        const wrongAnswer = Number(answer) + randomOffset;
-        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toString());
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-const isAnswerValid = (studentAns, { answer }) => {
-    const answerTree = new numberNode_1.NumberNode(Number(answer));
-    const texs = answerTree.toAllValidTexs();
-    return texs.includes(studentAns);
-};
-exports.addAndSubExercise = {
-    id: "addAndSub",
-    connector: "=",
-    label: "Additions et soustractions",
-    levels: ["6ème", "5ème"],
-    sections: ["Calculs"],
-    isSingleStep: true,
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAddAndSubQuestions, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-};

package/lib/exercises/calcul/addAndSubWithoutRelatives.d.ts

@@ -1,7 +0,0 @@
-import { MathExercise } from "../exercise";
-type Identifiers = {
-    numbers: number[];
-};
-export declare const addAndSubWithoutRelatives: MathExercise<Identifiers>;
-export {};
-//# sourceMappingURL=addAndSubWithoutRelatives.d.ts.map

package/lib/exercises/calcul/addAndSubWithoutRelatives.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"addAndSubWithoutRelatives.d.ts","sourceRoot":"","sources":["../../../src/exercises/calcul/addAndSubWithoutRelatives.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,YAAY,EAQb,MAAM,aAAa,CAAC;AA4CrB,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAoBzC,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,WAAW,CAa/D,CAAC"}

package/lib/exercises/calcul/addAndSubWithoutRelatives.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addAndSubWithoutRelatives = void 0;
-const randint_1 = require("../../math/utils/random/randint");
-const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const addNode_1 = require("../../tree/nodes/operators/addNode");
-const shuffle_1 = require("../../utils/shuffle");
-const exercise_1 = require("../exercise");
-const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
-/**
- * a±b±c±d
- */
-const getAddAndSubWithoutRelatives = () => {
-    let answer = -1;
-    let statementTree;
-    let numbers = [];
-    while (answer < 0) {
-        const nbOperations = (0, randint_1.randint)(2, 4);
-        numbers = [];
-        do {
-            numbers = [];
-            numbers.push((0, randint_1.randint)(1, 15));
-            let sum = numbers[0];
-            for (let i = 1; i < nbOperations + 1; i++) {
-                numbers.push((0, randint_1.randint)(-sum, 15, [0]));
-                sum += numbers[i];
-            }
-        } while (numbers.every((a) => a > 0));
-        const allNumbersNodes = numbers.map((nb) => new numberNode_1.NumberNode(nb));
-        statementTree = new addNode_1.AddNode(allNumbersNodes[0], allNumbersNodes[1]);
-        for (let i = 2; i < allNumbersNodes.length; i++) {
-            statementTree = new addNode_1.AddNode(statementTree, allNumbersNodes[i]);
-        }
-        answer = numbers.reduce((a, b) => a + b);
-    }
-    const answerTex = answer.toString();
-    const question = {
-        instruction: `Calculer : $${statementTree.toTex()}$`,
-        startStatement: statementTree.toTex(),
-        answer: answerTex,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { numbers },
-    };
-    return question;
-};
-const getPropositions = (n, { answer }) => {
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    while (propositions.length < n) {
-        const incorrectAnswer = Number(answer) + (0, randint_1.randint)(-5, 6, [0]);
-        (0, exercise_1.tryToAddWrongProp)(propositions, incorrectAnswer.toString());
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-const isAnswerValid = (studentAns, { answer }) => {
-    const answerTree = new numberNode_1.NumberNode(Number(answer));
-    const texs = answerTree.toAllValidTexs();
-    return texs.includes(studentAns);
-};
-exports.addAndSubWithoutRelatives = {
-    id: "addAndSubWithoutRelatives",
-    connector: "=",
-    label: "Additions et soustractions sans les nombres relatifs",
-    levels: ["6ème", "5ème"],
-    sections: ["Calculs"],
-    isSingleStep: true,
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAddAndSubWithoutRelatives, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-};

package/lib/exercises/calcul/arithmetics/commonDivisorsList.d.ts

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

package/lib/exercises/calcul/arithmetics/commonDivisorsList.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"commonDivisorsList.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calcul/arithmetics/commonDivisorsList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2DF,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,WAAW,CAYxD,CAAC"}