math-exercises 3.0.189 → 3.0.191

package/lib/exercises/math/functions/affines/affineVariationsFromGraph.js

@@ -0,0 +1,203 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blues, greenMain, oranges, purples, reds, } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { random } from "../../../../utils/alea/random.js";
+const getInstruction = () => {
+    return `Ci-dessous est tracée la courbe représentative $C_f$ d'une fonction affine $f$. 
+Déterminer graphiquement le sens de variation de $f$.`;
+};
+const getAnswer = (identifiers) => {
+    const { b, secondPoint } = identifiers;
+    const point1 = new Point("P1", 0, b);
+    const point2 = new Point("P2", secondPoint[0], secondPoint[1]);
+    if (NodeComparator.isEqualViaSub(point1.y, point2.y)) {
+        return "Constante";
+    }
+    else {
+        const [pointXSmall, pointXBig] = [point1, point2].toSorted((point1, point2) => point1.x.evaluate() - point2.x.evaluate());
+        return NodeComparator.compareViaSub(pointXSmall.y, pointXBig.y) === -1
+            ? "Strictement croissante"
+            : "Strictement décroissante";
+    }
+};
+const getHint = () => {
+    return `On prend deux points distincts sur $C_f$. 
+
+On note $x_{1}$ l'abscisse du point avec l'abscisse la plus petite.
+On note $x_{2}$ l'abscisse du point avec l'abscisse la plus grande.
+
+Les coordonnées des deux points sont donc $(x_{1};f(x_{1}))$ et $(x_{2};f(x_{2}))$.
+
+La fonction $f$ est 
+
+- strictement croissante si :
+
+$$
+f(x_{1})<f(x_{2})
+$$
+
+- strictement décroissante si :
+
+$$
+f(x_{1})>f(x_{2})
+$$
+
+- constante si :
+
+$$
+f(x_{1})=f(x_{2})
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { b, secondPoint } = identifiers;
+    const point1 = new Point("P1", 0, b);
+    const point2 = new Point("P2", secondPoint[0], secondPoint[1]);
+    if (NodeComparator.isEqualViaSub(point1.y, point2.y)) {
+        return `On a :
+    
+$$
+f(${point1.x.toTex()}) = f(${point2.x.toTex()}) = ${point1.y.toTex()}
+$$
+
+La fonction $f$ est donc constante sur $\\mathbb{R}$.`;
+    }
+    else {
+        const [pointXSmall, pointXBig] = [point1, point2].toSorted((point1, point2) => point1.x.evaluate() - point2.x.evaluate());
+        const valueComp = NodeComparator.compareViaSub(pointXSmall.y, pointXBig.y);
+        if (valueComp === -1) {
+            return `On a :
+
+$$
+${pointXSmall.x.toTex()} < ${pointXBig.x.toTex()}
+$$
+
+et
+
+$$
+f(${pointXSmall.x.toTex()}) < f(${pointXBig.x.toTex()})
+$$
+  
+
+La fonction $f$ est donc ${getAnswer(identifiers).toLocaleLowerCase()} sur $\\mathbb{R}$.`;
+        }
+        else {
+            return `On a :
+
+$$
+${pointXSmall.x.toTex()} < ${pointXBig.x.toTex()}
+$$
+
+et
+
+$$
+f(${pointXSmall.x.toTex()}) > f(${pointXBig.x.toTex()})
+$$
+  
+
+La fonction $f$ est donc ${getAnswer(identifiers).toLocaleLowerCase()} sur $\\mathbb{R}$.`;
+        }
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { b, secondPoint } = identifiers;
+    const xMin = Math.min(0, secondPoint[0]);
+    const xMax = Math.max(0, secondPoint[0]);
+    const yMin = Math.min(b, secondPoint[1]);
+    const yMax = Math.max(b, secondPoint[1]);
+    const point1 = new Point("P1", 0, b);
+    const point2 = new Point("P2", secondPoint[0], secondPoint[1]);
+    const [pointXSmall, pointXBig] = [point1, point2].toSorted((point1, point2) => point1.x.evaluate() - point2.x.evaluate());
+    const colorButGreen = (() => {
+        const colors = [...reds, ...oranges, ...blues, ...purples];
+        return random(colors);
+    })();
+    const commands = [
+        `l = Line[(0, ${b}), (${secondPoint[0]}, ${secondPoint[1]})]`,
+        `SetColor(l, "${colorButGreen}")`,
+        "SetFixed(l, true, false)",
+        `v = Vector(${pointXSmall.toMathString()}, ${pointXBig.toMathString()})`,
+        `SetLineThickness(v, 10)`,
+        `SetColor(v, "${greenMain}")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { b, secondPoint } = identifiers;
+    const xMin = Math.min(0, secondPoint[0]);
+    const xMax = Math.max(0, secondPoint[0]);
+    const yMin = Math.min(b, secondPoint[1]);
+    const yMax = Math.max(b, secondPoint[1]);
+    const colorButGreen = (() => {
+        const colors = [...reds, ...oranges, ...blues, ...purples];
+        return random(colors);
+    })();
+    const commands = [
+        `l = Line[(0, ${b}), (${secondPoint[0]}, ${secondPoint[1]})]`,
+        `SetColor(l, "${colorButGreen}")`,
+        "SetFixed(l, true, false)",
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+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 getAffineVariationsFromGraphQuestion = () => {
+    const b = randint(-5, 6);
+    const secondPoint = [randint(-5, 6, [0]), randint(-5, 6)];
+    const identifiers = { b, secondPoint };
+    //[0,b] et [x,y]
+    //a = (y-b)/x
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+export const affineVariationsFromGraph = {
+    id: "affineVariationsFromGraph",
+    connector: "=",
+    label: "Lire graphiquement le sens de variation d'une fonction affine",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getAffineVariationsFromGraphQuestion(), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/affines/affineVariationsFromTwoImages.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    pointIds: PointIdentifiers[];
+};
+type Options = {
+    typeX: string;
+    typeY: string;
+};
+export declare const affineVariationsFromTwoImages: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=affineVariationsFromTwoImages.d.ts.map

package/lib/exercises/math/functions/affines/affineVariationsFromTwoImages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineVariationsFromTwoImages.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineVariationsFromTwoImages.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AA+CtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AAyMF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA+BF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkCxE,CAAC"}

package/lib/exercises/math/functions/affines/affineVariationsFromTwoImages.js

@@ -0,0 +1,259 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const createRandomNode = (numberType) => {
+    switch (numberType) {
+        case "Décimal":
+            return coinFlip()
+                ? randfloat(-100, 0, randint(1, 7), [0]).toTree()
+                : randfloat(1, 100, randint(1, 7), [1]).toTree();
+        case "Fraction": {
+            if (probaFlip(0.7)) {
+                const num = coinFlip()
+                    ? randint(10_000, 20_000)
+                    : randint(-20_000, -10_000);
+                const den = randint(1, abs(num).evaluate());
+                return frac(num, den);
+            }
+            else {
+                const num = coinFlip()
+                    ? randfloat(1, 200, randint(1, 3), [1])
+                    : randfloat(-200, -1, randint(1, 3));
+                const den = randfloat(1, abs(num).evaluate(), randint(1, 3));
+                return frac(num, den);
+            }
+        }
+        case "Réel":
+            return random([
+                PiNode,
+                frac(PiNode, randint(2, 4)),
+                sqrt(randfloat(1, 100, randint(1, 5), [1])),
+            ]);
+        case "Entier":
+        default:
+            return randint(-100, 100).toTree();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { pointIds } = identifiers;
+    const [point1, point2] = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    return `Soit $f$ une fonction affine telle que : 
+
+${alignTex([point1, point2].map((point) => [
+        `f(${point.x.toTex()})`,
+        "=",
+        point.y.toTex(),
+    ]))}
+
+Quel est le sens de variations de $f$ sur $\\mathbb{R}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { pointIds } = identifiers;
+    const [point1, point2] = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    if (NodeComparator.isEqualViaSub(point1.y, point2.y)) {
+        return "Constante";
+    }
+    else {
+        const [pointXSmall, pointXBig] = [point1, point2].toSorted((point1, point2) => point1.x.evaluate() - point2.x.evaluate());
+        return NodeComparator.compareViaSub(pointXSmall.y, pointXBig.y) === -1
+            ? "Strictement croissante"
+            : "Strictement décroissante";
+    }
+};
+const getHint = () => {
+    return `Soit $f$ une fonction affine et $x_{1}$ et $x_{2}$ deux réels distincts tels que :
+  
+$$
+x_{1}<x_{2}
+$$
+
+La fonction $f$ est 
+
+- strictement croissante si :
+
+$$
+f(x_{1})<f(x_{2})
+$$
+
+- strictement décroissante si :
+
+$$
+f(x_{1})>f(x_{2})
+$$
+
+- constante si :
+
+$$
+f(x_{1})=f(x_{2})
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { pointIds } = identifiers;
+    const [point1, point2] = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    if (NodeComparator.isEqualViaSub(point1.y, point2.y)) {
+        return `On a :
+    
+$$
+f(${point1.x.toTex()}) = f(${point2.x.toTex()}) = ${point1.y.toTex()}
+$$
+
+La fonction $f$ est donc constante sur $\\mathbb{R}$.`;
+    }
+    else {
+        const [pointXSmall, pointXBig] = [point1, point2].toSorted((point1, point2) => point1.x.evaluate() - point2.x.evaluate());
+        const valueComp = NodeComparator.compareViaSub(pointXSmall.y, pointXBig.y);
+        if (valueComp === -1) {
+            return `On a :
+
+$$
+${pointXSmall.x.toTex()} < ${pointXBig.x.toTex()}
+$$
+
+et
+
+$$
+${pointXSmall.y.toTex()} < ${pointXBig.y.toTex()}
+$$
+
+donc 
+
+$$
+f(${pointXSmall.x.toTex()}) < f(${pointXBig.x.toTex()})
+$$
+  
+
+La fonction $f$ est donc ${getAnswer(identifiers).toLocaleLowerCase()} sur $\\mathbb{R}$.`;
+        }
+        else {
+            return `On a :
+
+$$
+${pointXSmall.x.toTex()} < ${pointXBig.x.toTex()}
+$$
+
+et
+
+$$
+${pointXSmall.y.toTex()} > ${pointXBig.y.toTex()}
+$$
+
+donc 
+
+$$
+f(${pointXSmall.x.toTex()}) > f(${pointXBig.x.toTex()})
+$$
+  
+
+La fonction $f$ est donc ${getAnswer(identifiers).toLocaleLowerCase()} sur $\\mathbb{R}$.`;
+        }
+    }
+};
+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 getKeys = () => {
+    return [];
+};
+const getAffineVariationsFromTwoImagesQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const typeX1 = random(arrayedOptions.typeX);
+    const typeX2 = random(arrayedOptions.typeX);
+    const typeY1 = random(arrayedOptions.typeY);
+    const typeY2 = random(arrayedOptions.typeY);
+    const nodeX1 = createRandomNode(typeX1);
+    const nodeX2 = (() => {
+        let nodeCandidate;
+        do {
+            nodeCandidate = createRandomNode(typeX2);
+        } while (NodeComparator.isEqualViaSub(nodeCandidate, nodeX1));
+        return nodeCandidate;
+    })();
+    const nodeY1 = createRandomNode(typeY1);
+    const nodeY2 = probaFlip(0.9) ? createRandomNode(typeY2) : nodeY1;
+    const point1 = new Point("P1", nodeX1, nodeY1);
+    const point2 = new Point("P2", nodeX2, nodeY2);
+    const identifiers = {
+        pointIds: [point1, point2].map((point) => point.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;
+};
+const optsDefault = {
+    typeX: ["Entier", "Décimal"],
+    typeY: ["Entier", "Décimal"],
+};
+const options = [
+    {
+        id: "typeX",
+        label: "Types de nombres pour les antécédents",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entier", "Décimal", "Fraction", "Réel"],
+        defaultValue: optsDefault.typeX,
+    },
+    {
+        id: "typeY",
+        label: "Types de nombres pour les images",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entier", "Décimal", "Fraction", "Réel"],
+        defaultValue: optsDefault.typeY,
+    },
+];
+export const affineVariationsFromTwoImages = {
+    id: "affineVariationsFromTwoImages",
+    label: "Déterminer le sens de variations d'une fonction affine à partir des images de deux réels",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAffineVariationsFromTwoImagesQuestion(opts), nb),
+    options,
+    validateOptions: (opts) => {
+        return {
+            valid: !!(opts?.typeX &&
+                opts?.typeX.length > 0 &&
+                opts?.typeY &&
+                opts?.typeY.length > 0),
+            message: "Veuillez choisir au moins un type de nombre pour les antécédents et un type de nombre pour les images'.",
+        };
+    },
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/functions/affines/coordsOfPointOnAffineFindX.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coordsOfPointOnAffineFindX.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/coordsOfPointOnAffineFindX.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAqIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}
+{"version":3,"file":"coordsOfPointOnAffineFindX.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/coordsOfPointOnAffineFindX.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA+IF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/math/functions/affines/coordsOfPointOnAffineFindX.js

@@ -1,5 +1,6 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
 import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { Polynomial } from "../../../../math/polynomials/polynomial.js";
 import { randint } from "../../../../math/utils/random/randint.js";
@@ -64,11 +65,12 @@ const getPropositions = (n, { answer, coeffs, yValue }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     const poly = AffineConstructor.fromCoeffs(coeffs);
-    tryToAddWrongProp(propositions, `(${yValue.frenchify()}, ${poly.calculate(yValue).frenchify()})`);
-    tryToAddWrongProp(propositions, `(${yValue}, ${AffineConstructor.fromCoeffs([p, -m])
-        .calculate(yValue)
-        .frenchify()})`);
-    tryToAddWrongProp(propositions, `(${frac(add(yValue, p), m).simplify().toTex()}, ${yValue.frenchify()})`);
+    tryToAddWrongProp(propositions, new Point("A", yValue.toTree(), poly.calculate(yValue).toTree()).toCoords());
+    tryToAddWrongProp(propositions, new Point("B", yValue.toTree(), AffineConstructor.fromCoeffs([p, -m]).calculate(yValue).toTree()).toCoords());
+    tryToAddWrongProp(propositions, new Point("C", frac(add(yValue, p), m).simplify(), yValue.toTree()).toCoords());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, PointConstructor.random("A").toCoords());
+    });
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=estimateExponentialFunctionImageFromGeometricScatterplot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"estimateExponentialFunctionImageFromGeometricScatterplot.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/estimateExponentialFunctionImageFromGeometricScatterplot.ts"],"names":[],"mappings":""}

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/exponentialFunctionImage.d.ts

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