math-exercises 3.0.134 → 3.0.135

package/lib/exercises/math/geometry/vectors/constructions/traceVectorCL.js

@@ -0,0 +1,178 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { purpleDark, red } 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, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randomMany } from "../../../../../utils/alea/random.js";
+import { doWhile } from "../../../../../utils/doWhile.js";
+const getMultiplyVectorTex = (v, a, shouldShowPlusSign) => {
+    if (a === 1)
+        return `${shouldShowPlusSign ? "+" : ""}\\overrightarrow{${v}}`;
+    if (a === -1)
+        return `-\\overrightarrow{${v}}`;
+    if (a < 0)
+        return `${a}\\overrightarrow{${v}}`;
+    return `${shouldShowPlusSign ? "+" : ""}${a}\\overrightarrow{${v}}`;
+};
+const getSolutionPoint = (identifiers) => {
+    const { a, b, firstVectorPointsIndexes, secondVectorPointsIndexes, startPointIndex, } = identifiers;
+    const points = identifiers.points.map(PointConstructor.fromIdentifiers);
+    const origin = points[startPointIndex];
+    const vecs = [
+        VectorConstructor.fromPoints(points[firstVectorPointsIndexes[0]], points[firstVectorPointsIndexes[1]]),
+        VectorConstructor.fromPoints(points[secondVectorPointsIndexes[0]], points[secondVectorPointsIndexes[1]]),
+    ];
+    return vecs[0]
+        .times(a.toTree())
+        .add(vecs[1].times(b.toTree()))
+        .getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, a, b, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = `${identifiers.points[firstVectorPointsIndexes[0]].name}${identifiers.points[firstVectorPointsIndexes[1]].name}`;
+    const secondVec = `${identifiers.points[secondVectorPointsIndexes[0]].name}${identifiers.points[secondVectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+  
+$$
+\\overrightarrow{${origin}K} = ${getMultiplyVectorTex(firstVec, a, false)} ${getMultiplyVectorTex(secondVec, b, true)}
+$$
+
+Penser à effacer les points de construction pour que la réponse soit comptée juste.`;
+};
+const getHint = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, a, b, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = `${identifiers.points[firstVectorPointsIndexes[0]].name}${identifiers.points[firstVectorPointsIndexes[1]].name}`;
+    const secondVec = `${identifiers.points[secondVectorPointsIndexes[0]].name}${identifiers.points[secondVectorPointsIndexes[1]].name}`;
+    return `À partir du point $${origin}$, trace à la suite les vecteurs $${getMultiplyVectorTex(firstVec, a, false)}$ et $${getMultiplyVectorTex(secondVec, b, false)}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, a, b, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = `${identifiers.points[firstVectorPointsIndexes[0]].name}${identifiers.points[firstVectorPointsIndexes[1]].name}`;
+    const secondVec = `${identifiers.points[secondVectorPointsIndexes[0]].name}${identifiers.points[secondVectorPointsIndexes[1]].name}`;
+    return `On se place au point $${origin}$. On trace à partir de ce point le vecteur $${getMultiplyVectorTex(firstVec, a, false)}$. Puis, à la suite, on trace le vecteur $${getMultiplyVectorTex(secondVec, b, false)}$. Le point d'arrivée est le point $K$ recherché.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, a } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = [
+        identifiers.points[firstVectorPointsIndexes[0]].name,
+        identifiers.points[firstVectorPointsIndexes[1]].name,
+    ];
+    const midPoint = `${origin}+(${a})*Vector(${firstVec[0]}, ${firstVec[1]})`;
+    const endPoint = getSolutionPoint(identifiers);
+    return [
+        ...endPoint.toGGBCommand(),
+        `a = Vector(${origin}, ${midPoint})`,
+        `SetColor(a, "${red}")`,
+        `b = Vector(${midPoint}, K)`,
+        `SetColor(b, "${purpleDark}")`,
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { firstVectorPointsIndexes, startPointIndex, a } = identifiers;
+    const commands = identifiers.points.flatMap((p) => PointConstructor.fromIdentifiers(p).toGGBCommand({ size: 4 }));
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideAxes: true,
+        fontSize: 16,
+    });
+    const points = identifiers.points.map((p) => PointConstructor.fromIdentifiers(p));
+    const firstVec = VectorConstructor.fromPoints(points[firstVectorPointsIndexes[0]], points[firstVectorPointsIndexes[1]]);
+    const origin = points[startPointIndex];
+    const midPoint = firstVec.times(a.toTree()).getEndPoint(origin);
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint, midPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C", "D"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = parseGGBPoints(studentAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceVectorSumQuestion = () => {
+    const names = ["A", "B", "C", "D"];
+    let points = [];
+    let startPointIndex;
+    let firstVectorPointsIndexes;
+    let secondVectorPointsIndexes;
+    const a = randint(-3, 4, [0]);
+    const b = randint(-3, 4, Math.abs(a) === 1 ? [0, 1, -1] : [0]);
+    let counter = 0;
+    while (true) {
+        counter++;
+        if (counter > 1000)
+            throw new Error("Too many iterations in traceVectorCL");
+        points = [];
+        points.push(...PointConstructor.randomDifferent(4, {
+            minDistance: 1,
+            names,
+            minDistanceToOrigin: 2,
+        }));
+        startPointIndex = randint(0, names.length);
+        firstVectorPointsIndexes = randomMany([0, 1, 2, 3], 2);
+        secondVectorPointsIndexes = doWhile(() => randomMany([0, 1, 2, 3], 2), (arr) => arr[0] === firstVectorPointsIndexes[0] &&
+            arr[1] === firstVectorPointsIndexes[1]);
+        //AC = AB+BC
+        const firstVec = VectorConstructor.fromPoints(points[firstVectorPointsIndexes[0]], points[firstVectorPointsIndexes[1]]);
+        const second = VectorConstructor.fromPoints(points[secondVectorPointsIndexes[0]], points[secondVectorPointsIndexes[1]]);
+        const endPoint = firstVec
+            .times(a.toTree())
+            .add(second.times(b.toTree()))
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        firstVectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        secondVectorPointsIndexes,
+        startPointIndex,
+        a,
+        b,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const traceVectorCL = {
+    id: "traceVectorCL",
+    label: "Placer un point défini par une combinaison linéaire de deux vecteurs",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceVectorSumQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/percent/evolutions/findEndValueAfterEvolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findEndValueAfterEvolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/findEndValueAfterEvolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAgGF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}
+{"version":3,"file":"findEndValueAfterEvolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/findEndValueAfterEvolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAkGF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}

package/lib/exercises/math/percent/evolutions/findEndValueAfterEvolution.js

@@ -24,7 +24,7 @@ const getAnswer = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const evolution = identifiers.percentRate < 0 ? "baisse" : "hausse";
-    return `Le prix initial d'un objet est $${identifiers.vd.frenchify()}€$. Quel sera son prix après une ${evolution} de $${identifiers.percentRate.frenchify()}\\%$ ? Arrondir au centième.`;
+    return `Le prix initial d'un objet est $${identifiers.vd.frenchify()}€$. Quel sera son prix après une ${evolution} de $${Math.abs(identifiers.percentRate).frenchify()}\\%$ ? Arrondir au centième.`;
 };
 const getHint = () => {
     return `Transforme le taux d'évolution en coefficient multiplicateur. Puis multiplie le prix initial par ce coefficient multiplicateur.`;

package/lib/exercises/math/powers/powersMixOperations.d.ts

@@ -7,6 +7,9 @@ type Identifiers = {
     m: number;
     n: number | undefined;
 };
-export declare const powersMixOperations: Exercise<Identifiers>;
+type Options = {
+    useSameInteger: boolean;
+};
+export declare const powersMixOperations: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=powersMixOperations.d.ts.map

package/lib/exercises/math/powers/powersMixOperations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powersMixOperations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersMixOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AAwKF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAerD,CAAC"}
+{"version":3,"file":"powersMixOperations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersMixOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AA4JF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AA0BF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB9D,CAAC"}

package/lib/exercises/math/powers/powersMixOperations.js

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { frac, isFractionNode, } from "../../../tree/nodes/operators/fractionNode.js";
@@ -108,10 +108,10 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
-const getPowersMixOperationsQuestion = () => {
+const getPowersMixOperationsQuestion = (opts) => {
     const finalPower = randint(2, 10);
     const a = randint(2, 10);
-    const bEqualsA = coinFlip();
+    const bEqualsA = opts?.useSameInteger || coinFlip();
     const b = bEqualsA ? a : randint(2, 10, [a]);
     let l, m, k, n;
     if (!bEqualsA) {
@@ -135,15 +135,24 @@ const getPowersMixOperationsQuestion = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const options = [
+    {
+        id: "useSameInteger",
+        label: "Utiliser des puissances du même entier",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        instruction: getInstruction(identifiers, opts),
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -159,6 +168,7 @@ export const powersMixOperations = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    options,
     getQuestionFromIdentifiers,
     shouldHaveCalculator: false,
 };

package/lib/exercises/math/probaStat/stats1var/plausibilityOfAverage.js

@@ -182,7 +182,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 export const plausibilityOfAverage = {
     id: "plausibilityOfAverage",
-    label: "S’assurer de la vraisemblance, de la cohérence d’un résultat (moyenne d'une série)",
+    label: "S'assurer de la vraisemblance, de la cohérence d'un résultat (moyenne d'une série)",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getPlausibilityOfAverageQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8HF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA+HF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormula.js

@@ -85,7 +85,8 @@ const isAnswerValid = (ans, { reason, firstValue }) => {
     const texs = equal.toAllValidTexs();
     return (texs.includes(ans) ||
         (() => {
-            let nodeAns = parseLatex(ans);
+            const refinedAns = ans.replace("u_n", "").replace("=", "");
+            let nodeAns = parseLatex(refinedAns);
             if (isEqualNode(nodeAns)) {
                 nodeAns = nodeAns.rightChild;
             }

package/lib/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.d.ts

@@ -5,6 +5,10 @@ type Identifiers = {
     reason: number;
     nbTerms: number;
 };
-export declare const geometricFirstTermsGeneralSum: Exercise<Identifiers>;
+type Options = {
+    positiveReason: boolean;
+    firstRankOne: boolean;
+};
+export declare const geometricFirstTermsGeneralSum: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=geometricFirstTermsGeneralSum.d.ts.map

package/lib/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFirstTermsGeneralSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAgHF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}
+{"version":3,"file":"geometricFirstTermsGeneralSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAkHF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAkBF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBxE,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.js

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
@@ -53,10 +53,10 @@ const getAnswer = (identifiers) => {
     const answer = (firstValue * (1 - Math.pow(reason, nbTerms))) / (1 - reason);
     return answer.frenchify();
 };
-const getGeometricFirstTermsGeneralSumQuestion = () => {
-    const firstRank = random([0, 1]);
+const getGeometricFirstTermsGeneralSumQuestion = (opts) => {
+    const firstRank = opts?.firstRankOne ? 1 : random([0, 1]);
     const firstValue = randint(-9, 10, [0]);
-    const reason = randint(-5, 5, [0, 1]);
+    const reason = opts?.positiveReason ? randint(2, 5) : randint(-5, 5, [0, 1]);
     const nbTerms = randint(4, 9);
     const identifiers = {
         firstRank,
@@ -64,7 +64,7 @@ const getGeometricFirstTermsGeneralSumQuestion = () => {
         reason,
         nbTerms,
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
@@ -93,14 +93,31 @@ const getPropositions = (n, { answer, firstValue, reason }) => {
 const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
+const options = [
+    {
+        id: "positiveReason",
+        label: "Utiliser des raisons positives",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+    {
+        id: "firstRankOne",
+        label: "Toujours utiliser $u_1$ comme premier terme",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
 export const geometricFirstTermsGeneralSum = {
     id: "geometricFirstTermsGeneralSum",
     connector: "=",
     label: "Somme des termes d'une suite géométrique (cas général)",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getGeometricFirstTermsGeneralSumQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFirstTermsGeneralSumQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
+    options,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",

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

@@ -9,7 +9,7 @@ const getInstruction = (identifiers) => {
   
 - $u_0 = ${u0}$,
 
-- pour tout $n\\geq 1$ :
+- pour tout $n\\geq 0$ :
 $$
 u_{n+1} = ${u.toTree().toTex()}
 $$

package/lib/index.d.ts

@@ -46,6 +46,9 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -330,6 +333,11 @@ declare const mathExercises: (Exercise<{
     point: import("./math/geometry/point.js").PointIdentifiers;
     bounding: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    isFractionToDigital: boolean;
+    nb: number;
+}, {
+    conversionType: string;
+}> | Exercise<{
     choices: {
         node: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
         irrationalUsed: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers | null;
@@ -388,6 +396,12 @@ declare const mathExercises: (Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isAdd: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    type: number;
+    affine1: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
+    affine2: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
+    affine3: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
+    affine4?: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     randNbr: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -825,6 +839,11 @@ declare const mathExercises: (Exercise<{
     affineB: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeUIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeVIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeUPrimeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeVPrimeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coeffs: number[];
     x: number;
@@ -1471,6 +1490,15 @@ declare const mathExercises: (Exercise<{
     k: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isFindU: boolean;
+    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    uov: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    items: {
+        tex: string;
+        isValid: boolean;
+    }[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coin: boolean;
     radius: number;
@@ -1784,6 +1812,13 @@ declare const mathExercises: (Exercise<{
     vCoords: number[];
     wCoords: number[];
     uCoords: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    points: import("./math/geometry/point.js").PointIdentifiers[];
+    startPointIndex: number;
+    firstVectorPointsIndexes: number[];
+    secondVectorPointsIndexes: number[];
+    a: number;
+    b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     points: string[][];
     pointAskedIndex: number[];
@@ -2172,7 +2207,9 @@ declare const mathExercises: (Exercise<{
     l: number;
     m: number;
     n: number | undefined;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    useSameInteger: boolean;
+}> | Exercise<{
     a: number;
     b: number;
     c: number;
@@ -2607,7 +2644,10 @@ declare const mathExercises: (Exercise<{
     firstValue: number;
     reason: number;
     nbTerms: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    positiveReason: boolean;
+    firstRankOne: boolean;
+}> | Exercise<{
     q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     a: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;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/utils/arithmetic/isCoprime.d.ts

@@ -0,0 +1,2 @@
+export declare const isCoprime: (a: number, b: number) => boolean;
+//# sourceMappingURL=isCoprime.d.ts.map

package/lib/math/utils/arithmetic/isCoprime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCoprime.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/arithmetic/isCoprime.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,YAY7C,CAAC"}

package/lib/math/utils/arithmetic/isCoprime.js

@@ -0,0 +1,10 @@
+import { primeDecomposition } from "./primeDecomposition.js";
+export const isCoprime = (a, b) => {
+    const [dictDecompA, dictDecompB] = [a, b].map((n) => {
+        const arrDecomp = primeDecomposition(n);
+        const dictDecomp = Object.fromEntries(arrDecomp.map(({ value, power }) => [value, power]));
+        return dictDecomp;
+    });
+    const isCoprime = Object.keys(dictDecompA).every((value) => dictDecompB[value] === undefined);
+    return isCoprime;
+};

package/lib/math/utils/arithmetic/primeDecompNode.d.ts

@@ -0,0 +1,3 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+export declare const primeDecompNode: (nb: number, asPowers?: boolean) => AlgebraicNode;
+//# sourceMappingURL=primeDecompNode.d.ts.map

package/lib/math/utils/arithmetic/primeDecompNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primeDecompNode.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/arithmetic/primeDecompNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,eAAO,MAAM,eAAe,GAAI,IAAI,MAAM,EAAE,WAAU,OAAc,KAef,aACpD,CAAC"}

package/lib/math/utils/arithmetic/primeDecompNode.js

@@ -0,0 +1,24 @@
+import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../tree/nodes/operators/powerNode.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { primeDecomposition } from "./primeDecomposition.js";
+export const primeDecompNode = (nb, asPowers = true) => {
+    const decomp = primeDecomposition(nb);
+    const nodes = [];
+    if (asPowers) {
+        for (const d of decomp) {
+            if (d.power === 1)
+                nodes.push(d.value.toTree());
+            else
+                nodes.push(power(d.value, d.power));
+        }
+    }
+    else {
+        for (const d of decomp) {
+            for (let i = 0; i < d.power; i++) {
+                nodes.push(d.value.toTree());
+            }
+        }
+    }
+    return operatorComposition(MultiplyNode, nodes);
+};

package/lib/math/utils/functions/functionComparison.d.ts

@@ -0,0 +1,3 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+export declare const isEquivalentNodes: (node1: AlgebraicNode, node2: AlgebraicNode) => boolean;
+//# sourceMappingURL=functionComparison.d.ts.map

package/lib/math/utils/functions/functionComparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionComparison.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComparison.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAsElE,eAAO,MAAM,iBAAiB,GAC5B,OAAO,aAAa,EACpB,OAAO,aAAa,YAarB,CAAC"}

package/lib/math/utils/functions/functionComparison.js

@@ -0,0 +1,58 @@
+import { isInfiniteNode } from "../../../tree/nodes/numbers/constantNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { randfloat } from "../random/randfloat.js";
+const getSafeEvaluationDictForEqualityCheck = (node1, node2, nbSafeX = 4) => {
+    const dict = {};
+    let counter = -1;
+    while (Object.keys(dict).length < nbSafeX && counter < 1000) {
+        counter++;
+        const x = randfloat(-20, 100, 3);
+        let value1;
+        let value2;
+        try {
+            value1 = node1.evaluate({ x });
+        }
+        catch (_) {
+            continue;
+        }
+        try {
+            value2 = node2.evaluate({ x });
+        }
+        catch (_) {
+            continue;
+        }
+        const [isValidValue1, isValidValue2] = [value1, value2].map((value) => value !== undefined && !isNaN(value) && !isInfiniteNode(value.toTree()));
+        if (isValidValue1 && isValidValue2) {
+            dict[x] = [value1, value2].map((value) => {
+                return {
+                    x,
+                    value,
+                };
+            });
+        }
+    }
+    return dict;
+};
+const isEqualFromRandomEvaluations = (node1, node2) => {
+    return Object.values(getSafeEvaluationDictForEqualityCheck(node1, node2)).every((arrSafeEval) => {
+        // console.log(
+        //   "arrSafeEval",
+        //   arrSafeEval.map((safeEval) => safeEval.value),
+        // );
+        return arrSafeEval
+            .slice(1)
+            .every((safeEval) => substract(arrSafeEval[0].value, safeEval.value).evaluate() === 0);
+    });
+};
+export const isEquivalentNodes = (node1, node2) => {
+    let isEqualFromAlgebraicSimplification = false;
+    try {
+        isEqualFromAlgebraicSimplification =
+            substract(node1, node2).simplify().evaluate() === 0;
+    }
+    catch (_) {
+        (() => { })();
+    }
+    return (isEqualFromAlgebraicSimplification ||
+        isEqualFromRandomEvaluations(node1, node2));
+};

package/lib/math/utils/functions/functionComposition.d.ts

@@ -0,0 +1,13 @@
+import { AlgebraicNode, SimplifyOptions } from "../../../tree/nodes/algebraicNode.js";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+export declare const nodeBySubstitutingVar: (nodeCarrier: AlgebraicNode, nodeInjected: AlgebraicNode, variableNode?: VariableNode) => AlgebraicNode;
+export type NodePathWithNodes = {
+    arrNode: AlgebraicNode[];
+    nodePath: NodePath;
+};
+export declare const getAllNodePaths: (node: AlgebraicNode) => NodePathWithNodes[];
+export type NodePath = {
+    keys: ("leftChild" | "rightChild" | "child")[];
+};
+export declare function nodeByReplacingNodeAtPath(nodeCarrier: AlgebraicNode, path: NodePath, nodeInjected: AlgebraicNode, simplifyUpToLevel?: number, simplifyOptions?: SimplifyOptions): AlgebraicNode;
+//# sourceMappingURL=functionComposition.d.ts.map

package/lib/math/utils/functions/functionComposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAU3C,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AAEpD,eAAO,MAAM,qBAAqB,GAChC,aAAa,aAAa,EAC1B,cAAc,aAAa,EAC3B,eAAc,YAA2C,kBAiB1D,CAAC;AAMF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,aAAa,wBA4ClD,CAAC;AAMF,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,CAAC,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC;CAChD,CAAC;AA6BF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,aAAa,EAC1B,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,aAAa,EAC3B,iBAAiB,GAAE,MAAW,EAC9B,eAAe,GAAE,eAAoB,iBAiEtC"}