math-exercises 3.0.114 → 3.0.116

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    arrayOfNodeIds: NodeIdentifiers[];
+    isFilterPossibleProba: boolean;
+};
+type Options = {
+    numberTypes: string[];
+    nbValues: number;
+};
+export declare const possibleValuesForProba: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=possibleValuesForProba.d.ts.map

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"possibleValuesForProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/possibleValuesForProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AAkHF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAgNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.js

@@ -0,0 +1,293 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.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 { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getAnswer = (identifiers) => {
+    const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
+    const arrayOfPossibleProbas = arrayOfNodeIds
+        .map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds))
+        .filter((node) => {
+        return isFilterPossibleProba
+            ? node.evaluate() >= 0 && substract(node, 1).evaluate() <= 0
+            : node.evaluate() < 0 || substract(node, 1).evaluate() > 0;
+    })
+        .toSorted((nodeA, nodeB) => substract(nodeA, nodeB).evaluate());
+    const answer = arrayOfPossibleProbas.map((node) => node.toTex()).join(";");
+    return answer;
+};
+const getInstruction = (identifiers) => {
+    const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
+    const arrNode = arrayOfNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Parmi les valeurs de la liste ci-dessous, donner celles qui sont des valeurs ${isFilterPossibleProba ? "possibles" : "impossibles"} pour une probabilité
+(séparer les valeurs par des points-virgules) : 
+$$
+${arrNode.map((node) => node.toTex()).join(" \\hspace{2mm} ; \\hspace{2mm} ")}
+$$
+`;
+};
+const getHint = () => {
+    return "Une probabilité est toujours comprise entre $0\\%$ et $100\\%$.";
+};
+const getCorrection = (identifiers) => {
+    return `Les valeurs possibles pour une probabilité sont comprises entre $0$ inclus et $1$ inclus.
+La liste à constituer était donc : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
+    const propositions = [];
+    // addValidProp(propositions, answer);
+    const allProbas = arrayOfNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const possibleNodes = allProbas.filter((node) => node.evaluate() >= 0 && substract(node, 1).evaluate() <= 0);
+    const impossibleNodes = allProbas.filter((node) => node.evaluate() < 0 || substract(node, 1).evaluate() > 0);
+    const validNodes = isFilterPossibleProba ? possibleNodes : impossibleNodes;
+    //we keep the order of the question
+    addValidProp(propositions, validNodes.map((node) => node.toTex()).join(" ; "));
+    while (propositions.length < n) {
+        const pickedNodes = allProbas.filter(coinFlip);
+        tryToAddWrongProp(propositions, pickedNodes.map((node) => node.toTex()).join(" ; "));
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const ansWithoutTrailingSemicolon = ans.slice(-1) === ";" ? ans.slice(0, -1) : ans;
+    const arrTex = ansWithoutTrailingSemicolon.split(";");
+    const arrNode = arrTex
+        .map((tex) => parseLatex(tex))
+        .toSorted((nodeA, nodeB) => substract(nodeA, nodeB).evaluate());
+    const arrTexSorted = arrNode.map((node) => node.toTex());
+    const ansRefined = arrTexSorted.join(";");
+    return ansRefined === answer;
+};
+const getKeys = (identifiers) => {
+    const { arrayOfNodeIds } = identifiers;
+    const arrNode = arrayOfNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return [
+        "semicolon",
+        ...arrNode.map((node) => {
+            return {
+                id: "custom",
+                label: node.toTex(),
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: node.toTex(),
+                },
+            };
+        }),
+    ];
+};
+const optsDefault = {
+    numberTypes: ["Entier", "Décimal", "Fraction", "Puiss10", "Sci", "Réel"],
+    nbValues: 8,
+};
+const options = [
+    {
+        id: "numberTypes",
+        label: "Types de nombres",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["Entier", "Décimal", "Fraction", "Puiss10", "Sci", "Réel"],
+        defaultValue: optsDefault.numberTypes,
+    },
+    {
+        id: "nbValues",
+        label: "Longueur de la liste",
+        type: GeneratorOptionType.select,
+        target: GeneratorOptionTarget.generation,
+        values: [5, 6, 7, 8, 9, 10],
+        defaultValue: optsDefault.nbValues,
+    },
+];
+const createRandomNode = (numberType, isPossibleProba) => {
+    if (isPossibleProba) {
+        switch (numberType) {
+            case "Décimal":
+                return randfloat(0, 1, randint(1, 7)).toTree();
+            case "Fraction": {
+                if (probaFlip(0.7)) {
+                    const num = randint(0, 10_000);
+                    const den = randint(num, 20_000);
+                    return frac(num, den);
+                }
+                else {
+                    const num = randfloat(0, 100, randint(1, 3));
+                    const den = randfloat(100, 200, randint(1, 3));
+                    return frac(num, den);
+                }
+            }
+            case "Puiss10":
+                return power(10, randint(-15, 1));
+            case "Sci":
+                if (probaFlip(0.7)) {
+                    return multiply(randfloat(1, 10, randint(1, 5)), power(10, randint(-15, 0)));
+                }
+                else {
+                    return multiply(randint(1, 10), power(10, randint(-15, 0)));
+                }
+            case "Réel":
+                return random([
+                    frac(PiNode, randint(4, 14)),
+                    sin(randfloat(0, PiNode.value, 2)),
+                    cos(randfloat(-frac(PiNode, 2).evaluate(), frac(PiNode, 2).evaluate(), 2)),
+                    exp(randint(-10, 0)),
+                    sqrt(randfloat(0, 1)),
+                ]);
+            case "Entier":
+            default:
+                return randint(0, 2).toTree();
+        }
+    }
+    else {
+        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(0, 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 "Puiss10":
+                return power(10, randint(1, 15));
+            case "Sci":
+                if (probaFlip(0.7)) {
+                    return coinFlip()
+                        ? multiply(randfloat(1, 10, randint(1, 5), [1]), power(10, randint(0, 15)))
+                        : multiply(randfloat(-10, -1, randint(1, 5), [-10]), power(10, randint(0, 15)));
+                }
+                else {
+                    return coinFlip()
+                        ? multiply(randint(2, 10), power(10, randint(0, 15)))
+                        : multiply(randint(-10, -1, [-10]), power(10, randint(0, 15)));
+                }
+            case "Réel":
+                return random([
+                    PiNode,
+                    frac(PiNode, randint(2, 4)),
+                    exp(randint(1, 10)),
+                    sqrt(randfloat(1, 100, randint(1, 5), [1])),
+                ]);
+            case "Entier":
+            default:
+                return randint(-100, 100, [0, 1]).toTree();
+        }
+    }
+};
+const getPossibleValuesForProbaQuestion = (optsIn) => {
+    const opts = Object.assign(optsDefault, optsIn) ?? optsDefault;
+    const isFilterPossibleProba = coinFlip();
+    //create numberType list
+    const dictNumberTypeToPriority = {
+        Entier: 1,
+        Puiss10: 2,
+        Décimal: 3,
+        Fraction: 4,
+        Réel: 5,
+    };
+    let arrNumberType = [...opts.numberTypes];
+    //filler
+    while (arrNumberType.length < opts.nbValues) {
+        arrNumberType.push(...shuffle(opts.numberTypes));
+    }
+    arrNumberType = arrNumberType
+        .slice(0, opts.nbValues)
+        .toSorted((numberType1, numberType2) => dictNumberTypeToPriority[numberType1] -
+        dictNumberTypeToPriority[numberType2]);
+    //create list
+    let arrNode = [];
+    const arrIsPossibleProba = [];
+    let is0And1AlreadyPicked = false;
+    for (let i = 0; i < arrNumberType.length; i++) {
+        const numberType = arrNumberType[i];
+        //ensure answer is neither an empty list, nor the whole list
+        const isLast = i === arrNumberType.length - 1;
+        const isPossibleProba = numberType === "Entier" && is0And1AlreadyPicked
+            ? false
+            : isLast &&
+                (arrIsPossibleProba.every((b) => b) ||
+                    arrIsPossibleProba.every((b) => !b))
+                ? !arrIsPossibleProba[0]
+                : coinFlip();
+        arrIsPossibleProba.push(isPossibleProba);
+        //ensure distinct values
+        let nodeCandidate;
+        let isAlreadyInList = true;
+        do {
+            nodeCandidate = createRandomNode(numberType, isPossibleProba);
+            isAlreadyInList = arrNode
+                .map((node) => node.evaluate())
+                .includes(nodeCandidate.evaluate());
+        } while (isAlreadyInList);
+        arrNode.push(nodeCandidate);
+        is0And1AlreadyPicked ||=
+            arrNode.map((node) => node.evaluate()).filter((v) => v === 0 || v === 1)
+                .length === 2;
+    }
+    arrNode = shuffle(arrNode);
+    const identifiers = {
+        arrayOfNodeIds: arrNode.map((node) => node.toIdentifiers()),
+        isFilterPossibleProba,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const possibleValuesForProba = {
+    id: "possibleValuesForProba",
+    label: "Déterminer les valeurs possibles pour une probabilité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPossibleValuesForProbaQuestion(opts), nb, 30),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    hasHintAndCorrection: true,
+};