math-exercises 3.0.190 → 3.0.192

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/sequences/geometric/geometricFindNextTermFromTwoConsecutiveTerms.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    precisionInitial: number;
+    precisionReason: number;
+};
+export declare const geometricFindNextTermFromTwoConsecutiveTerms: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricFindNextTermFromTwoConsecutiveTerms.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindNextTermFromTwoConsecutiveTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindNextTermFromTwoConsecutiveTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AA2OF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAmB5E,CAAC"}

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

@@ -0,0 +1,217 @@
+import { addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { rank1, value1, rank2, value2 } = identifiers;
+    const rankAsked = round(rank2 + 1, 0);
+    return `Soit $u$ une suite géométrique telle que $u_{${rank1.frenchify()}} = ${value1.frenchify()}$ et $u_{${rank2.frenchify()}} = ${value2.frenchify()}$. 
+  
+Que vaut $u_{${rankAsked.frenchify()}}$ ?`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { value1, value2 } = identifiers;
+    const nodeReason = frac(value2, value1).simplify({ towardsDistribute: true });
+    const nodeAnswer = multiply(value2, nodeReason);
+    return {
+        nodeReason,
+        nodeAnswer,
+    };
+};
+const getAnswer = (identifiers) => {
+    return getAnswerStuff(identifiers)
+        .nodeAnswer.simplify({ towardsDistribute: true })
+        .toTex();
+};
+const getHint = (identifiers, _optsIn) => {
+    const { rank2 } = identifiers;
+    const rankAsked = round(rank2 + 1, 0);
+    return `Commence par déterminer la raison $q$ de la suite $u$. 
+  
+Puis, utilise cette raison et un des termes connus de la suite pour déterminer $u_{${rankAsked.frenchify()}}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { rank1, value1, rank2, value2 } = identifiers;
+    const rankAsked = round(rank2 + 1, 0);
+    const { nodeReason, nodeAnswer } = getAnswerStuff(identifiers);
+    return `On commence par déterminer la raison $q$ de la suite $u$.
+
+On a :
+
+${alignTex([
+        ["q", "=", `\\frac{u_{${rank2}}}{u_{${rank1}}}`],
+        ["", "=", `\\frac{${value2.frenchify()}}{${value1.frenchify()}}`],
+        ["", "=", `${nodeReason.toTex()}`],
+    ])}
+
+On peut alors déterminer $u_{${rankAsked.frenchify()}}$ en utilisant $u_{${rank2.frenchify()}}$ et $q$. En effet, on a : 
+
+${alignTex([
+        [
+            `u_{${rankAsked.frenchify()}}`,
+            "=",
+            `u_{${rank2.frenchify()}} \\ \\times \\ q`,
+        ],
+        ["", "=", nodeAnswer.toTex()],
+        ["", "=", nodeAnswer.simplify({ towardsDistribute: true }).toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ..._identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiersCurated();
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiersRaw = () => {
+    const isDivergent = coinFlip();
+    const isReasonNegative = coinFlip();
+    const signReason = isReasonNegative ? -1 : +1;
+    function createGeometricDivergent() {
+        const precisionInitial = 1;
+        const initial = randfloat(1, 10, precisionInitial, [1]);
+        const precisionReason = 0;
+        const reason = signReason * randint(2, 10);
+        return [initial, precisionInitial, reason, precisionReason];
+    }
+    function createGeometricConvergent() {
+        const poolReasonStuff = [
+            {
+                q: 0.5,
+                precision: 1,
+                invQ: 2,
+            },
+            {
+                q: 0.25,
+                precision: 2,
+                invQ: 4,
+            },
+            {
+                q: 0.2,
+                precision: 1,
+                invQ: 5,
+            },
+            {
+                q: 0.1,
+                precision: 1,
+                invQ: 10,
+            },
+            {
+                q: 0.05,
+                precision: 2,
+                invQ: 20,
+            },
+        ];
+        const { q, invQ, precision: precisionReason } = random(poolReasonStuff);
+        const reason = signReason * q;
+        const precisionInitial = 0;
+        const initial = round(randint(10, 20) * Math.pow(invQ, 8), precisionInitial);
+        return [initial, precisionInitial, reason, precisionReason];
+    }
+    const [initial, precisionInitial, reason, precisionReason] = (() => {
+        if (isDivergent) {
+            return createGeometricDivergent();
+        }
+        else {
+            return createGeometricConvergent();
+        }
+    })();
+    const rank1 = randint(1, 5);
+    const rank2 = rank1 + 1;
+    const rankAsked = rank2 + 1;
+    function valueForRank(initial, reason, rank) {
+        return initial * Math.pow(reason, rank);
+    }
+    const [value1, value2] = [rank1, rank2].map((rank) => round(valueForRank(initial, reason, rank), 4));
+    const identifiers = {
+        rank1,
+        value1,
+        rank2,
+        value2,
+        precisionInitial,
+        precisionReason,
+        rankAsked,
+    };
+    return identifiers;
+};
+const createRandomIdentifiersCurated = () => {
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiersRaw();
+        getAnswerStuff(identifiersCandidate);
+        const answer = getAnswer(identifiersCandidate);
+        isValid = !answer.includes("NaN");
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        //2.5 * 2^n
+        const identifiersDefault = {
+            rank1: 2,
+            value1: 10,
+            rank2: 5,
+            value2: 40,
+            precisionInitial: 1,
+            precisionReason: 0,
+        };
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getGeometricFindNextTermFromTwoConsecutiveTermsQuestion = () => {
+    const identifiers = createRandomIdentifiersCurated();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+export const geometricFindNextTermFromTwoConsecutiveTerms = {
+    id: "geometricFindNextTermFromTwoConsecutiveTerms",
+    connector: "=",
+    label: "Connaissant deux termes consécutifs d'une suite géométrique, calculer le terme suivant",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindNextTermFromTwoConsecutiveTermsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../exercises/options/optionFirstTermRankOne.js";
+type Identifiers = {
+    reason: number;
+    firstValue: number;
+};
+type Options = OptionFirstTermRankOne;
+export declare const geometricFindRecurrenceFormula: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricFindRecurrenceFormula.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindRecurrenceFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindRecurrenceFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAgB3D,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAuNF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBzE,CAAC"}