math-exercises 3.0.191 → 3.0.193

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

@@ -1,131 +1,194 @@
-import { Rational } from "../../../../math/numbers/rationals/rational.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { dollarize } from "../../../../utils/latex/dollarize.js";
 import { mdTable } from "../../../../utils/markdown/mdTable.js";
 import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercise.js";
 import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
-const getFreqStrings = (rand) => {
+const getFreqStrings = (identifiers) => {
+    const { rand, x1, x2, x3, x4 } = identifiers;
+    const total = x1 + x2 + x3 + x4;
     let freqString = "";
     let frequence = "";
+    let mainEvent = "";
+    let subEvent = "";
+    let num = 0;
+    let denum = 0;
     switch (rand) {
         case 0:
             freqString = "marginale de $A$";
             frequence = "f(A)";
+            mainEvent = "A";
+            num = x1 + x3;
+            denum = total;
             break;
         case 1:
             freqString = "marginale de $B$";
             frequence = "f(B)";
+            mainEvent = "B";
+            num = x2 + x4;
+            denum = total;
             break;
         case 2:
             freqString = "marginale de $C$";
             frequence = "f(C)";
+            mainEvent = "C";
+            num = x1 + x2;
+            denum = total;
             break;
         case 3:
             freqString = "marginale de $D$";
             frequence = "f(D)";
+            mainEvent = "D";
+            num = x3 + x4;
+            denum = total;
             break;
         case 4:
             freqString = "conditionnelle de $A$ parmi $C$";
             frequence = "f_C(A)";
+            mainEvent = "A";
+            subEvent = "C";
+            num = x1;
+            denum = x1 + x2;
             break;
         case 5:
             freqString = "conditionnelle de $A$ parmi $D$";
             frequence = "f_D(A)";
+            mainEvent = "A";
+            subEvent = "D";
+            num = x3;
+            denum = x3 + x4;
             break;
         case 6:
             freqString = "conditionnelle de $B$ parmi $C$";
             frequence = "f_C(B)";
+            mainEvent = "B";
+            subEvent = "C";
+            num = x2;
+            denum = x1 + x2;
             break;
         case 7:
             freqString = "conditionnelle de $B$ parmi $D$";
             frequence = "f_D(B)";
+            mainEvent = "B";
+            subEvent = "D";
+            num = x4;
+            denum = x3 + x4;
             break;
         case 8:
             freqString = "conditionnelle de $C$ parmi $A$";
             frequence = "f_A(C)";
+            mainEvent = "C";
+            subEvent = "A";
+            num = x1;
+            denum = x1 + x3;
             break;
         case 9:
             freqString = "conditionnelle de $C$ parmi $B$";
             frequence = "f_B(C)";
+            mainEvent = "C";
+            subEvent = "B";
+            num = x2;
+            denum = x2 + x4;
             break;
         case 10:
             freqString = "conditionnelle de $D$ parmi $A$";
             frequence = "f_A(D)";
+            mainEvent = "D";
+            subEvent = "A";
+            num = x3;
+            denum = x1 + x3;
             break;
         case 11:
             freqString = "conditionnelle de $D$ parmi $B$";
             frequence = "f_B(D)";
+            mainEvent = "D";
+            subEvent = "B";
+            num = x4;
+            denum = x2 + x4;
             break;
         default:
             throw Error("error");
     }
-    return { freqString, frequence };
+    return { freqString, frequence, mainEvent, subEvent, num, denum };
 };
-const getInstruction = ({ x1, x2, x3, x4, rand, }) => {
-    const { freqString } = getFreqStrings(rand);
+const getInstruction = (identifiers) => {
+    const { x1, x2, x3, x4 } = identifiers;
+    const { freqString } = getFreqStrings(identifiers);
     return `On considère le tableau d'effectifs suivant : 
 
 ${mdTable([
-        [" ", "$A$", "$B$"],
-        ["$C$", dollarize(x1), dollarize(x2)],
-        ["$D$", dollarize(x3), dollarize(x4)],
+        [" ", "$A$", "$B$", "Total"],
+        ["$C$", dollarize(x1), dollarize(x2), dollarize(x1 + x2)],
+        ["$D$", dollarize(x3), dollarize(x4), dollarize(x3 + x4)],
+        [
+            "Total",
+            dollarize(x1 + x3),
+            dollarize(x2 + x4),
+            dollarize(x1 + x2 + x3 + x4),
+        ],
     ])}
 
-Calculer la fréquence ${freqString}.`;
+Calculer la fréquence ${freqString} (donner la valeur exacte ou une valeur arrondie au centième).`;
 };
-const getAnswerNode = (rand, x1, x2, x3, x4) => {
-    const x = x1 + x2 + x3 + x4;
-    let answer;
-    switch (rand) {
-        case 0:
-            answer = new Rational(x1 + x3, x).simplify().toTree();
-            break;
-        case 1:
-            answer = new Rational(x2 + x4, x).simplify().toTree();
-            break;
-        case 2:
-            answer = new Rational(x1 + x2, x).simplify().toTree();
-            break;
-        case 3:
-            answer = new Rational(x3 + x4, x).simplify().toTree();
-            break;
-        case 4:
-            answer = new Rational(x1, x1 + x2).simplify().toTree();
-            break;
-        case 5:
-            answer = new Rational(x3, x3 + x4).simplify().toTree();
-            break;
-        case 6:
-            answer = new Rational(x2, x1 + x2).simplify().toTree();
-            break;
-        case 7:
-            answer = new Rational(x4, x3 + x4).simplify().toTree();
-            break;
-        case 8:
-            answer = new Rational(x1, x1 + x3).simplify().toTree();
-            break;
-        case 9:
-            answer = new Rational(x2, x2 + x4).simplify().toTree();
-            break;
-        case 10:
-            answer = new Rational(x3, x1 + x3).simplify().toTree();
-            break;
-        case 11:
-            answer = new Rational(x4, x2 + x4).simplify().toTree();
-            break;
-        default:
-            throw Error("error");
-    }
-    return answer;
+const getAnswerNode = (identifiers) => {
+    const { num, denum } = getFreqStrings(identifiers);
+    return frac(num, denum).simplify();
 };
 const getAnswer = (identifiers) => {
-    const { rand, x1, x2, x3, x4 } = identifiers;
-    const answerNode = getAnswerNode(rand, x1, x2, x3, x4);
+    const answerNode = getAnswerNode(identifiers);
     const answer = answerNode.toTex();
     return answer;
 };
+const getHint = (identifiers) => {
+    const { rand } = identifiers;
+    if (rand < 4) {
+        return `La fréquence marginale de $M$ s'obtient par le calcul : 
+    
+$$
+f(M) = \\frac{\\text{effectif total de } M}{\\text{effectif total}}
+$$`;
+    }
+    return `La fréquence conditionnelle de $M$ parmi $N$ s'obtient par le calcul : 
+    
+$$
+f_N(M) = \\frac{\\text{effectif vérifiant à la fois } M \\text{ et } N}{\\text{effectif marginal de } N}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { rand } = identifiers;
+    const { freqString, frequence, mainEvent, subEvent, num, denum } = getFreqStrings(identifiers);
+    if (rand < 4) {
+        return `La fréquence ${freqString} s'obtient par le calcul : 
+    
+$$
+${frequence} = \\frac{\\text{effectif total de } ${mainEvent}}{\\text{effectif total}}
+$$
+
+Ici, l'effectif total est $${denum.frenchify()}$, et l'effectif total de $${mainEvent}$ est $${num}$.
+    
+On a donc : 
+
+$$
+${frequence} = ${frac(num, denum).toSimplificationTex()}
+$$`;
+    }
+    return `La fréquence ${freqString} s'obtient par le calcul : 
+    
+$$
+${frequence} = \\frac{\\text{effectif vérifiant à la fois } ${mainEvent} \\text{ et } ${subEvent}}{\\text{effectif marginal de } ${subEvent}}
+$$
+
+Ici, l'effectif vérifiant à la fois $${mainEvent}$ et $${subEvent}$ est $${num}$, et l'effectif marginal de $${subEvent}$ est $${denum}$.
+    
+On a donc :
+
+$$
+${frequence} = ${frac(num, denum).toSimplificationTex()}
+$$`;
+};
 const getMarginalAndConditionalFrequency = () => {
     const [x1, x2, x3, x4] = [1, 2, 3, 4].map((_el) => randint(1, 100));
     const rand = randint(0, 12);
@@ -135,7 +198,7 @@ const getMarginalAndConditionalFrequency = () => {
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
-        startStatement: `${getFreqStrings(identifiers.rand).frequence}`,
+        startStatement: `${getFreqStrings(identifiers).frequence}`,
         answer: getAnswer(identifiers),
         keys: ["f", "cap", "underscore"],
         answerFormat: "tex",
@@ -147,6 +210,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
                 firstRowIsHeader: true,
             },
         },
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -155,15 +220,19 @@ const getPropositions = (n, { answer, x1, x2, x3, x4 }) => {
     addValidProp(propositions, answer);
     propWhile(propositions, n, () => {
         const fakeRand = randint(0, 12);
-        const answerTree = getAnswerNode(fakeRand, x1 + random([0, 1]), x2 + random([0, 1]), x3 + random([0, 1]), x4 + random([0, 1]));
+        const answerTree = getAnswerNode({
+            rand: fakeRand,
+            x1: x1 + random([0, 1]),
+            x2: x2 + random([0, 1]),
+            x3: x3 + random([0, 1]),
+            x4: x4 + random([0, 1]),
+        });
         tryToAddWrongProp(propositions, answerTree.toTex());
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { rand, x1, x2, x3, x4 }) => {
-    const answerTree = getAnswerNode(rand, x1, x2, x3, x4);
-    const texs = answerTree.toAllValidTexs({ allowFractionToDecimal: true });
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return rationalVEA(ans, answer);
 };
 export const marginalAndConditionalFrequency = {
     id: "marginalAndConditionalFrequency",
@@ -177,4 +246,5 @@ export const marginalAndConditionalFrequency = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/stats2var/buildDataTableFromScatterplot.d.ts

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

package/lib/exercises/math/probaStat/stats2var/buildDataTableFromScatterplot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildDataTableFromScatterplot.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/buildDataTableFromScatterplot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;CACd,CAAC;AA6GF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAsB/D,CAAC"}

package/lib/exercises/math/probaStat/stats2var/buildDataTableFromScatterplot.js

@@ -0,0 +1,114 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { valueTableVEA } from "../../../../exercises/vea/valueTableVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { PointConstructor } from "../../../../math/geometry/point.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getAnswerTable = (identifiers) => {
+    const { xs, ys } = identifiers;
+    return [
+        ["\\text{Temps de révision}", ...xs.map((e) => e.frenchify())],
+        ["\\text{Note}", ...ys.map((e) => e.frenchify())],
+    ];
+};
+const getInstruction = () => {
+    return `Le graphique ci-dessous donne les résultats d'une classe à un contrôle : le temps de révision (en heures) est en abscisse, et la note obtenue (sur $10$) est en ordonnée.
+
+Compléter le tableau de données associé à ce nuage de points.`;
+};
+const getHint = () => {
+    return `Lis l'abscisse et l'ordonnée de chaque point. Dans le tableau, chaque colonne correspond à un point. Classe ces points dans l'ordre croissant de leur abscisse.`;
+};
+const getCorrection = (identifiers) => {
+    const { xs, ys } = identifiers;
+    const points = xs.map((x, i) => PointConstructor.fromCoords([x, ys[i]], `P_${i}`));
+    return `On lit les coordonnées de chaque point, on trouve : 
+    
+- $${points.map((p) => p.toCoords()).join("$ \n - $")}$
+
+On entre les abscisses dans la première ligne, et les ordonnées correspondantes dans la deuxième.
+
+On obtient donc le tableau suivant :
+
+${mdTable([
+        ["Temps de révision", ...xs.map((e) => dollarize(e.frenchify()))],
+        ["Note", ...ys.map((e) => dollarize(e.frenchify()))],
+    ])}`;
+};
+const getGGBOptions = (identifiers) => {
+    const { xs, ys } = identifiers;
+    const points = xs.map((x, i) => PointConstructor.fromCoords([x, ys[i]], `P_${i}`));
+    const ggb = new GeogebraConstructor({
+        commands: [
+            ...points.flatMap((p) => p.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: false,
+                showLabel: false,
+            })),
+        ],
+    });
+    return ggb.getOptions({
+        coords: [-1, 11, -1, 11],
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    return valueTableVEA(ans, answerTable);
+};
+const getBuildDataTableFromScatterplotQuestion = () => {
+    const xs = randTupleInt(4, {
+        from: 0,
+        to: 10,
+        allDifferent: true,
+        sorted: true,
+    });
+    const ys = randTupleInt(4, {
+        from: 0,
+        to: 10,
+        allDifferent: true,
+        sorted: true,
+    });
+    const identifiers = {
+        xs,
+        ys,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        initTable: [
+            ["\\text{Temps de révision}", "", "", "", ""],
+            ["\\text{Note}", "", "", "", ""],
+        ],
+    };
+};
+export const buildDataTableFromScatterplot = {
+    id: "buildDataTableFromScatterplot",
+    label: "Construire le tableau de valeurs associé à un nuage de points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBuildDataTableFromScatterplotQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswerTable,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    answerType: "valueTable",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/stats2var/buildScatterPlotFromDataTable.d.ts

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

package/lib/exercises/math/probaStat/stats2var/buildScatterPlotFromDataTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildScatterPlotFromDataTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/buildScatterPlotFromDataTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;CACd,CAAC;AA8GF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

package/lib/exercises/math/probaStat/stats2var/buildScatterPlotFromDataTable.js

@@ -0,0 +1,110 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
+import { PointConstructor } from "../../../../math/geometry/point.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getInstruction = (identifiers) => {
+    return `On s'intéresse à l'évolution de la population de loups dans une zone protégée à partir de l'année $2000$ (année $0$). Le tableau suivant donne le nombre d'individus pour chaque année étudiée. 
+    
+${mdTable([
+        ["Année", ...identifiers.xs.map((e) => dollarize(e.frenchify()))],
+        [
+            "Nombre d'individus",
+            ...identifiers.ys.map((e) => dollarize(e.frenchify())),
+        ],
+    ])}
+
+Construire le nuage de points associé au tableau ci-dessus.`;
+};
+const getHint = () => {
+    return `Chaque colonne du tableau représente un point du nuage de points. La première ligne donne son abscisse, et la deuxième son ordonnée.`;
+};
+const getCorrection = (identifiers) => {
+    const { xs, ys } = identifiers;
+    const points = xs.map((x, i) => PointConstructor.fromCoords([x, ys[i]], `P_${i}`));
+    return `Le tableau nous donne les points suivants : 
+  
+- $${points.map((p) => p.toCoords()).join("$ \n - $")}$
+
+Il suffit ensuite de placer ces points dans la figure.
+`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { xs, ys } = identifiers;
+    const points = xs.map((x, i) => PointConstructor.fromCoords([x, ys[i]], `P_${i}`));
+    return [
+        ...points.flatMap((p) => p.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: false,
+            showLabel: false,
+        })),
+    ];
+};
+const getStudentGGBOptions = () => {
+    const ggb = new GeogebraConstructor({
+        commands: [],
+        customToolBar: toolBarConstructor({ point: true }),
+    });
+    return ggb.getOptions({
+        coords: [-1, 11, -1, 11],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const { xs, ys } = identifiers;
+    const points = xs.map((x, i) => PointConstructor.fromCoords([x, ys[i]], `P_${i}`));
+    const studentPoints = parseGGBPoints(ans)
+        .map((p) => ggbPointToCoords(p))
+        .sort((a, b) => a.x - b.x);
+    return studentPoints.every((p, i) => Math.abs(p.x - points[i].x.evaluate()) < 0.4 &&
+        Math.abs(p.y - points[i].y.evaluate()) < 0.4);
+};
+const getBuildScatterPlotFromDataTableQuestion = () => {
+    const xs = randTupleInt(4, {
+        from: 0,
+        to: 10,
+        allDifferent: true,
+        sorted: true,
+    });
+    const ys = randTupleInt(4, {
+        from: 0,
+        to: 10,
+        allDifferent: true,
+        sorted: true,
+    });
+    const identifiers = {
+        xs,
+        ys,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const buildScatterPlotFromDataTable = {
+    id: "buildScatterPlotFromDataTable",
+    label: "Construire le nuage de points associé à un tableau de données",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBuildScatterPlotFromDataTableQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/stats2var/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./averagePoint.js";
 export * from "./fineAdjustementExercise.js";
+export * from "./buildDataTableFromScatterplot.js";
+export * from "./buildScatterPlotFromDataTable.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/stats2var/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC"}

package/lib/exercises/math/probaStat/stats2var/index.js

@@ -1,2 +1,4 @@
 export * from "./averagePoint.js";
 export * from "./fineAdjustementExercise.js";
+export * from "./buildDataTableFromScatterplot.js";
+export * from "./buildScatterPlotFromDataTable.js";

package/lib/exercises/math/sequences/geometric/graph/compareGeometricReasonWithOneFromGraph.d.ts

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

package/lib/exercises/math/sequences/geometric/graph/compareGeometricReasonWithOneFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareGeometricReasonWithOneFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/compareGeometricReasonWithOneFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAiFF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAuBxE,CAAC"}

package/lib/exercises/math/sequences/geometric/graph/compareGeometricReasonWithOneFromGraph.js

@@ -0,0 +1,87 @@
+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 { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "q>1");
+    tryToAddWrongProp(propositions, "q=1");
+    tryToAddWrongProp(propositions, "0<q<1");
+    tryToAddWrongProp(propositions, "q<0");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { q } = identifiers;
+    return q > 1 ? "q>1" : "0<q<1";
+};
+const getInstruction = () => {
+    return `On donne ci-dessous le nuage de points représentant une suite géométrique $u$. 
+  
+Que peut-on dire sur la raison $q$ de cette suite ?`;
+};
+const getHint = () => {
+    return `La raison d'une suite géométrique est le nombre par lequel on multiplie un terme pour passer au suivant. 
+  
+Ici, le sens de variations de la suite te donne une indication sur ce nombre : les termes de la suite augmentent-ils en fonction du rang, ou bien diminuent-ils ?`;
+};
+const getCorrection = (identifiers) => {
+    const { q } = identifiers;
+    return `Le nuage de points de la suite $u$ montre qu'elle est ${q > 1 ? "croissante" : "décroissante"}.
+  
+Or, une suite géométrique est : 
+- croissante si et seulement si $q>1$;
+- décroissante si et seulement si $0<q<1$.
+
+Ici, on peut donc affirmer que $${getAnswer(identifiers)}$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { q, start } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [`Sequence((n, ${start}*${q}^n), n, 0, 50)`],
+        lockedAxesRatio: false,
+        gridDistance: false,
+    });
+    const max = Math.max(start, q ** 4 * start);
+    return ggb.getOptions({
+        coords: [-1, 5, Math.min(-1, -max * 0.1), 1.2 * max],
+    });
+};
+const getCompareGeometricReasonWithOneFromGraphQuestion = () => {
+    const start = randfloat(0.5, 4, 2);
+    const q = coinFlip() ? randfloat(0.1, 1, 2, [1]) : randfloat(1.1, 5, 2);
+    const identifiers = { q, start };
+    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 compareGeometricReasonWithOneFromGraph = {
+    id: "compareGeometricReasonWithOneFromGraph",
+    label: "Comparer la raison d'une suite géométrique avec $1$ à partir de son nuage de points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareGeometricReasonWithOneFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/graph/index.d.ts

@@ -1,2 +1,5 @@
-export * from "./geometricPlaceFirstPoints.js";
+export * from "./recognizeGeometricFromGraph.js";
+export * from "./plausibleGeometricSequenceExpressionFromGraph.js";
+export * from "./readGeometricExpressionFromGraph.js";
+export * from "./compareGeometricReasonWithOneFromGraph.js";
 //# sourceMappingURL=index.d.ts.map