math-exercises 3.0.199 → 3.0.201

package/lib/math/utils/sequences/situations/seqGeometricSituations.js

@@ -1,6 +1,10 @@
+import { Point } from "../../../../math/geometry/point.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
 import { randfloat } from "../../random/randfloat.js";
 import { randint } from "../../random/randint.js";
 import { round } from "../../round.js";
@@ -10,30 +14,31 @@ const getStrFactor = (firstRank) => {
 };
 //decoration
 const createSituationGeometricFromTemplate = (templateSituationsGeometric) => {
-    const { variationFindExplicitFormula, variationFindRecurrenceFormula, variationFindRandomTerm,
-    // variationFindRank,
+    const { variationFindExplicitFormula, variationFindRecurrenceFormula, variationFindRandomTerm, variationFindRank,
     // variationFindThreshold,
      } = templateSituationsGeometric;
-    return Object.assign({}, templateSituationsGeometric, {
-        variationFindExplicitFormula: Object.assign({}, variationFindExplicitFormula, {
-            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
-                const { str: strRaw } = variationFindExplicitFormula.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
-                const str = `${strRaw}
+    return {
+        ...templateSituationsGeometric,
+        ...{
+            variationFindExplicitFormula: Object.assign({}, variationFindExplicitFormula, {
+                getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                    const { str: strRaw } = variationFindExplicitFormula.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                    const str = `${strRaw}
 
 $$
 ${seqGeometricUtils
-                    .getAnswerNodeExplicitFormula(initial, reason, firstRank)
-                    .toTex()}
+                        .getAnswerNodeExplicitFormula(initial, reason, firstRank)
+                        .toTex()}
 $$
 
 `;
-                return { str };
-            },
-        }),
-        variationFindRecurrenceFormula: Object.assign({}, variationFindRecurrenceFormula, {
-            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
-                const { str: strRaw, rank1, rank2, } = variationFindRecurrenceFormula.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
-                const str = `${strRaw}
+                    return { str };
+                },
+            }),
+            variationFindRecurrenceFormula: Object.assign({}, variationFindRecurrenceFormula, {
+                getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                    const { str: strRaw, rank1, rank2, } = variationFindRecurrenceFormula.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                    const str = `${strRaw}
 
 $$
 u_{${rank2.frenchify()}} = (${reason.frenchify()}) \\times u_{${rank1.frenchify()}}
@@ -43,27 +48,27 @@ La relation de récurrence est, pour $n \\geq ${firstRank.frenchify()}$ :
 
 $$
 ${seqGeometricUtils
-                    .getAnswerNodeRecurrenceFormula(initial, reason, firstRank)
-                    .toTex()}
+                        .getAnswerNodeRecurrenceFormula(initial, reason, firstRank)
+                        .toTex()}
 $$
 
 `;
-                return { str, rank1, rank2 };
-            },
-        }),
-        variationFindRandomTerm: Object.assign({}, variationFindRandomTerm, {
-            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
-                const [rankAsked] = otherArgs;
-                const { str: strRaw } = variationFindRandomTerm.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
-                const answerNode = variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, ...otherArgs);
-                const str = `${strRaw}
+                    return { str, rank1, rank2 };
+                },
+            }),
+            variationFindRandomTerm: Object.assign({}, variationFindRandomTerm, {
+                getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                    const [rankAsked] = otherArgs;
+                    const { str: strRaw } = variationFindRandomTerm.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                    const answerNode = variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, ...otherArgs);
+                    const str = `${strRaw}
 
 Le terme général est :
 
 $$
 ${seqGeometricUtils
-                    .getAnswerNodeExplicitFormula(initial, reason, firstRank)
-                    .toTex()}
+                        .getAnswerNodeExplicitFormula(initial, reason, firstRank)
+                        .toTex()}
 $$
 
 En particulier :
@@ -71,10 +76,58 @@ En particulier :
 ${alignTex([[`u_{${rankAsked}}`, "=", answerNode.toTex()]])}
 
 `;
-                return { str };
+                    return { str };
+                },
+            }),
+            variationFindRank: {
+                ...variationFindRank,
+                ...{
+                    getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                        const [_valueAsked, _rankDecoder, _digitsValue, digitsTarget] = otherArgs;
+                        const { str: strRaw } = variationFindRank.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                        const { answerNode, rankNode } = variationFindRank.getAnswerStuff(initial, reason, firstRank, ...otherArgs);
+                        const texRankSimplified = rankNode.evaluate().frPretty(0);
+                        const texAnswer = [
+                            ...new Set([
+                                answerNode.toTex(),
+                                answerNode.evaluate().frPretty(digitsTarget),
+                            ]),
+                        ].join(" = ");
+                        const nodeInitial = initial.toTree();
+                        const nodeReason = reason.toTree();
+                        const arrNodeTerm = [...Array(15).keys()].map((i) => multiply(nodeInitial, power(nodeReason, i))
+                            .simplify({
+                            towardsDistribute: true,
+                            calculatePowers: true,
+                            distributePowersOnFrac: true,
+                        })
+                            .simplify({ towardsDistribute: false }));
+                        const arrPoint = arrNodeTerm.map((nodeTerm, i) => {
+                            const nodeX = (firstRank + i).toTree();
+                            return new Point(`P${firstRank + i}`, nodeX, nodeTerm);
+                        });
+                        const str = `${strRaw}
+
+On note $p$ le rang recherché.
+On affiche le tableau de valeurs avec la calculatrice :
+
+${mdTable([
+                            ["n", "u_{n}"],
+                            ...arrPoint.map((point) => [
+                                point.x.toTex(),
+                                round(point.y.evaluate(), 2).frenchify(),
+                            ]),
+                        ], true)}
+
+Le rang $p$ est donc $${texRankSimplified}$.
+
+Le nombre recherché est donc $${texAnswer}$.`;
+                        return { str };
+                    },
+                },
             },
-        }),
-    });
+        },
+    };
 };
 //raw material
 const templatesSituationsGeometric = [
@@ -107,9 +160,11 @@ const templatesSituationsGeometric = [
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (2026 + rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() - 2026 + firstRank,
+            targetFromRank: (rank, firstRank) => round(2026 + rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() - 2026 + firstRank, 0),
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             const evoPercentage = (reason - 1) * 100;
             const strEvoPercentage = evoPercentage.frPretty(2);
@@ -198,6 +253,32 @@ Utilise le terme général de $u_n$ pour déterminer le capital pour l'année $2
                 const strEvoPercentage = evoPercentage.frPretty(2);
                 return {
                     str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, le capital est multiplié par $${reason.frenchify()}$.
+Le capital en $\\textrm{€}$, au premier janvier de l'année $${add(2026, substract("n".toTree(), firstRank))
+                        .simplify()
+                        .toTex()}$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle année le capital sera-t-il de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{€}$ ?`;
+            },
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqGeometricUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $u_n$ ? 
+      
+Utilise le terme général de $(u_n)$ pour déterminer $n$ tel que $u_n = ${valueAsked.frPretty(2)}$.`;
+            },
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                return {
+                    str: `Chaque année, le capital est multiplié par $${reason.frenchify()}$.
 Le capital en $\\textrm{€}$, au premier janvier de l'année $${add(2026, substract("n".toTree(), firstRank))
                         .simplify()
                         .toTex()}$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
@@ -234,9 +315,11 @@ Le capital en $\\textrm{€}$, au premier janvier de l'année $${add(2026, subst
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (2025 + rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() - 2025 + firstRank,
+            targetFromRank: (rank, firstRank) => round(2025 + rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() - 2025 + firstRank, 0),
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             const evoPercentage = (reason - 1) * 100;
             const strMinusEvoPercentage = (-evoPercentage).frPretty(0);
@@ -328,6 +411,32 @@ Utilise le terme général de $u_n$ pour déterminer la valeur de la voiture de
                 const strEvoPercentage = evoPercentage.frPretty(0);
                 return {
                     str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, la valeur de la voiture de Killian est multipliée par $${reason.frenchify()}$.
+La valeur de la voiture de Killian en $\\textrm{€}$, au premier juillet de l'année $${add(2025, substract("n".toTree(), firstRank))
+                        .simplify()
+                        .toTex()}$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle année la valeur de la voiture sera-t-elle de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{€}$ ?`;
+            },
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqGeometricUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $u_n$ ? 
+      
+Utilise le terme général de $(u_n)$ pour déterminer $n$ tel que $u_n = ${valueAsked.frPretty(2)}$.`;
+            },
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                return {
+                    str: `Chaque année, la valeur de la voiture est multipliée par $${reason.frenchify()}$.
 La valeur de la voiture de Killian en $\\textrm{€}$, au premier juillet de l'année $${add(2025, substract("n".toTree(), firstRank))
                         .simplify()
                         .toTex()}$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
@@ -364,9 +473,11 @@ La valeur de la voiture de Killian en $\\textrm{€}$, au premier juillet de l'a
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (0 + rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() - 0 + firstRank,
+            targetFromRank: (rank, firstRank) => round(0 + rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() - 0 + firstRank, 0),
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             const factorPercentage = reason * 100;
             const strFactorPercentage = factorPercentage.frPretty(0);
@@ -457,6 +568,30 @@ Utilise le terme général de $u_n$ pour déterminer la hauteur de la balle au $
                 const strFactorPercentage = factorPercentage.frPretty(0);
                 return {
                     str: `Le coefficient multiplicateur est $${strFactorPercentage} \\%$ donc à chaque rebond, la hauteur de la balle est multipliée par $${reason.frenchify()}$.
+La hauteur de la balle est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Après combien de rebonds la hauteur de la balle sera-t-elle de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{m}$ ?`;
+            },
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqGeometricUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $u_n$ ? 
+      
+Utilise le terme général de $(u_n)$ pour déterminer $n$ tel que $u_n = ${valueAsked.frPretty(2)}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Après chaque rebond, la hauteur de la balle est multipliée par $${reason.frenchify()}$.
 La hauteur de la balle est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
                 };
             },
@@ -491,9 +626,11 @@ La hauteur de la balle est donc une suite géométrique de premier terme $${init
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (0 + rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() - 0 + firstRank,
+            targetFromRank: (rank, firstRank) => round(0 + rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() - 0 + firstRank, 0),
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             const evoPercentage = (reason - 1) * 100;
             const strEvoPercentage = evoPercentage.frPretty(0);
@@ -579,6 +716,30 @@ Utilise le terme général de $u_n$ pour déterminer le nombre de bactéries apr
                 const strEvoPercentage = evoPercentage.frPretty(0);
                 return {
                     str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque heure, le nombre de bactéries est multiplié par $${reason.frenchify()}$.
+Le nombre de bactéries est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Après combien d'heures le nombre de bactéries sera-t-il de $${round(valueAsked, 0).frPretty(0)}$ ?`;
+            },
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqGeometricUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $u_n$ ? 
+      
+Utilise le terme général de $(u_n)$ pour déterminer $n$ tel que $u_n = ${valueAsked.frPretty(0)}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque heure, le nombre de bactéries est multiplié par $${reason.frenchify()}$.
 Le nombre de bactéries est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
                 };
             },
@@ -588,7 +749,7 @@ Le nombre de bactéries est donc une suite géométrique de premier terme $${ini
     {
         type: "factor",
         randInitial: () => randint(2, 8),
-        randReason: () => randint(2, 8),
+        randReason: () => randint(2, 4),
         randThreshold: (initial, reason, firstRank) => seqGeometricUtils.randThreshold(initial, reason, firstRank, 2),
         randSuperfluousData: () => {
             const rand = randint(0, 2);
@@ -613,9 +774,11 @@ Le nombre de bactéries est donc une suite géométrique de premier terme $${ini
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (0 + rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() - 0 + firstRank,
+            targetFromRank: (rank, firstRank) => round(0 + rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() - 0 + firstRank, 0),
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             if (superfluousData === undefined) {
                 return `Justine dévoile un secret à $${initial}$ de ses amies. 
@@ -699,6 +862,30 @@ Utilise le terme général de $u_n$ pour déterminer le nombre de personnes info
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
                     str: `Le coefficient multiplicateur est $${reason}$ donc, chaque jour, le nombre de personnes informées est multiplié par $${reason.frenchify()}$.
+Le nombre de personnes informées est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Après combien de jours le nombre de personnes informées sera-t-il de $${round(valueAsked, 0).frPretty(0)}$ ?`;
+            },
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqGeometricUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $u_n$ ? 
+      
+Utilise le terme général de $(u_n)$ pour déterminer $n$ tel que $u_n = ${valueAsked.frPretty(0)}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque jour, le nombre de personnes informées est multiplié par $${reason.frenchify()}$.
 Le nombre de personnes informées est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
                 };
             },
@@ -733,9 +920,11 @@ Le nombre de personnes informées est donc une suite géométrique de premier te
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (2025 + rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() - 2025 + firstRank,
+            targetFromRank: (rank, firstRank) => round(2025 + rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() - 2025 + firstRank, 0),
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             const evoPercentage = (reason - 1) * 100;
             const strEvoPercentage = evoPercentage.frPretty(0);
@@ -832,6 +1021,32 @@ Utilise le terme général de $u_n$ pour déterminer le salaire pour l'année $2
                 const strEvoPercentage = evoPercentage.frPretty(2);
                 return {
                     str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, le salaire est multiplié par $${reason.frenchify()}$.
+Le salaire en $\\textrm{€}$ pour l'année $${add(2025, substract("n".toTree(), firstRank))
+                        .simplify()
+                        .toTex()}$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle année le salaire de Sofiane sera-t-il de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{€}$ ?`;
+            },
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqGeometricUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $u_n$ ? 
+      
+      Utilise le terme général de $(u_n)$ pour déterminer $n$ tel que $u_n = ${valueAsked.frPretty(2)}$.`;
+            },
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                return {
+                    str: `Chaque année, le salaire est multiplié par $${reason.frenchify()}$.
 Le salaire en $\\textrm{€}$ pour l'année $${add(2025, substract("n".toTree(), firstRank))
                         .simplify()
                         .toTex()}$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
@@ -868,9 +1083,11 @@ Le salaire en $\\textrm{€}$ pour l'année $${add(2025, substract("n".toTree(),
             };
         },
         rankDecoder: {
-            targetFromRank: (rank, firstRank) => (0 + rank - firstRank).toTree(),
-            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() - 0 + firstRank,
+            targetFromRank: (rank, firstRank) => round(0 + rank - firstRank, 0).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => round(nodeTarget.evaluate() - 0 + firstRank, 0),
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, _firstRank, superfluousData) => {
             const evoPercentage = (reason - 1) * 100;
             const strEvoPercentage = evoPercentage.frPretty(0);
@@ -954,6 +1171,30 @@ Utilise le terme général de $u_n$ pour déterminer le loyer pour le mois $${ta
                 const strEvoPercentage = evoPercentage.frPretty(0);
                 return {
                     str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque mois, le loyer est multiplié par $${reason.frenchify()}$.
+Le loyer en $\\textrm{€}$ pour le mois $n$ est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Après combien de mois de location le loyer sera-t-il de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{€}$ ?`;
+            },
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqGeometricUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $u_n$ ? 
+      
+      Utilise le terme général de $(u_n)$ pour déterminer $n$ tel que $u_n = ${valueAsked.frPretty(2)}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque mois, le loyer est multiplié par $${reason.frenchify()}$.
 Le loyer en $\\textrm{€}$ pour le mois $n$ est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
                 };
             },

package/lib/server.js

@@ -101,6 +101,31 @@ const runServer = () => {
         const props = exo.getPropositions(n, { answer, ...identifiers }, options);
         res.json(props);
     });
+    app.get("/getOrderedItems", (req, res) => {
+        const n = Number(req.query.n) || 4;
+        const exoId = req.query.exoId;
+        const options = req.query.options
+            ? JSON.parse(decodeURIComponent(req.query.options))
+            : undefined;
+        const identifiers = req.query.identifiers
+            ? JSON.parse(decodeURIComponent(req.query.identifiers))
+            : undefined;
+        const hasAnswer = !!req.query.answer && req.query.answer !== "undefined";
+        const answer = hasAnswer
+            ? JSON.parse(decodeURIComponent(req.query.answer))
+            : "";
+        const exo = allExercises.find((exo) => exo.id == exoId);
+        if (!exo) {
+            res.send("Exo not found");
+            return;
+        }
+        if (!exo?.getOrderedItems) {
+            res.send("no getOrderedItems");
+            return;
+        }
+        const props = exo.getOrderedItems(n, { answer, ...identifiers }, options);
+        res.json(props);
+    });
     app.get("/isAnswerTableValid", (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options

package/lib/tests/questionTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AA0BjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAsU3B,CAAC"}
+{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AA0BjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CA6U3B,CAAC"}

package/lib/tests/questionTest.js

@@ -60,6 +60,7 @@ export const questionTest = (exo, question) => {
     }
     const dotDecimalPattern = /\d+\.\d+/;
     const pythonPattern = /\`.*\`/;
+    const latexArraystretchPattern = /.*\\def\\arraystretch\{\d+\.\d+\}.*/;
     if (question.studentGgbOptions?.coords?.length) {
         if (exo.answerType !== "GGB") {
             throw new Error(`exo ${exo.id} has studentGgbOptions but answerType is not GGB`);
@@ -111,7 +112,8 @@ export const questionTest = (exo, question) => {
     }
     if (question.answer) {
         if (question.answer.match(dotDecimalPattern) &&
-            !question.answer.match(pythonPattern))
+            !(question.answer.match(pythonPattern) ||
+                question.answer.match(latexArraystretchPattern)))
             throw new Error(`exo ${exo.id} has invalid number format, answer: ${question.answer}`);
         if (question.answer.includes("[object Object]"))
             throw new Error(`exo ${exo.id} has invalid answer`);
@@ -240,7 +242,8 @@ export const questionTest = (exo, question) => {
             if (prop.statement.includes("undefined"))
                 throw new Error(`exo ${exo.id} has invalid prop (undefined) : ${prop.statement}`);
             if (prop.statement.match(dotDecimalPattern) &&
-                !prop.statement.match(pythonPattern))
+                !(prop.statement.match(pythonPattern) ||
+                    prop.statement.match(latexArraystretchPattern)))
                 throw new Error(`exo ${exo.id} has invalid prop (dot) : ${prop.statement}`);
             if (prop.statement.includes("[object Object]"))
                 throw new Error(`exo ${exo.id} has invalid prop (objectObject) : ${prop.statement}`);

package/lib/tests/singleExo.test.js

@@ -1,9 +1,9 @@
 import "../prototypesEnhancement.js";
 import { exoTest } from "./exoTest.js";
-import { geometricFindExplicitFormulaFromSituation, } from "../exercises/math/index.js";
+import { productOfSinAXPlusBCosCXPlusDDerivative, } from "../exercises/math/index.js";
 try {
     for (let i = 0; i < 1000; i++)
-        exoTest(geometricFindExplicitFormulaFromSituation);
+        exoTest(productOfSinAXPlusBCosCXPlusDDerivative);
 }
 catch (err) {
     throw err;

package/lib/tree/nodes/functions/cosNode.d.ts

@@ -25,6 +25,6 @@ export declare class CosNode implements FunctionNode {
     evaluate(vars?: Record<string, number>, opts?: EvaluateOptions): number;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): CosNode;
-    derivative(): AlgebraicNode;
+    derivative(varName?: string | undefined): AlgebraicNode;
 }
 //# sourceMappingURL=cosNode.d.ts.map

package/lib/tree/nodes/functions/cosNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cosNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/cosNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EACL,aAAa,EACb,eAAe,EACf,eAAe,EAChB,MAAM,qBAAqB,CAAC;AAI7B,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,YAIrD,CAAC;AAEF,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAGf,mBAAmB,IAAI,MAAM;IAG7B,mBAAmB;IAOnB,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,aAAa;IA+BnD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe;IAO9D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,IAAI,aAAa;CAG5B"}
+{"version":3,"file":"cosNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/cosNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EACL,aAAa,EACb,eAAe,EACf,eAAe,EAChB,MAAM,qBAAqB,CAAC;AAO7B,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,YAIrD,CAAC;AAEF,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAGf,mBAAmB,IAAI,MAAM;IAG7B,mBAAmB;IAOnB,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAI1B,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,aAAa;IA+BnD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe;IAO9D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

package/lib/tree/nodes/functions/cosNode.js

@@ -2,6 +2,9 @@ import { NodeIds, NodeType } from "../node.js";
 import { FunctionsIds, isFunctionNode } from "./functionNode.js";
 import { mainTrigoValues } from "../../../math/trigonometry/remarkableValues.js";
 import { hasVariableNode } from "../hasVariableNode.js";
+import { multiply } from "../operators/multiplyNode.js";
+import { opposite } from "./oppositeNode.js";
+import { sin } from "./sinNode.js";
 export function isCosNode(a) {
     return isFunctionNode(a) && a.id === FunctionsIds.cos;
 }
@@ -96,7 +99,7 @@ export class CosNode {
     toDetailedEvaluation(vars) {
         return new CosNode(this.child.toDetailedEvaluation(vars));
     }
-    derivative() {
-        throw new Error("unimplemented derivative");
+    derivative(varName) {
+        return multiply(this.child.derivative(varName), opposite(sin(this.child)));
     }
 }

package/lib/tree/nodes/functions/factorialNode.d.ts

@@ -20,6 +20,7 @@ export declare class FactorialNode implements FunctionNode {
     toSimplificationTex(): string;
     toTex(opts?: ToTexOptions): string;
     toEquivalentNodes(): AlgebraicNode[];
+    toMultiplyNode(): AlgebraicNode;
     toAllValidTexs(): string[];
     simplify(opts?: SimplifyOptions): import("../numbers/constantNode.js").ConstantNode | import("../numbers/numberNode.js").NumberNode | FactorialNode;
     evaluate(vars?: Record<string, number>): number;

package/lib/tree/nodes/functions/factorialNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factorialNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/factorialNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGrE,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AACD,eAAO,MAAM,KAAK,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,kBAIvD,CAAC;AACF,qBAAa,aAAc,YAAW,YAAY;IAChD,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,mBAAmB;IAOnB,mBAAmB,IAAI,MAAM;IAG7B,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IAOlC,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAO/B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,MAAM,CAAC,IAAI,EAAE,aAAa;IAI1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAKxD,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGzD"}
+{"version":3,"file":"factorialNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/factorialNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKrE,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AACD,eAAO,MAAM,KAAK,GAAI,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,kBAIvD,CAAC;AACF,qBAAa,aAAc,YAAW,YAAY;IAChD,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,mBAAmB;IAOnB,mBAAmB,IAAI,MAAM;IAG7B,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IAYlC,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,aAAa;IAQ/B,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAO/B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,MAAM,CAAC,IAAI,EAAE,aAAa;IAI1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAKxD,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGzD"}