math-exercises 3.0.164 → 3.0.165

package/lib/exercises/math/functions/trinoms/sign/trinomSignTableFromAlgebraicForm.js

@@ -0,0 +1,209 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getAnswerTable = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const sign = a > 0 ? "+" : "-";
+    if (!roots.length) {
+        return [
+            ["$x$", "-\\infty", "\\ ", "+\\infty"],
+            ["$f(x)$", "\\ ", sign, "\\ "],
+        ];
+    }
+    if (roots.length === 1) {
+        const sign = a > 0 ? "+" : "-";
+        return [
+            ["$x$", "-\\infty", "\\ ", roots[0].toTex(), "\\ ", "+\\infty"],
+            ["$f(x)$", "\\ ", sign, "0", sign, "\\ "],
+        ];
+    }
+    const opp = a > 0 ? "-" : "+";
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            roots[0].toTex(),
+            "\\ ",
+            roots[1].toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        ["$f(x)$", "\\ ", sign, "0", opp, "0", sign, "\\ "],
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c, form } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const eq = form === "dev"
+        ? trinom.toTree()
+        : form === "cano"
+            ? trinom.getCanonicalForm()
+            : trinom.toFactorized();
+    return `Soit $f$ la fonction polynôme du second degré définie sur $\\mathbb{R}$ par : 
+
+$$
+f(x)=${eq.toTex()}
+$$
+
+Dresser le tableau de signes de $f$.
+`;
+};
+const getHint = () => {
+    return `Un trinôme est du signe de son coefficient $a$, sauf entre ses éventuelles racines. 
+  
+Il faut donc commencer par déterminer les solutions de l'équation $f(x) = 0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c, form } = identifiers;
+    const aSign = a > 0 ? "positive" : "négative";
+    const aInvSign = a > 0 ? "négative" : "positive";
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    let rootsTex = ``;
+    if (form === "dev") {
+        const delta = trinom.getDeltaNode();
+        rootsTex = `On calcule le discriminant : 
+     
+$$
+\\Delta = b^2 - 4ac= ${delta.toTex()}
+$$
+
+Puisque $\\Delta>0$, $f$ possède deux racines : 
+
+$$
+x_1 = \\frac{-b-\\sqrt{\\Delta}}{2a} = ${frac(substract(opposite(b), sqrt(delta)), multiply(2, a))
+            .simplify()
+            .toTex()}
+$$
+
+$$
+x_2 = \\frac{-b+\\sqrt{\\Delta}}{2a} = ${frac(add(opposite(b), sqrt(delta)), multiply(2, a))
+            .simplify()
+            .toTex()}
+$$`;
+    }
+    else if (form === "cano") {
+        const alpha = trinom.getAlphaNode();
+        const beta = trinom.getBetaNode();
+        const cano = trinom.getCanonicalForm();
+        rootsTex = `On a : 
+
+$$
+${cano.toTex()}=0 \\iff ${square(substract("x", alpha).simplify()).toTex()} = ${frac(opposite(beta), a).simplify().toTex()} 
+$$
+
+Cela donne deux équations à résoudre : 
+
+$$
+${substract("x", alpha).simplify().toTex()} = ${sqrt(frac(opposite(beta), a).simplify()).toTex()}
+$$
+
+d'où $x = ${substract(sqrt(frac(opposite(beta), a)), alpha)
+            .simplify()
+            .toTex()}$, et :
+
+$$
+${substract("x", alpha).simplify().toTex()} = ${opposite(sqrt(frac(opposite(beta), a).simplify())).toTex()}
+$$
+
+d'où $x = ${substract(opposite(sqrt(frac(opposite(beta), a))), alpha)
+            .simplify()
+            .toTex()}$.
+
+`;
+    }
+    else {
+        rootsTex = `Puisque $f$ est donnée sous forme factorisée, on peut facilement déterminer ses racines : ce sont $${roots[0].toTex()}$ et $${roots[1].toTex()}$.`;
+    }
+    return `Un trinôme est du signe de son coefficient $a$, sauf entre ses éventuelles racines. Ici, $f$ est donc ${aSign} sauf entre ses racines (si elle en a) où elle est ${aInvSign}.
+  
+On commence donc par déterminer les racines de $f$. 
+  
+${rootsTex}
+
+On en conclut donc que $f$ est ${aSign} sur $\\left]-\\infty; ${roots[0].toTex()}\\right]$ et sur $\\left[${roots[1].toTex()}; +\\infty\\right[$, et ${aInvSign} sur $\\left[${roots[0].toTex()}; ${roots[1].toTex()}\\right]$.
+`;
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return ans.every((row, i) => row.every((cell, j) => cell === answerTable[i][j]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTrinomSignTableFromAlgebraicFormQuestion = (opts) => {
+    const form = opts?.givenForm === "Forme canonique"
+        ? "cano"
+        : opts?.givenForm === "Forme factorisée"
+            ? "facto"
+            : "dev";
+    let trinom;
+    if (form === "cano") {
+        trinom = TrinomConstructor.randomNiceRootsAndSummit(2);
+    }
+    else {
+        trinom = TrinomConstructor.randomNiceRoots(2);
+    }
+    const identifiers = {
+        form,
+        a: trinom.a,
+        b: trinom.b,
+        c: trinom.c,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getKeys = () => {
+    return ["infty"];
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answerTable: getAnswerTable(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        answerFormat: "tex",
+        keys: getKeys(identifiers),
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        initTable: [
+            ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+            ["$f(x)$", "\\ ", "", "", "", "", "", "\\ "],
+        ],
+    };
+};
+const options = [
+    {
+        id: "givenForm",
+        label: "Forme donnée",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Forme développée", "Forme factorisée", "Forme canonique"],
+        defaultValue: "Forme développée",
+    },
+];
+export const trinomSignTableFromAlgebraicForm = {
+    id: "trinomSignTableFromAlgebraicForm",
+    label: "Dresser le tableau de signes d'un trinôme donné sous forme algébrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrinomSignTableFromAlgebraicFormQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "signTable",
+    options,
+    isAnswerTableValid,
+    getKeys,
+};

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;
@@ -1408,6 +1424,17 @@ declare const mathExercises: (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[];
@@ -3108,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: {

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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"}