math-exercises 3.0.16 → 3.0.18

package/lib/exercises/math/calcul/proportionality/index.d.ts

@@ -5,4 +5,5 @@ export * from "./scaleUsage.js";
 export * from "./isTableProportionalNonInteger.js";
 export * from "./findCoeffInProportionalTableNonIntegers.js";
 export * from "./isTableProportional.js";
+export * from "./rectangleSideAfterReduction.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/proportionality/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oCAAoC,CAAC;AACnD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oCAAoC,CAAC;AACnD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC"}

package/lib/exercises/math/calcul/proportionality/index.js

@@ -5,3 +5,4 @@ export * from "./scaleUsage.js";
 export * from "./isTableProportionalNonInteger.js";
 export * from "./findCoeffInProportionalTableNonIntegers.js";
 export * from "./isTableProportional.js";
+export * from "./rectangleSideAfterReduction.js";

package/lib/exercises/math/calcul/proportionality/rectangleSideAfterReduction.d.ts

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

package/lib/exercises/math/calcul/proportionality/rectangleSideAfterReduction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rectangleSideAfterReduction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/rectangleSideAfterReduction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CAGnB,CAAC;AA8OF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAoB7D,CAAC"}

package/lib/exercises/math/calcul/proportionality/rectangleSideAfterReduction.js

