math-exercises 3.0.163 → 3.0.165

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

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
@@ -10,7 +10,7 @@ import { substract } from "../../../../../tree/nodes/operators/substractNode.js"
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
 import { alignTex } from "../../../../../utils/latex/alignTex.js";
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer }, opts) => {
     const propositions = [];
     addValidProp(propositions, answer);
     propWhile(propositions, n, () => {
@@ -23,27 +23,30 @@ const getPropositions = (n, { answer }) => {
             pointIds: point.toIdentifiers(),
             summitIds: summit.toIdentifiers(),
         };
-        tryToAddWrongProp(propositions, getAnswer(fakeIds));
+        tryToAddWrongProp(propositions, getAnswer(fakeIds, opts));
     });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers, opts) => {
     const { pointIds, summitIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
     const summit = PointConstructor.fromIdentifiers(summitIds);
     const a = frac(substract(point.y, summit.y), square(substract(point.x, summit.x))).simplify();
-    const cano = add(multiply(a, square(substract("x", summit.x))), summit.y);
-    return cano
-        .simplify({ towardsDistribute: true, forbidFactorize: true })
-        .toTex();
+    const cano = add(multiply(a, square(substract("x", summit.x).simplify())), summit.y);
+    if (opts?.expectedForm === "Forme canonique")
+        return cano;
+    return cano.simplify({ towardsDistribute: true, forbidFactorize: true });
 };
-const getInstruction = (identifiers) => {
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getInstruction = (identifiers, opts) => {
     const { pointIds, summitIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
     const summit = PointConstructor.fromIdentifiers(summitIds);
     return `On considère une fonction polynôme du second degré $f$. Sa parabole passe par le point $${point.toTexWithCoords()}$, et son sommet est $${summit.toTexWithCoords()}$. 
   
-Déterminer la forme développée de $f$.`;
+Déterminer la forme ${opts?.expectedForm === "Forme canonique" ? "canonique" : "développée"} de $f$.`;
 };
 const getHint = (identifiers) => {
     return `La forme canonique d'une fonction polynôme du second degré $f$ est : 
@@ -56,7 +59,7 @@ où $\\alpha$ est l'abscisse du sommet de la parabole, et $\\beta$ son ordonnée
 
 Utilise cette formule ici, puis le fait que le point $${PointConstructor.fromIdentifiers(identifiers.pointIds).toTexWithCoords()}$ est un point de la parabole pour déterminer $a$.`;
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, opts) => {
     const { pointIds, summitIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
     const summit = PointConstructor.fromIdentifiers(summitIds);
@@ -88,49 +91,59 @@ ${alignTex([
         ["a", "=", a.simplify().toTex()],
     ])}
 
-Il ne reste plus qu'à développer la forme canonique de $f$ :
+${opts?.expectedForm === "Forme canonique"
+        ? `La forme canonique de $f$ est donc : 
+    
+$$
+f(x) = ${getAnswer(identifiers, opts)}
+$$`
+        : `Il ne reste plus qu'à développer la forme canonique de $f$ :
 
 ${alignTex([
-        [
-            "f(x)",
-            "=",
-            add(multiply(a, square(substract("x", alpha))), beta)
-                .simplify()
-                .toTex(),
-        ],
-        [
-            "",
-            "=",
-            add(multiply(a, square(substract("x", alpha)).simplify({
-                towardsDistribute: true,
-                forbidFactorize: true,
-            })), beta).toTex(),
-        ],
-        [
-            "",
-            "=",
-            add(multiply(a, square(substract("x", alpha))), beta)
-                .simplify({ towardsDistribute: true, forbidFactorize: true })
-                .toTex(),
-        ],
-    ])}
-`;
+            [
+                "f(x)",
+                "=",
+                add(multiply(a, square(substract("x", alpha))), beta)
+                    .simplify()
+                    .toTex(),
+            ],
+            [
+                "",
+                "=",
+                add(multiply(a, square(substract("x", alpha)).simplify({
+                    towardsDistribute: true,
+                    forbidFactorize: true,
+                })), beta).toTex(),
+            ],
+            [
+                "",
+                "=",
+                add(multiply(a, square(substract("x", alpha))), beta)
+                    .simplify({ towardsDistribute: true, forbidFactorize: true })
+                    .toTex(),
+            ],
+        ])}
+`}`;
 };
 const getKeys = () => {
     return ["xsquare", "x"];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
     try {
         const parsed = parseAlgebraic(ans);
+        const ansNode = getAnswerNode(identifiers, opts);
         return (parsed
             .simplify({ towardsDistribute: true, forbidFactorize: true })
-            .toTex() === answer);
+            .toTex() ===
+            ansNode
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex());
     }
     catch (err) {
         return handleVEAError(err);
     }
 };
-const getDevFormFromSummitAndPointQuestion = () => {
+const getDevFormFromSummitAndPointQuestion = (opts) => {
     const summit = PointConstructor.random("S");
     const a = randint(-10, 10, [0]);
     const pointX = randint(-10, 10, [summit.x.evaluate()]);
@@ -140,23 +153,33 @@ const getDevFormFromSummitAndPointQuestion = () => {
         pointIds: point.toIdentifiers(),
         summitIds: summit.toIdentifiers(),
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     return {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
 };
+const options = [
+    {
+        id: "expectedForm",
+        label: "Forme attendue",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.select,
+        values: ["Forme développée", "Forme canonique"],
+        defaultValue: "Forme développée",
+    },
+];
 export const devFormFromSummitAndPoint = {
     id: "devFormFromSummitAndPoint",
     connector: "=",
-    label: "Déterminer la forme développée d'un trinôme en connaissant un point et le sommet de la parabole",
+    label: "Déterminer l'expression algébrique d'un trinôme en connaissant un point et le sommet de la parabole",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getDevFormFromSummitAndPointQuestion(opts), nb),
     qcmTimer: 60,
@@ -169,5 +192,6 @@ export const devFormFromSummitAndPoint = {
     getCorrection,
     getAnswer,
     getQuestionFromIdentifiers,
+    options,
     hasHintAndCorrection: true,
 };

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

@@ -16,3 +16,4 @@ export * from "./basicProbas/index.js";
 export * from "./probaAsSumOfProbas.js";
 export * from "./conditionalProbaWriteFromFrench.js";
 export * from "./twoStepExperiments/index.js";
+// export * from "./trees/index.js";

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

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

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

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

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

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

package/lib/exercises/math/probaStat/trees/treeInInstruction.d.ts

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

package/lib/exercises/math/probaStat/trees/treeInInstruction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeInInstruction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/treeInInstruction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;AAClC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,WAAW,CAAC;CACnB,CAAC;AAiGF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}

package/lib/exercises/math/probaStat/trees/treeInInstruction.js

@@ -0,0 +1,110 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-10, 10) + "");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = () => {
+    return "prout";
+};
+const getInstruction = (identifiers) => {
+    const { tree } = identifiers;
+    return `Bla bla bla voici un arbre de proba : 
+  
+<svg id="treeDiagram">${JSON.stringify(tree)}</svg>
+
+Comment ça va ajd ?`;
+};
+const getHint = () => {
+    return `indice`;
+};
+const getCorrection = () => {
+    return `correction`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = () => {
+    try {
+        return coinFlip();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTreeInInstructionQuestion = () => {
+    const steps = randint(2, 4);
+    const randomBlock = () => {
+        const branches = randint(2, 4);
+        const isDecimal = coinFlip();
+        const value = () => {
+            return isDecimal
+                ? randfloat(0.1, 1, 2)
+                : RationalConstructor.randomIrreductibleProba().toTree().toTex();
+        };
+        const res = [
+            [`£${value()}£`, "£A£"],
+            [`£${value()}£`, "£B£"],
+        ];
+        if (branches === 3)
+            res.push([`£${value()}£`, "£C£"]);
+        return res;
+    };
+    const firstBlock = randomBlock();
+    const firstBlockLength = firstBlock.length;
+    const tree = [[firstBlock], []];
+    for (let i = 0; i < firstBlockLength; i++) {
+        tree[1].push(randomBlock());
+    }
+    if (steps === 3) {
+        tree.push([]);
+        tree[1].forEach((block) => {
+            const length = block.length;
+            for (let i = 0; i < length; i++) {
+                tree[2].push(randomBlock());
+            }
+        });
+    }
+    const identifiers = {
+        tree,
+    };
+    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),
+    };
+};
+export const treeInInstruction = {
+    id: "treeInInstruction",
+    connector: "=",
+    label: "Test arbre in instruction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTreeInInstructionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    firstRank: number;
+    firstTerm: number;
+    reason: number;
+    form: "explicit" | "recu" | "termAndReason";
+};
+type Options = {
+    forms: string[];
+};
+export declare const arithmeticVariations: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=arithmeticVariations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticVariations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,eAAe,CAAC;CAC7C,CAAC;AA+HF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAoBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA8B/D,CAAC"}

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

@@ -0,0 +1,163 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Strictement croissante", "raw");
+    tryToAddWrongProp(propositions, "Strictement décroissante", "raw");
+    tryToAddWrongProp(propositions, "Constante", "raw");
+    tryToAddWrongProp(propositions, "Non monotone", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { reason } = identifiers;
+    return reason > 0 ? "Strictement croissante" : "Strictement décroissante";
+};
+const getInstruction = (identifiers) => {
+    const { firstRank, firstTerm, form, reason } = identifiers;
+    const def = form === "explicit"
+        ? `, pour tout $n\\geq ${firstRank}$ :
+  
+$$
+u_n = ${add(firstTerm, multiply(reason, "n"))
+            .simplify({ forbidFactorize: true })
+            .toTex()}
+$$`
+        : form === "recu"
+            ? ` :
+
+$$
+\\left\\{\\begin{matrix}
+u_{${firstRank}} = ${firstTerm} \\\\
+u_{n+1} = ${add("u_n", reason).toTex()} \\text{ pour }n\\geq ${firstRank}
+\\end{matrix}\\right.
+$$
+
+`
+            : ` son premier terme $u_{${firstRank}} = ${firstTerm}$ et sa raison $r = ${reason}$.`;
+    return `On considère une suite arithmétique $u$, définie par${def}
+  
+Quel est le sens de variation de $u$ ?
+`;
+};
+const getHint = () => {
+    return `Une suite arithmétique de raison $r$ est : 
+  
+- strictement croissante si $r>0$;
+- strictement décroissante si $r<0$;
+- constante si $r = 0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { reason, firstTerm, form } = identifiers;
+    const sign = reason > 0 ? "positive" : "négative";
+    const way = reason > 0 ? "croissante" : "décroissante";
+    if (form === "explicit") {
+        return `Puisque la formule explicite de $u$ est : 
+    
+$$
+u_n = ${add(firstTerm, multiply(reason, "n"))
+            .simplify({ forbidFactorize: true })
+            .toTex()}
+$$
+
+alors $u$ est une suite de premier terme $${firstTerm}$ et de raison $${reason}$.
+
+Puisque la raison $${reason}$ est strictement ${sign}, alors $u$ est strictement ${way}.`;
+    }
+    if (form === "recu") {
+        return `La suite $u$ est définie par une formule de récurrence : 
+    
+$$
+u_{n+1} = ${add("u_n", reason).toTex()}
+$$
+
+La raison de la suite $u$ est donc $${reason}$.
+
+Puisque la raison $${reason}$ est strictement ${sign}, alors $u$ est strictement ${way}.`;
+    }
+    return `Puisque la raison $${reason}$ de la suite $u$ est strictement ${sign}, alors $u$ est strictement ${way}.`;
+};
+const getArithmeticVariationsQuestion = (opts) => {
+    const form = opts?.forms
+        ? random(opts.forms)
+        : random([
+            "Formule explicite",
+            "Formule de récurrence",
+            "Premier terme et raison",
+        ]);
+    const firstRank = random([0, 1]);
+    const firstTerm = randint(-9, 10);
+    const reason = randint(-9, 10, [0]);
+    const identifiers = {
+        form: form === "Formule explicite"
+            ? "explicit"
+            : form === "Formule de récurrence"
+                ? "recu"
+                : "termAndReason",
+        firstRank,
+        firstTerm,
+        reason,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const options = [
+    {
+        id: "forms",
+        label: "Type de définition de la suite",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "Formule explicite",
+            "Formule de récurrence",
+            "Premier terme et raison",
+        ],
+        defaultValue: [
+            "Formule explicite",
+            "Formule de récurrence",
+            "Premier terme et raison",
+        ],
+    },
+];
+export const arithmeticVariations = {
+    id: "arithmeticVariations",
+    label: "Déterminer le sens de variation d'une suite arithmétique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticVariationsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+    options,
+    validateOptions: (opts) => {
+        return opts.forms.length > 0
+            ? {
+                message: "OK",
+                valid: true,
+            }
+            : {
+                message: "Veuillez choisir au moins un type de définition de la suite.",
+                valid: false,
+            };
+    },
+};

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

@@ -17,4 +17,5 @@ export * from "./arithmeticFindRandomTermFromTwoTerms.js";
 export * from "./arithmeticFindTerm.js";
 export * from "./arithmeticFindTermFirstRankOne.js";
 export * from "./arithmeticFindAntecedent.js";
+export * from "./arithmeticVariations.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AAEpD,cAAc,oCAAoC,CAAC;AACnD,cAAc,gDAAgD,CAAC;AAE/D,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wCAAwC,CAAC;AACvD,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mDAAmD,CAAC;AAClE,cAAc,sCAAsC,CAAC;AACrD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yBAAyB,CAAC;AACxC,cAAc,qCAAqC,CAAC;AACpD,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AAEpD,cAAc,oCAAoC,CAAC;AACnD,cAAc,gDAAgD,CAAC;AAE/D,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wCAAwC,CAAC;AACvD,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mDAAmD,CAAC;AAClE,cAAc,sCAAsC,CAAC;AACrD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yBAAyB,CAAC;AACxC,cAAc,qCAAqC,CAAC;AACpD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC"}

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

@@ -17,3 +17,4 @@ export * from "./arithmeticFindRandomTermFromTwoTerms.js";
 export * from "./arithmeticFindTerm.js";
 export * from "./arithmeticFindTermFirstRankOne.js";
 export * from "./arithmeticFindAntecedent.js";
+export * from "./arithmeticVariations.js";

package/lib/index.d.ts

@@ -1346,8 +1346,11 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
-    isDevForm: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+    isDevForm?: boolean;
+    form?: "cano" | "dev" | "facto";
+}, {
+    form: string[];
+}> | Exercise<{
     a: number;
     b: number;
     c: number;
@@ -1360,8 +1363,21 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     type: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    factoType: string[];
+}> | Exercise<{
     coeffs: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    equations: {
+        a: number;
+        b: number;
+        c: number;
+        form: "dev" | "cano" | "facto";
+    }[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    cIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     roots: number[];
     a: number;
@@ -1397,12 +1413,28 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode.js").TrinomNodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    rootsIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+}, {
+    expectedForm: string;
+}> | Exercise<{
     trinomCoeffs: number[];
     isAskingPositive: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     trinomCoeffs: number[];
     isAskingPositive: boolean;
     isStrict: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    form: "dev" | "cano" | "facto";
+}, {
+    givenForm: string;
+}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     param: string;
     coeffs: number[];
@@ -1442,7 +1474,9 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     summitIds: import("./math/geometry/point.js").PointIdentifiers;
     pointIds: import("./math/geometry/point.js").PointIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    expectedForm: string;
+}> | Exercise<{
     type: number;
     points: number[][];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -3101,6 +3135,13 @@ declare const mathExercises: (Exercise<{
     b: number;
     n: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    firstRank: number;
+    firstTerm: number;
+    reason: number;
+    form: "explicit" | "recu" | "termAndReason";
+}, {
+    forms: string[];
+}> | Exercise<{
     firstValue: number;
     reason: number;
     askedRank: 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

@@ -46,7 +46,7 @@ export declare abstract class TrinomConstructor {
         excludes?: number[];
     }): Trinom;
     static randomNiceRoots(nbOfRoots?: number): Trinom;
-    static randomNiceRootsAndSummit(): Trinom;
+    static randomNiceRootsAndSummit(nbOfRoots?: number): Trinom;
     static fromCoeffs(coeffs: number[]): Trinom;
     static fromRoots(roots: number[], a: number): Trinom;
     static fromAlphaBeta(params: {