math-exercises 3.0.168 → 3.0.169

package/lib/exercises/math/functions/trinoms/equation/trinomSelectEquationWithoutDeltaNeeded.js

@@ -141,7 +141,7 @@ const getTrinomSelectEquationWithoutDeltaNeededQuestion = () => {
         else {
             const trinom = TrinomConstructor.randomCanonical(undefined, {
                 excludes: [0],
-            });
+            }); //prevents x^2 + b which looks like devform
             return {
                 a: trinom.a,
                 b: trinom.b,

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.d.ts

@@ -3,6 +3,9 @@ type Identifiers = {
     isAri: boolean;
     sequence: number[];
 };
-export declare const recognizeArithmeticFromGraph: Exercise<Identifiers>;
+type Options = {
+    firstTermRankOne?: boolean;
+};
+export declare const recognizeArithmeticFromGraph: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=recognizeArithmeticFromGraph.d.ts.map

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeArithmeticFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA6GF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}
+{"version":3,"file":"recognizeArithmeticFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA2IF,KAAK,OAAO,GAAG;IACb,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AASF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBvE,CAAC"}

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.js

@@ -1,8 +1,9 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { Point } from "../../../../math/geometry/point.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 const getInstruction = () => {
@@ -12,9 +13,10 @@ const getAnswer = (identifiers) => {
     const { isAri } = identifiers;
     return isAri ? "Oui" : "Non";
 };
-const getGGBOptions = (identifiers) => {
+const getGGBOptions = (identifiers, opts) => {
     const { sequence } = identifiers;
-    const commands = sequence.flatMap((nb, index) => new Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand({
+    const rankOne = opts?.firstTermRankOne ? 1 : 0;
+    const commands = sequence.flatMap((nb, index) => new Point(`A_{${index + rankOne}}`, (index + rankOne).toTree(), nb.toTree()).toGGBCommand({
         showLabel: false,
     }));
     const ggb = new GeogebraConstructor({
@@ -28,25 +30,39 @@ const getGGBOptions = (identifiers) => {
         coords: [-1, 7, Math.min(-1, yMin - 2), Math.max(1, yMax + 2)],
     });
 };
-// const getHint: GetHint<Identifiers> = () => {
-//   return `Une suite est arithmétique si, pour passer d'un terme au suivant, on ajoute toujours le même nombre (appelé la raison de la suite).
-// Sur le graphique, les points `;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   return ``;
-// };
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
+const getHint = () => {
+    return `Une suite est arithmétique si, pour passer d'un terme au suivant, on ajoute toujours le même nombre (appelé la raison de la suite).
+
+Sur le graphique, retrouve-t-on ce comportement ?`;
+};
+const getCorrection = (identifiers, opts) => {
+    const rankOne = opts?.firstTermRankOne ? 1 : 0;
+    const { isAri, sequence } = identifiers;
+    const reason = round(sequence[1] - sequence[0], 5);
+    return `On peut lire graphiquement les premiers termes de la suite : 
+  
+${sequence
+        .slice(0, 5)
+        .map((e, i) => `$$
+u_{${i + rankOne}} = ${e.frenchify()}
+$$`)
+        .join("\n \n")}
+  
+${isAri
+        ? `Sur ces premiers termes, on ajoute donc $${reason.frenchify()}$ pour passer d'un terme à l'autre. La suite semble donc bien arithmétique.`
+        : "Puisqu'on n'ajoute pas toujours le même nombre pour passer d'un terme à l'autre, la suite n'est donc pas arithmétique."}`;
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: [],
-        ggbOptions: getGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers, opts),
         answerFormat: "raw",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers, opts),
     };
-    return question;
 };
 const getRandomFirstNonAriTerms = () => {
     const type = randint(0, 3);
@@ -77,7 +93,7 @@ const getRandomFirstNonAriTerms = () => {
         }
     }
 };
-const getRecognizeArithmeticFromGraphQuestion = () => {
+const getRecognizeArithmeticFromGraphQuestion = (opts) => {
     const isAri = coinFlip();
     const firstAriTerm = randint(-5, 10);
     const reason = randint(-4, 6, [0]);
@@ -85,7 +101,7 @@ const getRecognizeArithmeticFromGraphQuestion = () => {
         ? new Array(10).fill(0).map((_el, index) => firstAriTerm + reason * index)
         : getRandomFirstNonAriTerms();
     const identifiers = { sequence, isAri };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -94,11 +110,19 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "Non", "raw");
     return shuffleProps(propositions, n);
 };
+const options = [
+    {
+        id: "firstTermRankOne",
+        label: "Utiliser $u_1$ comme premier terme",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+    },
+];
 export const recognizeArithmeticFromGraph = {
     id: "recognizeArithmeticFromGraph",
     label: "Reconnaître graphiquement si une suite est arithmétique",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getRecognizeArithmeticFromGraphQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getRecognizeArithmeticFromGraphQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -106,5 +130,6 @@ export const recognizeArithmeticFromGraph = {
     hasGeogebra: true,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
-    // hasHintAndCorrection: true,
+    hasHintAndCorrection: true,
+    options,
 };

package/lib/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.d.ts

@@ -3,6 +3,9 @@ type Identifiers = {
     reason: number;
     sequence: number[];
 };
-export declare const recognizeReasonFromGraph: Exercise<Identifiers>;
+type Options = {
+    firstTermRankOne?: boolean;
+};
+export declare const recognizeReasonFromGraph: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=recognizeReasonFromGraph.d.ts.map

package/lib/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeReasonFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAqEF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"recognizeReasonFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA2GF,KAAK,OAAO,GAAG;IACb,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAUF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAenE,CAAC"}

package/lib/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.js

@@ -1,5 +1,6 @@
-import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { Point } from "../../../../math/geometry/point.js";
 import { randint } from "../../../../math/utils/random/randint.js";
@@ -11,11 +12,12 @@ const getAnswer = (identifiers) => {
     const answer = reason + "";
     return answer;
 };
-const getGGBOptions = (identifiers) => {
+const getGGBOptions = (identifiers, opts) => {
     const { sequence } = identifiers;
+    const rankOne = opts?.firstTermRankOne ? 1 : 0;
     const yMin = Math.min(...sequence.slice(0, 5));
     const yMax = Math.max(...sequence.slice(0, 5));
-    const commands = sequence.flatMap((nb, index) => new Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand({
+    const commands = sequence.flatMap((nb, index) => new Point(`A_{${index + rankOne}}`, (index + rankOne).toTree(), nb.toTree()).toGGBCommand({
         showLabel: false,
     }));
     const ggb = new GeogebraConstructor({
@@ -27,25 +29,47 @@ const getGGBOptions = (identifiers) => {
         coords: [-1, 7, Math.min(-1, yMin - 2), Math.max(1, yMax + 2)],
     });
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getHint = () => {
+    return `Une suite est arithmétique si, pour passer d'un terme au suivant, on ajoute toujours le même nombre (appelé la raison de la suite).
+  
+Lit graphiquement les premiers termes de la suite pour déterminer ce nombre.`;
+};
+const getCorrection = (identifiers, opts) => {
+    const rankOne = opts?.firstTermRankOne ? 1 : 0;
+    const { sequence, reason } = identifiers;
+    return `On peut lire graphiquement les premiers termes de la suite : 
+  
+${sequence
+        .slice(0, 5)
+        .map((e, i) => `$$
+u_{${i + rankOne}} = ${e.frenchify()}
+$$`)
+        .join("\n \n")}
+
+Pour passer d'un terme à l'autre, on ajoute donc toujours $${reason.frenchify()}$ : c'est la raison de la suite $u$.
+`;
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: [],
-        ggbOptions: getGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers, opts),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
-const getRecognizeReasonFromGraphQuestion = () => {
+const getRecognizeReasonFromGraphQuestion = (opts) => {
     const firstTerm = randint(1, 20);
     const reason = randint(-5, 6, [0]);
     const sequence = new Array(10)
         .fill(0)
         .map((_el, index) => firstTerm + index * reason);
     const identifiers = { reason, sequence };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -56,13 +80,21 @@ const getPropositions = (n, { answer }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return numberVEA(ans, answer);
 };
+const options = [
+    {
+        id: "firstTermRankOne",
+        label: "Utiliser $u_1$ comme premier terme",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+    },
+];
 export const recognizeReasonFromGraph = {
     id: "recognizeReasonFromGraph",
     label: "Reconnaître graphiquement la raison d'une suite arithmétique",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getRecognizeReasonFromGraphQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getRecognizeReasonFromGraphQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -70,4 +102,6 @@ export const recognizeReasonFromGraph = {
     hasGeogebra: true,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    options,
+    hasHintAndCorrection: true,
 };

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

@@ -7,4 +7,5 @@ export * from "./sequenceEvaluation.js";
 export * from "./sequencePlot.js";
 export * from "./graph/index.js";
 export * from "./notation/index.js";
+export * from "./variations/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,uBAAuB,CAAC"}

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

@@ -8,3 +8,4 @@ export * from "./sequencePlot.js";
 export * from "./graph/index.js";
 export * from "./notation/index.js";
 // export * from "./limits/index.js";
+export * from "./variations/index.js";

package/lib/exercises/math/sequences/variations/expressConsecutiveTermsDifference.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    formulaIds: NodeIdentifiers;
+};
+type Options = {
+    sequenceTypes: string[];
+};
+export declare const expressConsecutiveTermsDifference: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=expressConsecutiveTermsDifference.d.ts.map

package/lib/exercises/math/sequences/variations/expressConsecutiveTermsDifference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressConsecutiveTermsDifference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/variations/expressConsecutiveTermsDifference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAWF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwB1E,CAAC"}

package/lib/exercises/math/sequences/variations/expressConsecutiveTermsDifference.js

@@ -0,0 +1,160 @@
+import { addValidProp, shuffleProps, propWhile, GeneratorOptionTarget, GeneratorOptionType, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, formulaIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const formula = reifyAlgebraic(formulaIds);
+    const un1 = formula.toDetailedEvaluation({ n: add("n", 1) });
+    tryToAddWrongProp(propositions, un1.simplify({ towardsDistribute: true, forbidFactorize: true }).toTex());
+    tryToAddWrongProp(propositions, add(un1, formula)
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, coinFlip()
+            ? AffineConstructor.random(undefined, undefined, "n").toTree().toTex()
+            : TrinomConstructor.random(undefined, undefined, undefined, "n")
+                .toTree()
+                .toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { formulaIds } = identifiers;
+    const formula = reifyAlgebraic(formulaIds);
+    const un1 = formula.toDetailedEvaluation({ n: add("n", 1) });
+    return substract(un1, formula)
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { formulaIds } = identifiers;
+    const formula = reifyAlgebraic(formulaIds);
+    return `On considère la suite $u$ définie sur $\\mathbb{N}$ par : 
+  
+$$
+u_n = ${formula.toTex()}
+$$
+
+Pour $n\\geq 0$, exprimer en fonction de $n$ la différence : 
+
+$$
+u_{n+1}-u_n
+$$`;
+};
+const getHint = () => {
+    return `Calcule en fonction de $n$ le terme $u_{n+1}$, en remplaçant $n$ par $n+1$ dans la formule donnée.
+  
+Puis, soustrait $u_n$ et simplifie.`;
+};
+const getCorrection = (identifiers) => {
+    const { formulaIds } = identifiers;
+    const formula = reifyAlgebraic(formulaIds);
+    const un1 = formula.toDetailedEvaluation({ n: add("n", 1) });
+    const un1Simp = un1.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    return `On exprime d'abord $u_{n+1}$ : 
+  
+${alignTex([
+        ["u_{n+1}", "=", un1.toTex()],
+        ["", "=", un1Simp.toTex()],
+    ])}
+
+On a donc : 
+
+${alignTex([
+        ["u_{n+1}-u_n", "=", substract(un1Simp, formula).toTex()],
+        [
+            "",
+            "=",
+            substract(un1Simp, formula)
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex(),
+        ],
+    ])}`;
+};
+const getKeys = () => {
+    return ["n"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getExpressConsecutiveTermsDifferenceQuestion = (opts) => {
+    const type = opts?.sequenceTypes
+        ? random(opts?.sequenceTypes)
+        : random(["Premier degré", "Second degré"]);
+    const formula = type === "Premier degré"
+        ? AffineConstructor.random(undefined, undefined, "n")
+        : TrinomConstructor.random(undefined, undefined, undefined, "n");
+    const identifiers = {
+        formulaIds: formula.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const options = [
+    {
+        id: "sequenceTypes",
+        label: "Type de fonctions",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Premier degré", "Second degré"],
+        defaultValue: ["Premier degré", "Second degré"],
+    },
+];
+export const expressConsecutiveTermsDifference = {
+    id: "expressConsecutiveTermsDifference",
+    connector: "=",
+    label: "Exprimer la différence de deux termes consécutifs $u_{n+1}-u_n$ pour une suite donnée explicitement",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpressConsecutiveTermsDifferenceQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    options,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/variations/index.d.ts

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

package/lib/exercises/math/sequences/variations/index.d.ts.map

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

package/lib/exercises/math/sequences/variations/index.js

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

package/lib/exercises/math/trigonometry/circle/findAngleFromCosAndSin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findAngleFromCosAndSin.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/findAngleFromCosAndSin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}
+{"version":3,"file":"findAngleFromCosAndSin.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/findAngleFromCosAndSin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

package/lib/exercises/math/trigonometry/circle/findAngleFromCosAndSin.js

@@ -11,7 +11,6 @@ const getPropositions = (n, { answer }) => {
     propWhile(propositions, n, () => {
         tryToAddWrongProp(propositions, random(mainTrigoValues).angle.toTex());
     });
-    throw Error("correction not over");
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {

package/lib/exercises/math/trigonometry/circle/findAssociateAnglePointOnTrigoCircle.d.ts

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

package/lib/exercises/math/trigonometry/circle/findAssociateAnglePointOnTrigoCircle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findAssociateAnglePointOnTrigoCircle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/findAssociateAnglePointOnTrigoCircle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAuKF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAqBtE,CAAC"}

package/lib/exercises/math/trigonometry/circle/findAssociateAnglePointOnTrigoCircle.js

@@ -0,0 +1,158 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const points = [
+    "I",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "J",
+    "F",
+    "G",
+    "H",
+    "K",
+    "L",
+    "M",
+    "N",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+];
+const getPropositions = (n, { answer, startPoint }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, getAnswer({
+        associateType: 0,
+        startPoint,
+    }));
+    tryToAddWrongProp(propositions, getAnswer({
+        associateType: 1,
+        startPoint,
+    }));
+    tryToAddWrongProp(propositions, getAnswer({
+        associateType: 2,
+        startPoint,
+    }));
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, random(points));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    //pi+a :index +12
+    //-a : length - index
+    const { associateType, startPoint } = identifiers;
+    const startIndex = points.indexOf(startPoint);
+    switch (associateType) {
+        case 0:
+            return points[points.length - startIndex];
+        case 1:
+            return points[(startIndex + 12) % points.length];
+        case 2:
+        default:
+            if (startIndex <= 12)
+                return points[12 - startIndex];
+            else
+                return points[12 + (points.length - startIndex)];
+    }
+};
+const getAssociateAngle = (identifiers) => {
+    const { associateType } = identifiers;
+    switch (associateType) {
+        case 0:
+            return opposite("a");
+        case 1:
+            return add(PiNode, "a");
+        case 2:
+        default:
+            return substract(PiNode, "a");
+    }
+};
+const getInstruction = (identifiers) => {
+    const { startPoint } = identifiers;
+    return `On considère un réel $a$, dont le point-image est $${startPoint}$ sur le cercle trigonométrique ci-dessous.
+    
+Quel est le point-image de $${getAssociateAngle(identifiers).toTex()}$ ?
+
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/piCircleBy12.png)`;
+};
+const getHint = (identifiers) => {
+    const { associateType } = identifiers;
+    switch (associateType) {
+        case 0:
+            return `Sur le cercle trigonométrique, le point image de $-a$ est le symétrique du point image de $a$ par rapport à l'axe des abscisses.`;
+        case 1:
+            return `Sur le cercle trigonométrique, le point image de $\\pi+a$ est le symétrique du point image de $a$ par rapport à l'origine du repère.`;
+        case 2:
+        default:
+            return `Sur le cercle trigonométrique, le point image de $\\pi-a$ est le symétrique du point image de $a$ par rapport à l'axe des ordonnées.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { associateType } = identifiers;
+    switch (associateType) {
+        case 0:
+            return `Sur le cercle trigonométrique, le point image de $-a$ est le symétrique du point image de $a$ par rapport à l'axe des abscisses.
+      
+Le point-image associé à l'angle $${getAssociateAngle(identifiers).toTex()}$ est donc $${getAnswer(identifiers)}$.`;
+        case 1:
+            return `Sur le cercle trigonométrique, le point image de $\\pi+a$ est le symétrique du point image de $a$ par rapport à l'origine du repère.
+      
+Le point-image associé à l'angle $${getAssociateAngle(identifiers).toTex()}$ est donc $${getAnswer(identifiers)}$.`;
+        case 2:
+        default:
+            return `Sur le cercle trigonométrique, le point image de $\\pi-a$ est le symétrique du point image de $a$ par rapport à l'axe des ordonnées.
+
+Le point-image associé à l'angle $${getAssociateAngle(identifiers).toTex()}$ est donc $${getAnswer(identifiers)}$.`;
+    }
+};
+const getFindAssociateAnglePointOnTrigoCircleQuestion = () => {
+    const startPoint = doWhile(() => random(points), (p) => ["I", "J", "M", "T"].includes(p));
+    const identifiers = {
+        associateType: randint(0, 3),
+        startPoint,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const findAssociateAnglePointOnTrigoCircle = {
+    id: "findAssociateAnglePointOnTrigoCircle",
+    label: "Repérer le point-image d'un angle associé à un autre sur le cercle trigonométriqueérer ",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindAssociateAnglePointOnTrigoCircleQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/trigonometry/circle/index.d.ts

@@ -4,4 +4,6 @@ export * from "./mainRemarkableValues.js";
 export * from "./remarkableValues.js";
 export * from "./areReelsOnTheSameTrigoCirclePoint.js";
 export * from "./associateReelToTrigoCirclePoint.js";
+export * from "./placeAssociateAngleOnCircle.js";
+export * from "./findAssociateAnglePointOnTrigoCircle.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/trigonometry/circle/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wCAAwC,CAAC;AACvD,cAAc,sCAAsC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wCAAwC,CAAC;AACvD,cAAc,sCAAsC,CAAC;AAErD,cAAc,kCAAkC,CAAC;AACjD,cAAc,2CAA2C,CAAC"}

package/lib/exercises/math/trigonometry/circle/index.js

@@ -5,3 +5,5 @@ export * from "./remarkableValues.js";
 export * from "./areReelsOnTheSameTrigoCirclePoint.js";
 export * from "./associateReelToTrigoCirclePoint.js";
 // export * from "./findAngleFromCosAndSin.js";
+export * from "./placeAssociateAngleOnCircle.js";
+export * from "./findAssociateAnglePointOnTrigoCircle.js";

package/lib/exercises/math/trigonometry/circle/mainAngleMeasure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mainAngleMeasure.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/mainAngleMeasure.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAgGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"mainAngleMeasure.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/mainAngleMeasure.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAkGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

package/lib/exercises/math/trigonometry/circle/mainAngleMeasure.js

@@ -1,4 +1,7 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp,
+// GetCorrection,
+// GetHint,
+ } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { mainTrigoValues, } from "../../../../math/trigonometry/remarkableValues.js";
 import { randint } from "../../../../math/utils/random/randint.js";
@@ -43,9 +46,10 @@ $$
 };
 // const getHint: GetHint<Identifiers> = (identifiers) => {
 //   const angle = NodeConstructor.fromIdentifiers(identifiers.nodeIds);
-//   return `La mesure principale d'un angle en radian est sa valeur appartenant à l'intervalle $]-\\pi; \\pi]$. Il faut donc ajouter (ou retirer) $2\\pi$ à $${angle.toTex()}$ jusqu'à ce que le résultat soit dans cet intervalle.`;
+//   return `La mesure principale d'un angle en radian est sa valeur appartenant à l'intervalle $]-\\pi; \\pi]$.
+// Il faut donc ajouter (ou retirer) $2\\pi$ à $${angle.toTex()}$ jusqu'à ce que le résultat soit dans cet intervalle.`;
 // };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+// const getCorrection: GetCorrection<Identifiers> = () => {
 //   return `a`;
 // };
 const getKeys = () => {
@@ -97,4 +101,5 @@ export const mainAngleMeasure = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    // hasHintAndCorrection: true,
 };

package/lib/exercises/math/trigonometry/circle/placeAssociateAngleOnCircle.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    degree: number;
+    associateType: number;
+};
+export declare const placeAssociateAngleOnCircle: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=placeAssociateAngleOnCircle.d.ts.map

package/lib/exercises/math/trigonometry/circle/placeAssociateAngleOnCircle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeAssociateAngleOnCircle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/placeAssociateAngleOnCircle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AA4LF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAqB7D,CAAC"}

package/lib/exercises/math/trigonometry/circle/placeAssociateAngleOnCircle.js

@@ -0,0 +1,167 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { pinkDark } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getAssociateAngle = (identifiers) => {
+    const { associateType } = identifiers;
+    switch (associateType) {
+        case 0:
+            return opposite("a");
+        case 1:
+            return add(PiNode, "a");
+        case 2:
+        default:
+            return substract(PiNode, "a");
+    }
+};
+const getInstruction = (identifiers) => {
+    return `On considère un réel $a$, dont le point-image est $A$ sur le cercle trigonométrique ci-dessous.
+    
+Avec les outils disponibles, construire sur la figure le point-image du réel $${getAssociateAngle(identifiers).toTex()}$.
+  `;
+};
+const getHint = (identifiers) => {
+    const { associateType } = identifiers;
+    switch (associateType) {
+        case 0:
+            return `Sur le cercle trigonométrique, le point image de $-a$ est le symétrique du point image de $a$ par rapport à l'axe des abscisses.`;
+        case 1:
+            return `Sur le cercle trigonométrique, le point image de $\\pi+a$ est le symétrique du point image de $a$ par rapport à l'origine du repère.`;
+        case 2:
+        default:
+            return `Sur le cercle trigonométrique, le point image de $\\pi-a$ est le symétrique du point image de $a$ par rapport à l'axe des ordonnées.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { associateType } = identifiers;
+    switch (associateType) {
+        case 0:
+            return `Sur le cercle trigonométrique, le point image de $-a$ est le symétrique du point image de $a$ par rapport à l'axe des abscisses.
+      
+On utilise donc l'outil "Symétrie linéaire", on sélectionne le point $A$ puis l'axe des abscisses. Cela nous donne le point $A'$, associé à l'angle $${getAssociateAngle(identifiers).toTex()}$.`;
+        case 1:
+            return `Sur le cercle trigonométrique, le point image de $\\pi+a$ est le symétrique du point image de $a$ par rapport à l'origine du repère.
+      
+On utilise donc l'outil "Symétrie centrale", on sélectionne le point $A$ puis l'origine du repère. Cela nous donne le point $A'$, associé à l'angle $${getAssociateAngle(identifiers).toTex()}$.`;
+        case 2:
+        default:
+            return `Sur le cercle trigonométrique, le point image de $\\pi-a$ est le symétrique du point image de $a$ par rapport à l'axe des ordonnées.
+
+On utilise donc l'outil "Symétrie linéaire", on sélectionne le point $A$ puis l'axe des ordonnées. Cela nous donne le point $A'$, associé à l'angle $${getAssociateAngle(identifiers).toTex()}$.      `;
+    }
+};
+const getAnswerPoint = (identifiers) => {
+    const { associateType, degree } = identifiers;
+    switch (associateType) {
+        case 0:
+            return new Point("A'", Math.cos((-degree * Math.PI) / 180), Math.sin((-degree * Math.PI) / 180));
+        case 1:
+            return new Point("A'", Math.cos(((180 + degree) * Math.PI) / 180), Math.sin(((180 + degree) * Math.PI) / 180));
+        case 2:
+        default:
+            return new Point("A'", Math.cos(((180 - degree) * Math.PI) / 180), Math.sin(((180 - degree) * Math.PI) / 180));
+    }
+};
+const getGGBAnswer = (identifiers) => {
+    const point = getAnswerPoint(identifiers);
+    return [
+        ...point.toGGBCommand({
+            showLabel: true,
+        }),
+        `S = Segment(A, A')`,
+        `SetFixed(S, true, false)`,
+        `SetColor(S, "${pinkDark}")`,
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { degree } = identifiers;
+    const point = new Point("A", Math.cos((degree * Math.PI) / 180), Math.sin((degree * Math.PI) / 180));
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `O = (0,0)`,
+            `SetFixed(O, true, true)`,
+            `C = Circle((0,0),1)`,
+            `ShowLabel(C, false)`,
+            `SetFixed(C, true, false)`,
+            // `I = (1,0)`,
+            // `SetFixed(I, true, false)`,
+            // `J = (0, 1)`,
+            // `SetFixed(J, true, false)`,
+            ...point.toGGBCommand({
+                showLabel: true,
+                isSelectionnable: true,
+            }),
+            // `Text("$\\small A$", (1.4*cos(${degree} * pi / 180), 1.4*sin(${degree} * pi / 180)), true, true, 0,0)`,
+        ],
+        customToolBar: toolBarConstructor({
+            intersect: true,
+            centralSymetric: true,
+            lineSymetric: true,
+        }),
+        hideGrid: true,
+        xAxis: {
+            hideNumbers: true,
+        },
+        yAxis: {
+            hideNumbers: true,
+        },
+    });
+    return ggb.getOptions({
+        coords: [-1.1, 1.1, -1.1, 1.1],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const points = parseGGBPoints(ans)
+        .map((p) => ggbPointToCoords(p))
+        .map((coords, i) => new Point(`K_${i}`, coords.x, coords.y));
+    const answerPoint = getAnswerPoint(identifiers);
+    console.log(points.map((e) => [e.x.toTex(), e.y.toTex()]));
+    console.log(answerPoint.x.toTex(), answerPoint.y.toTex());
+    return (points.length < 5 &&
+        points.some((point) => point.distanceTo(answerPoint) < 0.1));
+};
+const getPlaceAssociateAngleOnCircleQuestion = () => {
+    const degree = doWhile(() => randint(0, 360), (x) => Math.min(x % 90, 90 - (x % 90)) < 20);
+    const associateType = randint(0, 3);
+    const identifiers = {
+        degree,
+        associateType,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const placeAssociateAngleOnCircle = {
+    id: "placeAssociateAngleOnCircle",
+    label: "Construire le point-image d'un angle associé à un autre sur le cercle trigonométrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlaceAssociateAngleOnCircleQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts

@@ -11,5 +11,7 @@ export declare const toolBarConstructor: (options: {
     segmentFixed?: boolean;
     polygon?: boolean;
     erase?: boolean;
+    centralSymetric?: boolean;
+    lineSymetric?: boolean;
 }) => string;
 //# sourceMappingURL=toolBarConstructor.d.ts.map

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,GAAI,SAAS;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,WAgBA,CAAC"}
+{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,GAAI,SAAS;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,WAkBA,CAAC"}

package/lib/exercises/utils/geogebra/toolBarConstructor.js

@@ -24,5 +24,9 @@ export const toolBarConstructor = (options) => {
         customToolBar += "||34";
     if (options.polygon)
         customToolBar += "||16";
+    if (options.centralSymetric)
+        customToolBar += "||29";
+    if (options.lineSymetric)
+        customToolBar += "||30";
     return customToolBar;
 };

package/lib/index.d.ts

@@ -3125,10 +3125,14 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     reason: number;
     sequence: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    firstTermRankOne?: boolean;
+}> | Exercise<{
     isAri: boolean;
     sequence: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    firstTermRankOne?: boolean;
+}> | Exercise<{
     firstRank: number;
     firstValue: number;
     reason: number;
@@ -3258,6 +3262,10 @@ declare const mathExercises: (Exercise<{
     askedTerm: number;
 }, {
     firstRank: string;
+}> | Exercise<{
+    formulaIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    sequenceTypes: string[];
 }> | Exercise<{
     intervalIdentifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -3457,6 +3465,12 @@ declare const mathExercises: (Exercise<{
 }, {
     solutionInterval: string;
 }> | Exercise<{
+    degree: number;
+    associateType: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    associateType: number;
+    startPoint: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     trigFunction: string;
     trigValue: number;
     angleInDegrees: number;

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;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,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":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/polynomials/trinom.d.ts

@@ -17,7 +17,7 @@ export declare abstract class TrinomConstructor {
         min?: number;
         max?: number;
         excludes?: number[];
-    }): Trinom;
+    }, variable?: string): Trinom;
     static randomCanonical(aOpts?: {
         min?: number;
         max?: number;

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

@@ -1 +1 @@
-{"version":3,"file":"trinom.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/trinom.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"trinom.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/trinom.ts"],"names":[],"mappings":"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"}

package/lib/math/polynomials/trinom.js

@@ -16,11 +16,11 @@ import { random } from "../../utils/alea/random.js";
 import { blueMain } from "../../geogebra/colors.js";
 import { round } from "../utils/round.js";
 export class TrinomConstructor {
-    static random(aOpts, bOpts, cOpts) {
+    static random(aOpts, bOpts, cOpts, variable) {
         const a = randint(aOpts?.min ?? -9, aOpts?.max ?? 10, aOpts?.excludes ?? [0]);
         const b = randint(bOpts?.min ?? -9, bOpts?.max ?? 10, bOpts?.excludes ?? []);
         const c = randint(cOpts?.min ?? -9, cOpts?.max ?? 10, cOpts?.excludes ?? []);
-        return new Trinom(a, b, c);
+        return new Trinom(a, b, c, variable ? { variable } : undefined);
     }
     static randomCanonical(aOpts, alphaOpts, betaOpts) {
         const a = aOpts?.from

package/package.json

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