@@ -0,0 +1,198 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.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 { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { D3Node } from "d3-node";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { lengths } = identifiers;
+    const [a, b, c, d] = lengths;
+    addValidProp(propositions, answer);
+    const askedIndex = lengths.findIndex((e) => !e);
+    switch (askedIndex) {
+        case 0:
+            tryToAddWrongProp(propositions, c + (b - d) + "");
+            tryToAddWrongProp(propositions, round((b * d) / c, 1).frenchify());
+            tryToAddWrongProp(propositions, round((c * d) / b, 1).frenchify());
+            break;
+        case 1:
+            tryToAddWrongProp(propositions, d + (a - c) + "");
+            tryToAddWrongProp(propositions, round((c * d) / a, 1).frenchify());
+            tryToAddWrongProp(propositions, round((a * c) / d, 1).frenchify());
+            break;
+        case 2:
+            tryToAddWrongProp(propositions, a - (b - d) + "");
+            tryToAddWrongProp(propositions, round((b * d) / a, 1).frenchify());
+            tryToAddWrongProp(propositions, round((a * b) / d, 1).frenchify());
+            break;
+        case 3:
+            tryToAddWrongProp(propositions, b - (a - c) + "");
+            tryToAddWrongProp(propositions, round((a * c) / b, 1).frenchify());
+            tryToAddWrongProp(propositions, round((a * b) / c, 1).frenchify());
+        default:
+            break;
+    }
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randfloat(2, 10, 1).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { lengths } = identifiers;
+    const [a, b, c, d] = lengths;
+    const asked = lengths.findIndex((e) => !e);
+    switch (asked) {
+        case 0:
+            //a = bc/d
+            return round((b * c) / d, 1).frenchify();
+        case 1:
+            //b = da/c
+            return round((d * a) / c, 1).frenchify();
+        case 2:
+            //c = ad/b
+            return round((a * d) / b, 1).frenchify();
+        case 3:
+        default:
+            //d = bc/a
+            return round((b * c) / a, 1).frenchify();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { lengths } = identifiers;
+    const [a, b, c, d] = lengths;
+    const askedIndex = lengths.findIndex((e) => !e);
+    // Create d3-node instance
+    const d3n = new D3Node();
+    // Set SVG dimensions
+    const width = 300, height = 150;
+    const svg = d3n.createSVG(width, height);
+    // Function to add rotated rectangles
+    function addRectangle(svg, x, y, w, h, angle, color, label1, label2) {
+        const group = svg
+            .append("g")
+            .attr("transform", `translate(${x},${y}) rotate(${angle})`);
+        group
+            .append("rect")
+            .attr("width", w)
+            .attr("height", h)
+            .attr("fill", color)
+            .attr("fill-opacity", 0.3)
+            .attr("stroke", color)
+            .attr("stroke-width", 2);
+        // Add side labels
+        group
+            .append("text")
+            .attr("x", w + 5)
+            .attr("y", h / 2)
+            .attr("fill", color)
+            .attr("font-size", "14px")
+            .attr("font-weight", "bold")
+            .text(label1);
+        group
+            .append("text")
+            .attr("x", w / 2 - 5)
+            .attr("y", h + 18)
+            .attr("fill", color)
+            .attr("font-size", "14px")
+            .attr("font-weight", "bold")
+            .text(label2);
+    }
+    // Add first rectangle (red) - Bigger
+    addRectangle(svg, 60, 60, 120, 40, -20, "red", b === 0 ? "?" : b + "", a === 0 ? "?" : a + "");
+    // Add second rectangle (blue) - Smaller
+    addRectangle(svg, 190, 90, 80, 25, -20, "blue", d === 0 ? "?" : d + "", c === 0 ? "?" : c + "");
+    // Output the SVG string
+    const sideIsOnFirstRect = askedIndex < 2;
+    const sideTypeAsked = askedIndex % 2 === 0 ? "longueur" : "largeur";
+    const sidesString = lengths.map((e, i) => e === 0 ? "" : `${i % 2 === 0 ? "longueur" : "largeur"} $${e}$ cm`);
+    return `Sur la figure suivante, le premier rectangle a pour ${sideIsOnFirstRect
+        ? sidesString[askedIndex === 1 ? 0 : 1]
+        : sidesString[0] + " et pour " + sidesString[1]}. 
+
+Le deuxième rectangle est une réduction du premier rectangle et a pour ${sideIsOnFirstRect
+        ? sidesString[2] + " et pour " + sidesString[3]
+        : sidesString[askedIndex === 3 ? 2 : 3]}.
+  
+${d3n.svgString()}
+
+Quelle est la ${sideTypeAsked} (en cm) du ${sideIsOnFirstRect ? "premier" : "deuxième"} rectangle ? Arrondir à $0,1$ cm si nécessaire.`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer, 1);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRectangleSideAfterReductionQuestion = (ops) => {
+    const askedSize = randint(0, 4);
+    let a;
+    let b;
+    let c;
+    let d;
+    switch (askedSize) {
+        case 0:
+            a = 0;
+            c = randint(3, 10);
+            d = randint(1, c);
+            b = randint(d + 1, 15);
+            break;
+        case 1:
+            b = 0;
+            c = randint(3, 10);
+            d = randint(1, c);
+            a = randint(c + 1, 15);
+            break;
+        case 2:
+            c = 0;
+            a = randint(5, 10);
+            b = randint(2, a);
+            d = randint(1, b);
+            break;
+        case 3:
+        default:
+            d = 0;
+            a = randint(5, 10);
+            b = randint(2, a);
+            c = randint(3, a);
+            break;
+    }
+    const identifiers = {
+        lengths: [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;
+};
+export const rectangleSideAfterReduction = {
+    id: "rectangleSideAfterReduction",
+    // connector: "",
+    label: "Utiliser la proportionnalité pour déterminer les dimensions d'un rectangle après réduction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRectangleSideAfterReductionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

package/lib/exercises/math/derivation/derivative/thirdDegreeFunctionVariation.d.ts

@@ -1,6 +1,7 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
     a: number;
+    c: number;
     coin: number;
     racine1: number;
     racine2: number;

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

@@ -1 +1 @@
-{"version":3,"file":"thirdDegreeFunctionVariation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/thirdDegreeFunctionVariation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAkHF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}
+{"version":3,"file":"thirdDegreeFunctionVariation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/thirdDegreeFunctionVariation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAsIF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAiB9D,CAAC"}

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

@@ -13,21 +13,21 @@ import { unionIntervalParser } from "../../../../tree/parsers/unionIntervalParse
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-const getThirdDegreeFunctionVariation = () => {
-    const a = randint(-3, 4, [0]);
-    const c = randint(-2, 3);
-    const racine1 = randint(-5, 4);
-    const racine2 = randint(racine1 + 1, 6);
-    const coefs = [
-        c,
-        a * racine1 * racine2,
-        (-a * (racine1 + racine2)) / 2,
-        a / 3,
-    ];
-    const polynome = new Polynomial(coefs);
-    const coin = coinFlip() ? -1 : 1;
-    const instruction = `Soit $f$ la fonction représentée ci-dessous. Sur quel intervalle la dérivée de $f$ est-elle ` +
-        (coin < 0 ? "négative ?" : "positive ?");
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds?.c !== undefined)
+        return oldIds;
+    return {
+        ...oldIds,
+        c: randint(-2, 3),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { a, coin, racine1, racine2 } = identifiers;
+    return (`Soit $f$ la fonction représentée ci-dessous. Sur quel intervalle la dérivée de $f$ est-elle ` +
+        (coin < 0 ? "négative ?" : "positive ?"));
+};
+const getAnswer = (identifiers) => {
+    const { a, coin, racine1, racine2 } = identifiers;
     const racine1Tree = new NumberNode(racine1);
     const racine2Tree = new NumberNode(racine2);
     const answer = coin * a < 0
@@ -36,12 +36,23 @@ const getThirdDegreeFunctionVariation = () => {
             new IntervalNode(MinusInfinityNode, racine1Tree, ClosureType.OF),
             new IntervalNode(racine2Tree, PlusInfinityNode, ClosureType.FO),
         ]).toTex();
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, coin, racine1, racine2, c } = identifiers;
+    const coefs = [
+        c,
+        a * racine1 * racine2,
+        (-a * (racine1 + racine2)) / 2,
+        a / 3,
+    ];
+    const polynome = new Polynomial(coefs);
+    const y1 = polynome.calculate(racine1);
+    const y2 = polynome.calculate(racine2);
     const commands = [
         `f(x) = ${polynome.toMathString()}`,
         `SetColor(f, "${randomColor()}")`,
     ];
-    const y1 = polynome.calculate(racine1);
-    const y2 = polynome.calculate(racine2);
     const yMax = Math.max(y1, y2);
     const yMin = Math.min(y1, y2);
     const xMax = Math.max(racine1, racine2);
@@ -51,16 +62,25 @@ const getThirdDegreeFunctionVariation = () => {
         lockedAxesRatio: false,
         gridDistance: false,
     });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+const getThirdDegreeFunctionVariation = () => {
+    const a = randint(-3, 4, [0]);
+    const c = randint(-2, 3);
+    const racine1 = randint(-5, 4);
+    const racine2 = randint(racine1 + 1, 6);
+    const coin = coinFlip() ? -1 : 1;
+    const identifiers = { racine1, racine2, coin, a, c };
     const question = {
-        instruction,
+        instruction: getInstruction(identifiers),
         startStatement: "S",
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["lbracket", "rbracket", "semicolon", "infty", "cup"],
         answerFormat: "tex",
-        ggbOptions: ggb.getOptions({
-            coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
-        }),
-        identifiers: { racine1, racine2, coin, a },
+        ggbOptions: getGGBOptions(identifiers),
+        identifiers,
     };
     return question;
 };
@@ -108,4 +128,8 @@ export const thirdDegreeFunctionVariation = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/derivation/tangent/derivativeNumberReading.d.ts

@@ -2,6 +2,7 @@ import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
     A: number[];
     B: number[];
+    coeffs: number[];
 };
 export declare const derivativeNumberReading: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/derivation/tangent/derivativeNumberReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derivativeNumberReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeNumberReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AA2FF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"derivativeNumberReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeNumberReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAgJF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}

package/lib/exercises/math/derivation/tangent/derivativeNumberReading.js

@@ -8,11 +8,53 @@ import { Polynomial } from "../../../../math/polynomials/polynomial.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getDerivativeNumberReading = () => {
-    let xA, yA, xB, yB;
-    [xA, yA] = [1, 2].map((el) => randint(-5, 6));
-    xB = xA > 0 ? randint(xA - 4, 6, [xA]) : randint(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
-    yB = yA > 0 ? randint(yA - 4, 6) : randint(-4, yA + 5);
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds?.coeffs?.length)
+        return oldIds;
+    const { A, B } = oldIds;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
+    const pente = new Rational(yB - yA, xB - xA).simplify();
+    const penteValue = pente.value;
+    const [a, b] = [
+        (3 * randint(-100, 100, [0])) / 100,
+        (2 * randint(-4, 5)) / 100,
+    ];
+    const c = penteValue - a * Math.pow(xA, 2) - b * xA;
+    const d = yA - (a / 3) * Math.pow(xA, 3) - (b / 2) * Math.pow(xA, 2) - xA * c;
+    return {
+        A,
+        B,
+        coeffs: [d, c, b / 2, a / 3],
+    };
+};
+const getInstruction = (identifiers) => {
+    const { A, B } = identifiers;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
+    return `Ci-dessous sont tracées la courbe $\\mathcal C_f$ de la fonction $f$ et la tangente à cette courbe au point d'abscisse $${xA}$.$\\\\$ Déterminer $f'(${xA})$.`;
+};
+const getAnswer = (identifiers) => {
+    const { A, B } = identifiers;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
+    const pente = new Rational(yB - yA, xB - xA).simplify();
+    const penteTree = pente.toTree();
+    const answer = penteTree.toTex();
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { A, B } = identifiers;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
     const pente = new Rational(yB - yA, xB - xA).simplify();
     const origin = pente
         .opposite()
@@ -22,16 +64,7 @@ const getDerivativeNumberReading = () => {
     const originTree = origin.toTree();
     const penteString = penteTree.toMathString();
     const originString = originTree.toMathString();
-    const penteValue = pente.value;
-    const originValue = origin.value;
-    const [a, b] = [
-        (3 * randint(-100, 100, [0])) / 100,
-        (2 * randint(-4, 5)) / 100,
-    ];
-    const c = penteValue - a * Math.pow(xA, 2) - b * xA;
-    const d = yA - (a / 3) * Math.pow(xA, 3) - (b / 2) * Math.pow(xA, 2) - xA * c;
-    const polynome = new Polynomial([d, c, b / 2, a / 3]);
-    const instruction = `Ci-dessous sont tracées la courbe $\\mathcal C_f$ de la fonction $f$ et la tangente à cette courbe au point d'abscisse $${xA}$.$\\\\$ Déterminer $f'(${xA})$.`;
+    const polynome = new Polynomial(identifiers.coeffs);
     const commands = [
         `f(x) = ${polynome.toMathString()}`,
         `SetColor(f, "${blueMain}")`,
@@ -50,17 +83,36 @@ const getDerivativeNumberReading = () => {
     const ggb = new GeogebraConstructor({
         commands,
     });
-    const answer = penteTree.toTex();
+    return ggb.getOptions({
+        coords: [xMin - 5, xMax + 5, yMin - 5, yMax + 5],
+    });
+};
+const getDerivativeNumberReading = () => {
+    let xA, yA, xB, yB;
+    [xA, yA] = [1, 2].map((el) => randint(-5, 6));
+    xB = xA > 0 ? randint(xA - 4, 6, [xA]) : randint(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
+    yB = yA > 0 ? randint(yA - 4, 6) : randint(-4, yA + 5);
+    const pente = new Rational(yB - yA, xB - xA).simplify();
+    const penteValue = pente.value;
+    const [a, b] = [
+        (3 * randint(-100, 100, [0])) / 100,
+        (2 * randint(-4, 5)) / 100,
+    ];
+    const c = penteValue - a * Math.pow(xA, 2) - b * xA;
+    const d = yA - (a / 3) * Math.pow(xA, 3) - (b / 2) * Math.pow(xA, 2) - xA * c;
+    const identifiers = {
+        A: [xA, yA],
+        B: [xB, yB],
+        coeffs: [d, c, b / 2, a / 3],
+    };
     const question = {
-        instruction,
+        instruction: getInstruction(identifiers),
         startStatement: "a",
-        answer,
-        ggbOptions: ggb.getOptions({
-            coords: [xMin - 5, xMax + 5, yMin - 5, yMax + 5],
-        }),
+        answer: getAnswer(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
         keys: [],
-        identifiers: { A: [xA, yA], B: [xB, yB] },
+        identifiers,
     };
     return question;
 };
@@ -96,4 +148,8 @@ export const derivativeNumberReading = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/functions/trinoms/roots/rootsReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqDF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}
+{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAgB9C,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/rootsReading.js

@@ -4,9 +4,19 @@ import { randomColor } from "../../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
 import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-const getRootsReadingQuestion = () => {
-    const trinom = TrinomConstructor.randomNiceRoots(randint(1, 3));
+const getInstruction = (identifiers) => {
+    return `Déterminer graphiquement le ou les racine(s) du polynôme du second degré représenté ci-dessous : `;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
     const roots = trinom.getRoots();
+    const answer = roots.length === 1 ? roots[0].toString() : roots.join("\\text{ et }");
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
     const commands = [
         `f(x) = ${trinom.toMathString()}`,
         `SetColor(f, "${randomColor()}")`,
@@ -15,14 +25,18 @@ const getRootsReadingQuestion = () => {
         commands,
         lockedAxesRatio: false,
     });
-    const answer = roots.length === 1 ? roots[0].toString() : roots.join("\\text{ et }");
+    return ggb.getOptions({ coords: trinom.getCoords() });
+};
+const getRootsReadingQuestion = () => {
+    const trinom = TrinomConstructor.randomNiceRoots(randint(1, 3));
+    const identifiers = { a: trinom.a, b: trinom.b, c: trinom.c };
     const question = {
-        answer,
-        instruction: `Déterminer graphiquement le ou les racine(s) du polynôme du second degré représenté ci-dessous : `,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["et", "aucun"],
         answerFormat: "tex",
-        ggbOptions: ggb.getOptions({ coords: trinom.getCoords() }),
-        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+        ggbOptions: getGGBOptions(identifiers),
+        identifiers,
     };
     return question;
 };
@@ -60,4 +74,7 @@ export const rootsReading = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
 };

package/lib/exercises/math/functions/trinoms/summitAndCanonical/summitReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"summitReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/summitReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuDF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAa/C,CAAC"}
+{"version":3,"file":"summitReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/summitReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAgB/C,CAAC"}

package/lib/exercises/math/functions/trinoms/summitAndCanonical/summitReading.js

@@ -5,8 +5,18 @@ import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor
 import { Point } from "../../../../../math/geometry/point.js";
 import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-const getSummitReadingQuestion = () => {
-    const trinom = TrinomConstructor.randomCanonical();
+const getInstruction = (identifiers) => {
+    return `Déterminer les coordonnées du sommet de la parabole représentée ci-dessous :`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const answer = trinom.getSommet().toCoords();
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
     const commands = [
         `f(x) = ${trinom.toMathString()}`,
         `SetColor(f, "${randomColor()}")`,
@@ -15,16 +25,20 @@ const getSummitReadingQuestion = () => {
         commands,
         isGridSimple: true,
     });
-    const answer = trinom.getSommet().toCoords();
+    return ggb.getOptions({
+        coords: trinom.getCoords(),
+    });
+};
+const getSummitReadingQuestion = () => {
+    const trinom = TrinomConstructor.randomCanonical();
+    const identifiers = { a: trinom.a, b: trinom.b, c: trinom.c };
     const question = {
-        answer,
-        instruction: `Déterminer les coordonnées du sommet de la parabole représentée ci-dessous :`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["leftParenthesis", "semicolon", "rightParenthesis"],
-        ggbOptions: ggb.getOptions({
-            coords: trinom.getCoords(),
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+        identifiers,
     };
     return question;
 };
@@ -56,4 +70,7 @@ export const summitReading = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
 };

package/lib/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convexityQuadrinomialsGeo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA8JF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"convexityQuadrinomialsGeo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA+KF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAiB3D,CAAC"}

package/lib/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.js

@@ -32,33 +32,39 @@ function generateEvenInflexionPoint() {
     } while (inflexionPointX % 10 !== 0);
     return inflexionPointX;
 }
-const getConvexityQuadrinomialsGeoQuestion = () => {
-    const inflexionPointX = generateEvenInflexionPoint() * 0.1;
-    const quadrinomial = generatePolynomialWithIntegerInflexionPoint(3, inflexionPointX);
-    const quadcoeffs = quadrinomial.coefficients;
-    const trinomial = quadrinomial.derivate();
-    const criticalPoints = trinomial.getRoots();
-    const yValues = criticalPoints.map((x) => quadrinomial.calculate(x));
-    const xMin = Math.min(...criticalPoints) - 5;
-    const xMax = Math.max(...criticalPoints) + 5;
-    const yMin = Math.min(...yValues, 0) - 5;
-    const yMax = Math.max(...yValues, 0) + 5;
-    const askConvex = coinFlip();
+const getInstruction = (identifiers) => {
+    const { askConvex, inflexionPoint, quadcoeffs } = identifiers;
+    const questionType = askConvex ? "convexe" : "concave";
+    const instruction = `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur quel intervalle $f$ est-elle ${questionType} ?`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { askConvex, inflexionPoint, quadcoeffs } = identifiers;
     let interval;
     if (askConvex) {
         interval =
             quadcoeffs[3] > 0
-                ? new IntervalNode(inflexionPointX.toTree(), PlusInfinityNode, ClosureType.OO).toTex()
-                : new IntervalNode(MinusInfinityNode, inflexionPointX.toTree(), ClosureType.OO).toTex();
+                ? new IntervalNode(inflexionPoint.toTree(), PlusInfinityNode, ClosureType.OO).toTex()
+                : new IntervalNode(MinusInfinityNode, inflexionPoint.toTree(), ClosureType.OO).toTex();
     }
     else {
         interval =
             quadcoeffs[3] <= 0
-                ? new IntervalNode(inflexionPointX.toTree(), PlusInfinityNode, ClosureType.OO).toTex()
-                : new IntervalNode(MinusInfinityNode, inflexionPointX.toTree(), ClosureType.OO).toTex();
+                ? new IntervalNode(inflexionPoint.toTree(), PlusInfinityNode, ClosureType.OO).toTex()
+                : new IntervalNode(MinusInfinityNode, inflexionPoint.toTree(), ClosureType.OO).toTex();
     }
-    const questionType = askConvex ? "convexe" : "concave";
-    const instruction = `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur quel intervalle $f$ est-elle ${questionType} ?`;
+    return interval;
+};
+const getGGBOptions = (identifiers) => {
+    const { askConvex, inflexionPoint, quadcoeffs } = identifiers;
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const trinomial = quadrinomial.derivate();
+    const criticalPoints = trinomial.getRoots();
+    const yValues = criticalPoints.map((x) => quadrinomial.calculate(x));
+    const xMin = Math.min(...criticalPoints) - 5;
+    const xMax = Math.max(...criticalPoints) + 5;
+    const yMin = Math.min(...yValues, 0) - 5;
+    const yMax = Math.max(...yValues, 0) + 5;
     const commands = [
         `f(x) = ${quadrinomial.toMathString()}`,
         `SetColor(f, "${blueMain}")`,
@@ -69,15 +75,27 @@ const getConvexityQuadrinomialsGeoQuestion = () => {
         commands,
         lockedAxesRatio: false,
     });
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getConvexityQuadrinomialsGeoQuestion = () => {
+    const inflexionPointX = generateEvenInflexionPoint() * 0.1;
+    const quadrinomial = generatePolynomialWithIntegerInflexionPoint(3, inflexionPointX);
+    const quadcoeffs = quadrinomial.coefficients;
+    const askConvex = coinFlip();
+    const identifiers = {
+        askConvex,
+        quadcoeffs,
+        inflexionPoint: inflexionPointX,
+    };
     const question = {
-        answer: interval,
-        instruction,
-        ggbOptions: ggb.getOptions({
-            coords: [xMin, xMax, yMin, yMax],
-        }),
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         keys: ["rbracket", "lbracket", "semicolon", "infty", "reals"],
         answerFormat: "tex",
-        identifiers: { askConvex, quadcoeffs, inflexionPoint: inflexionPointX },
+        identifiers,
     };
     return question;
 };
@@ -118,4 +136,7 @@ export const convexityQuadrinomialsGeo = {
     isAnswerValid,
     subject: "Mathématiques",
     hasGeogebra: true,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
 };

package/lib/exercises/math/geometry/convexity/convexityTrinomialsGeo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convexityTrinomialsGeo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/convexity/convexityTrinomialsGeo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAkDF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"convexityTrinomialsGeo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/convexity/convexityTrinomialsGeo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAmEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

package/lib/exercises/math/geometry/convexity/convexityTrinomialsGeo.js

@@ -2,11 +2,18 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { blueMain } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { Trinom, TrinomConstructor } from "../../../../math/polynomials/trinom.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getConvexityTrinomialsGeoQuestion = () => {
-    const trinom = TrinomConstructor.random();
-    const instruction = `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur $\\mathbb{R}$, la fonction $f$ est :`;
+const getInstruction = (identifiers) => {
+    return `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur $\\mathbb{R}$, la fonction $f$ est :`;
+};
+const getAnswer = (identifiers) => {
+    const trinom = new Trinom(identifiers.trinom[0], identifiers.trinom[1], identifiers.trinom[2]);
+    const isConvex = trinom.a > 0 ? "Convexe" : "Concave";
+    return isConvex;
+};
+const getGGBOptions = (identifiers) => {
+    const trinom = new Trinom(identifiers.trinom[0], identifiers.trinom[1], identifiers.trinom[2]);
     const commands = [
         `f(x) = ${trinom.toMathString()}`,
         `SetColor(f, "${blueMain}")`,
@@ -17,16 +24,20 @@ const getConvexityTrinomialsGeoQuestion = () => {
         commands,
         lockedAxesRatio: false,
     });
-    const isConvex = trinom.a > 0 ? "Convexe" : "Concave";
+    return ggb.getOptions({
+        coords: trinom.getCoords(),
+    });
+};
+const getConvexityTrinomialsGeoQuestion = () => {
+    const trinom = TrinomConstructor.random();
+    const identifiers = { trinom: [trinom.a, trinom.b, trinom.c] };
     const question = {
-        answer: isConvex,
-        instruction,
-        ggbOptions: ggb.getOptions({
-            coords: trinom.getCoords(),
-        }),
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         keys: [],
         answerFormat: "raw",
-        identifiers: { trinom: [trinom.a, trinom.b, trinom.c] },
+        identifiers,
     };
     return question;
 };
@@ -57,4 +68,7 @@ export const convexityTrinomialsGeo = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
 };

package/lib/index.d.ts

@@ -163,6 +163,8 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     xValues: number[];
     yValues: number[];
+}, {}> | Exercise<{
+    lengths: number[];
 }, {}> | Exercise<{
     precisionAsked: number;
     decimal: number;
@@ -539,6 +541,7 @@ declare const mathExercises: (Exercise<{
     coefficients: number[];
 }, {}> | Exercise<{
     a: number;
+    c: number;
     coin: number;
     racine1: number;
     racine2: number;
@@ -592,6 +595,7 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     A: number[];
     B: number[];
+    coeffs: number[];
 }, {}> | Exercise<{
     xA: number;
     yA: number;
@@ -1886,6 +1890,7 @@ declare const pcExercises: (Exercise<{
 }, {}> | Exercise<{
     A: number[];
     B: number[];
+    coeffs: number[];
 }, {}> | Exercise<{
     a: number;
 }, {}> | Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/latexTester.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,UAAW,MAAM,2CAkJxC,CAAC"}
+{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,UAAW,MAAM,2CAsJxC,CAAC"}

package/lib/latexTester.js

@@ -5,11 +5,12 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
     let leftRightCount = 0;
     let inArray = false;
     let inPython = false;
-    for (let i = 0; i < latex.length; i++) {
-        const prevChar = latex[i - 1];
-        const char = latex[i];
-        const nextChar = latex[i + 1];
-        const nextNextChar = latex[i + 2];
+    const formated = latex.replace(/<svg[\s\S]*?<\/svg>/g, "");
+    for (let i = 0; i < formated.length; i++) {
+        const prevChar = formated[i - 1];
+        const char = formated[i];
+        const nextChar = formated[i + 1];
+        const nextNextChar = formated[i + 2];
         if (char === "$") {
             if (isDefaultInMathMode)
                 throw new Error("Dollar in default math mode");
@@ -63,13 +64,13 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
             if (char === "}" && prevChar !== "\\" && !inPython) {
                 commandModeCount--;
             }
-            const substring = latex.substring(i);
+            const substring = formated.substring(i);
             if ((inDollarMode || inDoubleDollarMode) && char === "\n") {
                 let isEmptyLine = true;
-                for (let j = i + 1; j < latex.length; j++) {
-                    if (latex[j] === "\n")
+                for (let j = i + 1; j < formated.length; j++) {
+                    if (formated[j] === "\n")
                         break;
-                    if (latex[j] !== " " && latex[j] !== "\t") {
+                    if (formated[j] !== " " && formated[j] !== "\t") {
                         isEmptyLine = false;
                         break;
                     }

package/lib/math/polynomials/polynomial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAcpE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAa5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IActD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAoBxB,MAAM,CAAC,4BAA4B,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAqBxB,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,UAAU,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY;CAmCzB;AAED,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY;IAa1D,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAM9B,QAAQ,IAAI,MAAM,EAAE;IAkCpB,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,UAAU;IAyBvC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAQ7B,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAuBnC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU;IAqBnC,QAAQ,IAAI,UAAU;IAOtB,QAAQ,IAAI,UAAU;IAWtB,cAAc,IAAI,UAAU;IAiB5B,eAAe,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BlC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM;IAiB7C,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU;IAiBxC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAuCzB,KAAK,IAAI,MAAM;IA0Bf,YAAY,IAAI,MAAM;CAGvB"}
+{"version":3,"file":"polynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAcpE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAa5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IActD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAoBxB,MAAM,CAAC,4BAA4B,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAqBxB,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,UAAU,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY;CAmCzB;AAED,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY;IAa1D,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAM9B,QAAQ,IAAI,MAAM,EAAE;IAmCpB,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,UAAU;IAyBvC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAQ7B,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAuBnC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU;IAqBnC,QAAQ,IAAI,UAAU;IAOtB,QAAQ,IAAI,UAAU;IAWtB,cAAc,IAAI,UAAU;IAiB5B,eAAe,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BlC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM;IAiB7C,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU;IAiBxC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAuCzB,KAAK,IAAI,MAAM;IA0Bf,YAAY,IAAI,MAAM;CAGvB"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.16",
+  "version": "3.0.18",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [