math-exercises 3.0.189 → 3.0.190

package/lib/exercises/math/functions/exponentials/estimateExponentialFunctionImageFromGeometricScatterplot.js

@@ -0,0 +1,155 @@
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   GetAnswer,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetGGBOptions,
+//   GetQuestionFromIdentifiers,
+//   propWhile,
+//   tryToAddWrongProp,
+// } from "../../../../exercises/exercise.js";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+// import { randfloat } from "../../../../math/utils/random/randfloat.js";
+// import { round } from "../../../../math/utils/round.js";
+// import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+// import { power } from "../../../../tree/nodes/operators/powerNode.js";
+// import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+// import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+// import { doWhile } from "../../../../utils/doWhile.js";
+// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+export {};
+// type Identifiers = {
+//   x: number;
+//   u0: number;
+//   q: number;
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   propWhile(propositions, n, () => {
+//     // tryToAddWrongProp(propositions);
+//   });
+//   return shuffleProps(propositions, n);
+// };
+// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {
+//   const { q, u0, x } = identifiers;
+//   return round(multiply(u0, power(q, x)).evaluate(), 2).frenchify();
+// };
+// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
+//   const { x } = identifiers;
+//   return `On donne ci-dessous le nuage de points représentant une suite géométrique $u$ définie par :
+// $$
+// u_n = u_0\\times q^n
+// $$
+// où $u_0$ est le premier terme de la suite, et $q$ est sa raison.
+// On définit la fonction $f$ sur $[0;+\\infty[$ par :
+// $$
+// f(x) = u_0\\times q^x
+// $$
+// Donner une valeur approchée de $f(${x.frenchify()})$.
+// `;
+// };
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   const { x } = identifiers;
+//   return `La fonction $f$ est le prolongement de la suite $u$.
+// Pour donner une valeur approchée de $f(${x.frenchify()})$, on peut imaginer une courbe qui relie les points du nuage de points, et estimer ainsi l'image de ${x.frenchify()}.`;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   const { x } = identifiers;
+//   return `On relie mentalement les points par une courbe. On peut alors estimer la valeur de ${x.frenchify()} :
+// $$
+// f(${x.frenchify()}) \\approx ${getAnswer(identifiers)}
+// $$`;
+// };
+// const getGGBOptions: GetGGBOptions<Identifiers> = (identifiers) => {
+//   const { u0, q, x } = identifiers;
+//   const ggb = new GeogebraConstructor({
+//     commands: [`Sequence((n, ${u0}*${q}^n), n, 0, 50)`],
+//     lockedAxesRatio: false,
+//   });
+//   const f = (x: number) => round(multiply(u0, power(q, x)).evaluate(), 2);
+//   const next = f(Math.ceil(x));
+//   return ggb.getOptions({
+//     coords: [-1, Math.max(x + 2, 5), -1, Math.max(next + 5, 5) + 1],
+//   });
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, { answer, q, u0, x }) => {
+//   try {
+//     const parsed = parseAlgebraic(ans);
+//     if (!parsed) return false;
+//     const f = (x: number) => round(multiply(u0, power(q, x)).evaluate(), 2);
+//     const nbAns = f(x);
+//     const prev = f(Math.floor(x));
+//     const next = f(Math.ceil(x));
+//     const delta = Math.abs(next - prev);
+//     return Math.abs(parsed.evaluate() - nbAns) < 0.2 * delta;
+//   } catch (err) {
+//     return handleVEAError(err);
+//   }
+// };
+// const getEstimateExponentialFunctionImageFromGeometriceScatterplotQuestion: QuestionGenerator<
+//   Identifiers
+// > = () => {
+//   const u0 = randfloat(0.5, 4, 2);
+//   const q = coinFlip() ? randfloat(0.1, 1, 2, [1]) : randfloat(1.1, 5, 2);
+//   const x = doWhile(
+//     () => randfloat(0.5, 3, 2),
+//     (a) => Math.abs(round(a, 1) - a) < 0.025,
+//   );
+//   const identifiers: Identifiers = {
+//     q,
+//     u0,
+//     x,
+//   };
+//   return getQuestionFromIdentifiers(identifiers);
+// };
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (
+//   identifiers,
+// ) => {
+//   return {
+//     answer: getAnswer(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: [],
+//     answerFormat: "tex",
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers),
+//     ggbOptions: getGGBOptions(identifiers),
+//   };
+// };
+// export const estimateExponentialFunctionImageFromGeometricScatterplot: Exercise<Identifiers> =
+//   {
+//     id: "estimateExponentialFunctionImageFromGeometricScatterplot",
+//     connector: "=",
+//     label:
+//       "Estimer une valeur approchée de $q^x$ à partir du nuage de points de $q^n$",
+//     isSingleStep: true,
+//     generator: (nb, opts) =>
+//       getDistinctQuestions(
+//         () =>
+//           getEstimateExponentialFunctionImageFromGeometriceScatterplotQuestion(
+//             opts,
+//           ),
+//         nb,
+//       ),
+//     qcmTimer: 60,
+//     freeTimer: 60,
+//     getPropositions,
+//     isAnswerValid,
+//     subject: "Mathématiques",
+//     getHint,
+//     getCorrection,
+//     getInstruction,
+//     getAnswer,
+//     getGGBOptions,
+//     hasGeogebra: true,
+//     getQuestionFromIdentifiers,
+//   };

package/lib/exercises/math/functions/exponentials/exponentialsRawVariations.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    q: NodeIdentifiers;
+};
+export declare const exponentialsRawVariations: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=exponentialsRawVariations.d.ts.map

package/lib/exercises/math/functions/exponentials/exponentialsRawVariations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialsRawVariations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/exponentialsRawVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AA6FF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAkB3D,CAAC"}

package/lib/exercises/math/functions/exponentials/exponentialsRawVariations.js

@@ -0,0 +1,99 @@
+import { addValidProp, shuffleProps, 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 { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.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 qEv = reifyAlgebraic(identifiers.q).evaluate();
+    return qEv > 1 ? "Strictement croissante" : "Strictement décroissante";
+};
+const getInstruction = (identifiers) => {
+    const q = reifyAlgebraic(identifiers.q);
+    const statement = power(q, "x").simplify();
+    return `Soit $f$ la fonction définie sur $[0; +\\infty[$ par 
+
+$$
+f(x) = ${statement.toTex()}
+$$
+
+Quel est le sens de variations de $f$ sur $[0; +\\infty[$ ?`;
+};
+const getHint = () => {
+    return `Sur $[0; +\\infty[$, la fonction $f(x) = a^x$ est : 
+  
+- strictement croissante si $a>1$;
+- strictement décroissante si $0<a<1$;
+- constante si $a = 1$
+`;
+};
+const getCorrection = (identifiers) => {
+    const q = reifyAlgebraic(identifiers.q);
+    const qEv = q.evaluate();
+    const qLessThanOne = qEv < 1;
+    return `Puisque $${qLessThanOne ? `0 < ${q.toTex()} < 1` : `${q.toTex()}>1`}$, la fonction $${power(q, "x").toTex()}$ est strictement ${qLessThanOne ? "décroissante" : " croissante"} sur $[0; +\\infty[$.
+  
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const getExponentialsVariationsQuestion = () => {
+    const qLessThanOne = coinFlip();
+    let q;
+    if (qLessThanOne) {
+        q = coinFlip()
+            ? randfloat(0.1, 1, 2).toTree()
+            : RationalConstructor.randomIrreductibleProba().toTree();
+    }
+    else {
+        q = coinFlip()
+            ? randfloat(1.1, 10, 2).toTree()
+            : RationalConstructor.randomIrreductible(11, {
+                onlySupOne: true,
+            }).toTree();
+    }
+    const identifiers = {
+        q: q.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const exponentialsRawVariations = {
+    id: "exponentialsRawVariations",
+    label: "Déterminer le sens de variations d'une fonction exponentielle du type $f(x) = a^x$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExponentialsVariationsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/functions/exponentials/index.d.ts

@@ -1,2 +1,5 @@
 export * from "./exponentialsVariations.js";
+export * from "./exponentialsRawVariations.js";
+export * from "./readExponentialFunctionParamsOnGraph.js";
+export * from "./plausibleExponentialFunctionExpressionFromGraph.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/exponentials/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,sDAAsD,CAAC"}

package/lib/exercises/math/functions/exponentials/index.js

@@ -1 +1,5 @@
 export * from "./exponentialsVariations.js";
+export * from "./exponentialsRawVariations.js";
+export * from "./readExponentialFunctionParamsOnGraph.js";
+export * from "./plausibleExponentialFunctionExpressionFromGraph.js";
+// export * from "./estimateExponentialFunctionImageFromGeometricScatterplot.js";

package/lib/exercises/math/functions/exponentials/plausibleExponentialFunctionExpressionFromGraph.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    k: number;
+    a: number;
+    fakeParams: {
+        a: number;
+        k: number;
+    }[];
+};
+export declare const plausibleExponentialFunctionExpressionFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=plausibleExponentialFunctionExpressionFromGraph.d.ts.map

package/lib/exercises/math/functions/exponentials/plausibleExponentialFunctionExpressionFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plausibleExponentialFunctionExpressionFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/plausibleExponentialFunctionExpressionFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACxC,CAAC;AAwIF,eAAO,MAAM,+CAA+C,EAAE,QAAQ,CAAC,WAAW,CAwB/E,CAAC"}

package/lib/exercises/math/functions/exponentials/plausibleExponentialFunctionExpressionFromGraph.js

@@ -0,0 +1,138 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer, fakeParams }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    for (let i = 0; i < fakeParams.length; i++) {
+        tryToAddWrongProp(propositions, multiply(fakeParams[i].k, power(fakeParams[i].a, "x")).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, k } = identifiers;
+    return multiply(k, power(a, "x")).toTex();
+};
+const getInstruction = () => {
+    return `On donne ci-dessous la courbe représentative d'une fonction $f$ définie sur $[0; +\\infty[$ par : 
+  
+$$
+f(x) = ka^x
+$$
+
+où $k$ et $a$ sont des réels strictement positifs.
+
+Parmi les propositions suivantes, laquelle peut être l'expression de la fonction $f$ ?`;
+};
+const getHint = () => {
+    return `Le sens de variation de la fonction peut t'aider : si $a>1$, la fonction est strictement croissante, et si $0<a<1$, la fonction est strictement décroissante.
+  
+D'autre part, tu peux lire l'image de $0$ pour obtenir une valeur approchée de $k$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, k } = identifiers;
+    const sens = a < 1 ? "décroissante" : "croissante";
+    return `On sait que l'expression de la fonction $f$ est de la forme : 
+  
+$$
+f(x) = ka^x
+$$
+
+D'après le graphique, la fonction $f$ est ${sens} sur $[0; +\\infty[$. On en déduit donc que $a ${a < 1 ? "<1" : ">1"}$. Cela permet donc d'exclure deux des propositions.
+
+Ensuite, on lit l'image de $0$ par $f$ : on trouve $f(0) \\approx ${round(k, 1).frenchify()}$.
+
+Or, $f(0) = ka^0 = k$. Donc $k \\approx ${round(k, 1).frenchify()}$.
+
+On en conclut donc que la seule expression possible pour $f$ est :
+
+$$
+f(x) = ${getAnswer(identifiers)}
+$$`;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, k } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [`Function(${k}*${a}^x, 0, 10000)`],
+        lockedAxesRatio: false,
+    });
+    const f2 = multiply(k, power(a, 2)).evaluate();
+    return ggb.getOptions({
+        coords: [-1, 5, -1, Math.max(k, f2) + 1],
+    });
+};
+const getPlausibleExponentialFunctionExpressionFromGraphQuestion = () => {
+    const k = randfloat(0.5, 4, 2);
+    const a = coinFlip() ? randfloat(0.1, 1, 2, [1]) : randfloat(1.1, 5, 2);
+    let fakeParams = [];
+    if (a > 1) {
+        const firstDescA = randfloat(0.1, 1, 2, [1]);
+        const secondDescA = randfloat(0.1, 1, 2, [firstDescA]);
+        const thirdA = randfloat(1.1, 5, 2, [a]);
+        const firstK = k;
+        const secondK = randfloat(0.1, 4, 2);
+        const delta = randfloat(1, 3, 2);
+        const thirdK = k - delta > 0 ? k - delta : k + delta;
+        fakeParams = [
+            { a: firstDescA, k: firstK },
+            { a: secondDescA, k: secondK },
+            { a: thirdA, k: thirdK },
+        ];
+    }
+    else {
+        const firstAscA = randfloat(1.1, 5, 2);
+        const secondAscA = randfloat(1.1, 5, 2, [firstAscA]);
+        const thirdA = randfloat(0.1, 1, 2, [1, a]);
+        const firstK = k;
+        const secondK = randfloat(0.1, 4, 2);
+        const delta = randfloat(1, 3, 2);
+        const thirdK = k - delta > 0 ? k - delta : k + delta;
+        fakeParams = [
+            { a: firstAscA, k: firstK },
+            { a: secondAscA, k: secondK },
+            { a: thirdA, k: thirdK },
+        ];
+    }
+    const identifiers = {
+        a,
+        k,
+        fakeParams,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const plausibleExponentialFunctionExpressionFromGraph = {
+    id: "plausibleExponentialFunctionExpressionFromGraph",
+    label: "Donner l'expression possible d'une fonction exponentielle à partir de sa courbe représentative",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlausibleExponentialFunctionExpressionFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/exponentials/readExponentialFunctionParamsOnGraph.d.ts

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

package/lib/exercises/math/functions/exponentials/readExponentialFunctionParamsOnGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readExponentialFunctionParamsOnGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/readExponentialFunctionParamsOnGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA6HF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CA0BtE,CAAC"}

package/lib/exercises/math/functions/exponentials/readExponentialFunctionParamsOnGraph.js

@@ -0,0 +1,142 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const fakeK = randint(2, 10);
+        const fakeA = randint(2, 10);
+        tryToAddWrongProp(propositions, multiply(fakeK, power(fakeA, "x")).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { f0, f1 } = identifiers;
+    return multiply(f0, power(frac(f1, f0), "x"))
+        .simplify()
+        .toTex();
+};
+const getInstruction = () => {
+    return `On donne ci-dessous la courbe représentative d'une fonction $f$ définie sur $[0; +\\infty[$ par : 
+  
+$$
+f(x) = ka^x
+$$
+
+où $k$ et $a$ sont des réels strictement positifs.
+
+En lisant les images par $f$ de $0$ et de $1$, déterminer l'expression de la fonction $f$.`;
+};
+const getHint = () => {
+    return `Lis les images par $f$ de $0$ et de $1$.
+  
+Puis, remarque que : 
+
+- $f(0) = ka^0 = k$
+- $f(1) = ka^1 = ka$
+
+Cela te permet de retrouver $k$ et $a$.`;
+};
+const getCorrection = (identifiers) => {
+    const { f0, f1 } = identifiers;
+    return `On lit les images par $f$ de $0$ et de $1$ :
+  
+- $f(0) = ${f0.frenchify()}$
+- $f(1) = ${f1.frenchify()}$
+
+Or, puisque $f(x) = ka^x$, on a :
+
+$$
+f(0) = ka^0 = k\\times 1 = k
+$$
+
+Donc $k = ${f0.frenchify()}$.
+
+De même, on a :
+
+$$
+f(1) = ka^1 = ka = ${multiply(f0, "a").toTex()}
+$$
+
+Donc $a = ${frac(f1, f0).simplify().toTex()}$.
+
+Ainsi, l'expression de $f$ est : 
+
+$$
+f(x) = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { f0, f1 } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [`Function(${f0}*${f1 / f0}^x, 0, 10000)`],
+        lockedAxesRatio: false,
+    });
+    return ggb.getOptions({
+        coords: [-1, 5, -1, 2 * Math.max(f0, f1)],
+    });
+};
+const getKeys = () => {
+    return ["x"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getReadExponentialFunctionParamsOnGraphQuestion = () => {
+    const k = randint(1, 6);
+    const a = randint(2, 6, [k]);
+    const identifiers = {
+        f0: k,
+        f1: a * k,
+    };
+    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),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const readExponentialFunctionParamsOnGraph = {
+    id: "readExponentialFunctionParamsOnGraph",
+    connector: "=",
+    label: "Déterminer l'expression d'une fonction exponentielle à partir de sa courbe représentative",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getReadExponentialFunctionParamsOnGraphQuestion(opts), nb, 10),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    maxAllowedQuestions: 10,
+};

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placeAbscissOnSemiLineV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAanE,CAAC"}
+{"version":3,"file":"placeAbscissOnSemiLineV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAanE,CAAC"}

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.js

@@ -1,6 +1,7 @@
 import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
 import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
@@ -88,10 +89,10 @@ const isGGBAnswerValid = (ans, { absciss2, axisUnit }) => {
             0.2 * axisUnitNode.evaluate());
 };
 const getPlaceAbscissOnSemiLineV2Question = (optsIn) => {
-    const arrayedOptions = optsIn ?? optsDefault;
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
     const opts = {
-        questionType: random(arrayedOptions.questionType),
-        numberType: random(arrayedOptions.numberType),
+        questionType: random(arrayedOpts.questionType),
+        numberType: random(arrayedOpts.numberType),
     };
     const abscissType = (() => {
         switch (opts.numberType) {
@@ -169,7 +170,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     };
     return question;
 };
-const optsDefault = {
+const arrayedOptsDefault = {
     questionType: ["standard", "éviter le comptage"],
     numberType: ["Entiers", "Rationnels", "Décimaux"],
 };
@@ -180,7 +181,7 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["standard", "éviter le comptage"],
-        defaultValue: optsDefault.questionType,
+        defaultValue: arrayedOptsDefault.questionType,
     },
     {
         id: "numberType",
@@ -188,7 +189,7 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["Entiers", "Rationnels", "Décimaux"],
-        defaultValue: optsDefault.numberType,
+        defaultValue: arrayedOptsDefault.numberType,
     },
 ];
 export const placeAbscissOnSemiLineV2 = {

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductAlKashiBH.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAwBnD,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,mBAAmB,CAAC;IACjC,SAAS,EAAE,gBAAgB,CAAC;CAC7B,CAAC;AAopBF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAuBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA2BjE,CAAC"}
+{"version":3,"file":"scalarProductAlKashiBH.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAwBnD,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,mBAAmB,CAAC;IACjC,SAAS,EAAE,gBAAgB,CAAC;CAC7B,CAAC;AAmpBF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAuBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA2BjE,CAAC"}