math-exercises 3.0.78 → 3.0.80

package/lib/exercises/math/calcul/rationals/rationalNumbers.js

@@ -0,0 +1,185 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { DecimalConstructor } from "../../../../math/numbers/decimals/decimal.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { SqrtNode } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeIds } from "../../../../tree/nodes/node.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode, NumberNode, } from "../../../../tree/nodes/numbers/numberNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { frac, isFractionNode, } 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";
+const getPropositions = (n, { answer, choices }) => {
+    const propositions = [];
+    for (const choice of choices) {
+        if (!choice.irrationalUsed) {
+            addValidProp(propositions, reifyAlgebraic(choice.node).toTex());
+        }
+        else {
+            tryToAddWrongProp(propositions, reifyAlgebraic(choice.node).simplify().toTex());
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getInstruction = (identifiers) => {
+    return "Parmi ces nombres, lesquels sont rationnels ?";
+};
+const getHint = (identifiers) => {
+    return `Un nombre $n$ est rationnel s'il peut s'écrire sous la forme : 
+
+$$
+n = ${frac("a", "b").toTex()}
+$$
+
+avec $a \\in \\mathbb{Z}$ et $b \\in \\mathbb{Z}^*$.`;
+};
+const getCorrection = (identifiers) => {
+    let corrections = [];
+    for (const choice of identifiers.choices) {
+        const node = reifyAlgebraic(choice.node);
+        if (choice.irrationalUsed) {
+            const irrationalUsed = reifyAlgebraic(choice.irrationalUsed);
+            if (irrationalUsed.equals(node)) {
+                corrections.push(`- $${irrationalUsed.toTex()}$ est un nombre irrationnel.`);
+            }
+            else {
+                corrections.push(`- $${irrationalUsed.toTex()}$ est un nombre irrationnel, donc $${node
+                    .simplify()
+                    .toTex()}$ est irrationnel.`);
+            }
+        }
+        else {
+            const nodeId = node.toIdentifiers();
+            if (nodeId.id === NodeIds.fraction ||
+                (isOppositeNode(node) && isFractionNode(node.child))) {
+                corrections.push(`- $${node.toTex()}$ est un nombre rationnel car c'est une fraction de deux nombres entiers.`);
+            }
+            else if (isNumberNode(node)) {
+                corrections.push(`- $${node.toTex()}$ est un nombre rationnel car il peut être écrit sous la forme d'une fraction d'entiers :
+          
+$$
+${node.toTex()} = ${node.toFrac(false).toTex()}
+$$`);
+            }
+        }
+    }
+    return corrections.join("\n");
+};
+const getRationalNumbersQuestion = (ops) => {
+    let choices = [];
+    const knownIrrationals = [
+        PiNode,
+        new SqrtNode(new NumberNode(2)),
+        new SqrtNode(new NumberNode(3)),
+        new SqrtNode(new NumberNode(5)),
+    ];
+    let node;
+    const generateRational = () => {
+        switch (randint(0, 3)) {
+            case 0:
+                // Integer
+                do {
+                    node = new NumberNode(randint(-20, 20));
+                } while (choices.some((choice) => choice.node.toTex() === node.toTex()));
+                choices.push({
+                    node,
+                    irrationalUsed: null,
+                });
+                break;
+            case 1:
+                // Decimal
+                do {
+                    node = DecimalConstructor.random(-10, 10, 2).toTree();
+                } while (choices.some((choice) => choice.node.toTex() === node.toTex()));
+                choices.push({
+                    node,
+                    irrationalUsed: null,
+                });
+                break;
+            case 2:
+            default:
+                // Fraction
+                do {
+                    node = RationalConstructor.randomIrreductibleWithSign().toTree();
+                } while (choices.some((choice) => choice.node.toTex() === node.toTex()));
+                choices.push({
+                    node,
+                    irrationalUsed: null,
+                });
+                break;
+        }
+    };
+    const generateIrrational = () => {
+        switch (randint(0, 2)) {
+            case 0:
+                // Irrational
+                do {
+                    node = random(knownIrrationals);
+                } while (choices.some((choice) => choice.node.toTex() === node.toTex()));
+                choices.push({
+                    node,
+                    irrationalUsed: node.toIdentifiers(),
+                });
+                break;
+            case 1:
+            default:
+                let irrational;
+                do {
+                    irrational = random(knownIrrationals);
+                    node = multiply(irrational, RationalConstructor.randomPureRational(10).toTree());
+                } while (choices.some((choice) => choice.node.toTex() === node.toTex()));
+                // Irrational fraction
+                choices.push({
+                    node,
+                    irrationalUsed: irrational.toIdentifiers(),
+                });
+                break;
+        }
+    };
+    // Generer au moins un choix rationnel et un choix irrationnel
+    generateRational();
+    generateIrrational();
+    for (let i = 0; i < 2; i++) {
+        coinFlip() ? generateRational() : generateIrrational();
+    }
+    const identifiers = {
+        choices: choices.map((c) => {
+            return {
+                node: c.node.toIdentifiers(),
+                irrationalUsed: c.irrationalUsed,
+            };
+        }),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const rationalNumbers = {
+    id: "rationalNumbers",
+    label: "Dire si un nombre est rationnel",
+    answerType: "QCM",
+    isQCM: true,
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRationalNumbersQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/dataRepresentations/index.js

@@ -5,3 +5,4 @@ export * from "./pieChartReading.js";
 // export * from "./testGen.js";
 // export * from "./testGenGGB.js";
 // export * from "./testGenStudentGGB.js";
+// export * from "./testGGB.js";

package/lib/exercises/math/probaStat/averageLinearity.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Operators = "multiplication" | "division" | "soustraction" | "addition";
+type Identifiers = {
+    kind: "factor";
+    a: number;
+    operator: Operators;
+    factor: number;
+} | {
+    kind: "series";
+    series: number[];
+    operator: Operators;
+    factor: number;
+};
+export declare const averageLinearity: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=averageLinearity.d.ts.map

package/lib/exercises/math/probaStat/averageLinearity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"averageLinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/averageLinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAarC,KAAK,SAAS,GAAG,gBAAgB,GAAG,UAAU,GAAG,cAAc,GAAG,UAAU,CAAC;AAC7E,KAAK,WAAW,GACZ;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB,GACD;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmON,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAkBlD,CAAC"}

package/lib/exercises/math/probaStat/averageLinearity.js

@@ -0,0 +1,217 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { divide } from "../../../tree/nodes/operators/divideNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const moyenne = isSeriesQuestion(identifiers)
+        ? (identifiers.series[0] +
+            identifiers.series[1] +
+            identifiers.series[2] +
+            identifiers.series[3]) /
+            4
+        : identifiers.a;
+    const { operator, factor } = identifiers;
+    switch (operator) {
+        case "addition":
+            tryToAddWrongProp(propositions, (moyenne + factor + 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne + factor - 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne + factor + factor).frenchify());
+            tryToAddWrongProp(propositions, (moyenne + factor - 2).frenchify());
+            break;
+        case "soustraction":
+            tryToAddWrongProp(propositions, (moyenne - factor + 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne - factor - 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne - factor - factor).frenchify());
+            tryToAddWrongProp(propositions, (moyenne - factor - 2).frenchify());
+            break;
+        case "multiplication":
+            tryToAddWrongProp(propositions, (moyenne * factor + 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne * factor - 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne * factor + 2).frenchify());
+            tryToAddWrongProp(propositions, (moyenne * factor - 2).frenchify());
+            break;
+        case "division":
+            tryToAddWrongProp(propositions, frac(moyenne + 1, factor).toTex());
+            tryToAddWrongProp(propositions, frac(moyenne - 1, factor).toTex());
+            tryToAddWrongProp(propositions, frac(moyenne, factor + 1).toTex());
+            tryToAddWrongProp(propositions, frac(moyenne, factor - 1).toTex());
+            break;
+    }
+    return shuffleProps(propositions, n);
+};
+const isSeriesQuestion = (identifiers) => {
+    return identifiers.kind === "series";
+};
+const getAnswer = (identifiers) => {
+    const moyenne = isSeriesQuestion(identifiers)
+        ? (identifiers.series[0] +
+            identifiers.series[1] +
+            identifiers.series[2] +
+            identifiers.series[3]) /
+            4
+        : identifiers.a;
+    const { operator, factor } = identifiers;
+    switch (operator) {
+        case "addition":
+            return add(moyenne, factor).simplify().toTex();
+        case "soustraction":
+            return substract(moyenne, factor).simplify().toTex();
+        case "multiplication":
+            return multiply(moyenne, factor).simplify().toTex();
+        case "division":
+        default:
+            return frac(moyenne, factor).simplify().toTex();
+    }
+};
+const getInstruction = (identifiers) => {
+    if (isSeriesQuestion(identifiers)) {
+        const { series: [a, b, c, d], operator, factor, } = identifiers;
+        let factorResult = (x) => {
+            switch (operator) {
+                case "addition":
+                    return x + factor;
+                case "soustraction":
+                    return x - factor;
+                case "multiplication":
+                    return x * factor;
+                case "division":
+                default:
+                    return x / factor;
+            }
+        };
+        return `La moyenne de la série ${[a, b, c, d]
+            .map((x) => `$${x.frenchify()}$`)
+            .join(" ; ")} vaut $${((a + b + c + d) / 4).frenchify()}$. 
+    
+Que vaut la moyenne de la série ${[a, b, c, d]
+            .map((x) => `$${factorResult(x).frenchify()}$`)
+            .join(" ; ")} ?`;
+    }
+    else {
+        const { a, operator, factor } = identifiers;
+        const text = operator === "division"
+            ? "divisées par"
+            : operator === "multiplication"
+                ? "multipliées par"
+                : operator === "soustraction"
+                    ? "diminuées de"
+                    : "augmentées de";
+        return `La moyenne d'une série statistique vaut $${a.frenchify()}$. Calculer la nouvelle moyenne de la série si toutes ses valeurs sont ${text} $${factor.frenchify()}$.`;
+    }
+};
+const getHint = (identifiers) => {
+    return `Si on effectue une ${identifiers.operator} sur toutes les valeurs d'une série par un nombre $a$, alors la nouvelle moyenne de la série est obtenue en faisant une ${identifiers.operator} par ce même nombre sur la moyenne précédente.`;
+};
+const getCorrection = (identifiers) => {
+    const moyenne = isSeriesQuestion(identifiers)
+        ? (identifiers.series[0] +
+            identifiers.series[1] +
+            identifiers.series[2] +
+            identifiers.series[3]) /
+            4
+        : identifiers.a;
+    const { operator, factor } = identifiers;
+    let latexFormula = "";
+    switch (operator) {
+        case "addition":
+            latexFormula = `${add(moyenne, factor).toTex()} = ${(moyenne + factor).frenchify()}`;
+            break;
+        case "soustraction":
+            latexFormula = `${substract(moyenne, factor).toTex()} = ${(moyenne - factor).frenchify()}`;
+            break;
+        case "multiplication":
+            latexFormula = `${multiply(moyenne, factor).toTex()} = ${(moyenne * factor).frenchify()}`;
+            break;
+        case "division":
+        default:
+            latexFormula = `${divide(moyenne, factor).toTex()} = ${frac(moyenne, factor).toTex()}`;
+            break;
+    }
+    return `Il y a eu une ${operator} de $${factor.frenchify()}$ sur les valeurs de la série, donc la moyenne devient :
+    
+$$
+${latexFormula}
+$$`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getAverageLinearityQuestion = (ops) => {
+    const isSeries = coinFlip();
+    if (isSeries) {
+        const a = randint(1, 10);
+        const b = randint(10, 20);
+        const c = randint(20, 30);
+        const d = randint(30, 40);
+        const operator = random([
+            "multiplication",
+            "division",
+            "soustraction",
+            "addition",
+        ]);
+        const factor = randint(2, 5);
+        const identifiers = {
+            kind: "series",
+            series: [a, b, c, d],
+            operator,
+            factor,
+        };
+        return getQuestionFromIdentifiers(identifiers);
+    }
+    else {
+        const a = randint(2, 20);
+        const operator = random([
+            "multiplication",
+            "division",
+            "soustraction",
+            "addition",
+        ]);
+        const factor = randint(2, 10, [a, 7, 9]);
+        const identifiers = { kind: "factor", a, operator, factor };
+        return getQuestionFromIdentifiers(identifiers);
+    }
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const averageLinearity = {
+    id: "averageLinearity",
+    label: "Calculer la moyenne d'une série à partir de la moyenne d'une autre série en utilisant la linéarité de la moyenne",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAverageLinearityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/cumulativeSum.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    xVals: number[];
+    yVals: number[];
+    x: number;
+};
+export declare const cumulativeSum: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=cumulativeSum.d.ts.map

package/lib/exercises/math/probaStat/cumulativeSum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cumulativeSum.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/cumulativeSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4GF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}

package/lib/exercises/math/probaStat/cumulativeSum.js

@@ -0,0 +1,105 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { AddNode } from "../../../tree/nodes/operators/addNode.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { dollarize } from "../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { xVals, yVals, x } = identifiers;
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `${xVals[x]}`);
+    tryToAddWrongProp(propositions, `${xVals[x]}`);
+    for (let k = 0; k < yVals.length; k++) {
+        let sum = 0;
+        for (let i = 0; i <= k; i++) {
+            sum += yVals[i];
+        }
+        tryToAddWrongProp(propositions, `${sum}`);
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { yVals, x } = identifiers;
+    let sum = 0;
+    for (let i = 0; i <= x; i++) {
+        sum += yVals[i];
+    }
+    return `${sum}`;
+};
+const getInstruction = (identifiers) => {
+    const { xVals, yVals, x } = identifiers;
+    return `On considère la série statistique suivante :
+  
+${mdTable([
+        ["Valeur", ...xVals.map((x) => dollarize(x))],
+        ["Effectif", ...yVals.map((y) => dollarize(y))],
+    ])}
+
+Calculez l'effectif cumulé croissant de la valeur $${xVals[x]}$.
+`;
+};
+const getHint = (identifiers) => {
+    return `L'effectif cumulé croissant d'une valeur correspond à la somme des effectifs des valeurs inférieures ou égales à cette valeur`;
+};
+const getCorrection = (identifiers) => {
+    const { xVals, yVals, x } = identifiers;
+    let sum = 0;
+    for (let i = 0; i <= x; i++) {
+        sum += yVals[i];
+    }
+    return `L'effectif cumulé croissant de $${xVals[x]}$ correspond à la somme des effectifs des valeurs inférieures ou égales à $${xVals[x]}$ :
+  
+$$
+${x > 0
+        ? `${operatorComposition(AddNode, yVals.slice(0, x + 1).map((e) => e.toTree())).toTex()} = ${sum}`
+        : `${sum}`}
+$$`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getCumulativeSumQuestion = (ops) => {
+    let xVals = [randint(1, 10)];
+    let yVals = [randint(1, 10, xVals)];
+    for (let i = 1; i < randint(3, 6); i++) {
+        xVals.push(xVals[i - 1] + randint(1, 10));
+        yVals.push(yVals[i - 1] + randint(1, 10));
+    }
+    const identifiers = {
+        xVals,
+        yVals,
+        x: randint(1, xVals.length),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const cumulativeSum = {
+    id: "cumulativeSum",
+    label: "Calculer des effectifs cumulés croissants",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCumulativeSumQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/describeEvent.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    eventA: {
+        desc: string;
+        isComplementary: boolean;
+    };
+    eventB: {
+        desc: string;
+        isComplementary: boolean;
+    };
+    question: "union" | "intersection" | "comp";
+};
+export declare const describeEvent: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=describeEvent.d.ts.map

package/lib/exercises/math/probaStat/describeEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describeEvent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/describeEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;IACF,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;IACF,QAAQ,EAAE,OAAO,GAAG,cAAc,GAAG,MAAM,CAAC;CAC7C,CAAC;AA0LF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}