math-exercises 3.0.157 → 3.0.158

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

@@ -0,0 +1,114 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { DecimalConstructor } from "../../../../math/numbers/decimals/decimal.js";
+import { frenchify } from "../../../../math/utils/latex/frenchify.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { pA, pB, pUnion } = identifiers;
+    return `Soient deux événements $A$ et $B$ tels que $P(A) = ${frenchify(pA)}$, $P(B) = ${frenchify(pB)}$ et $P(A\\cup B) = ${frenchify(pUnion)}$. 
+  
+Les événements $A$ et $B$ sont-ils indépendants ?`;
+};
+const getHint = () => {
+    return `Deux évènements $M$ et $N$ sont indépendants si et seulement si : 
+  
+$$
+P(M\\cap N) = P(M)\\times P(N)
+$$
+
+D'autre part, on rappelle la formule de l'union : 
+
+$$
+P(A \\cup B) = P(A) + P(B) - P(A \\cap B)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { pA, pB, pUnion } = identifiers;
+    const isInde = getAnswer(identifiers) === "Oui";
+    return `On sait que : 
+  
+$$
+P(A \\cup B) = P(A) + P(B) - P(A \\cap B)
+$$
+
+On a donc : 
+
+$$
+P(A \\cap B) = P(A) + P(B) - P(A \\cup B) = ${round(pA + pB - pUnion, 5).frenchify()}
+$$
+
+D'autre part, 
+
+$$
+P(A)\\times P(B) = ${multiply(pA, pB).toTex()} = ${round(pA * pB, 5).frenchify()}
+$$
+
+${isInde
+        ? `Puisque $P(A\\cap B) = P(A)\\times P(B)$, les évènements $A$ et $B$ sont bien indépendants.`
+        : `Puisque $P(A\\cap B) \\neq P(A)\\times P(B)$, les évènements $A$ et $B$ ne sont pas indépendants.`}
+`;
+};
+const getAnswer = (identifiers) => {
+    const { pA, pB, pUnion } = identifiers;
+    return Math.abs(pA + pB - pA * pB - pUnion) < 0.0001 ? "Oui" : "Non";
+};
+const getIndependancyQuestion = () => {
+    const pA = DecimalConstructor.random(0, 1, randint(1, 3));
+    const pB = DecimalConstructor.random(0, 1, randint(1, 3));
+    const areIndependants = coinFlip();
+    let pUnion;
+    const unionValueIfIndependants = round(pA.value + pB.value - pA.value * pB.value, 5);
+    if (areIndependants)
+        pUnion = unionValueIfIndependants;
+    else {
+        let counter = 0;
+        do {
+            counter++;
+            if (counter > 1000)
+                throw new Error("Too many iterations in independancy");
+            pUnion = DecimalConstructor.random(0, 1, randint(1, 3)).value;
+        } while ((pUnion < pA.value && pUnion < pB.value) ||
+            pUnion === unionValueIfIndependants ||
+            pUnion > pA.value + pB.value);
+    }
+    const identifiers = { pA: pA.value, pB: pB.value, pUnion };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (_n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffle(propositions);
+};
+export const independancy = {
+    id: "independancy",
+    connector: "=",
+    label: "Déterminer l'indépendance de deux événements en connaissant $P(A)$, $P(B)$ et $P(A\\cup B)$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getIndependancyQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/independancy/independancyFindCap.d.ts

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

package/lib/exercises/math/probaStat/independancy/independancyFindCap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"independancyFindCap.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/independancyFindCap.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAuFF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}

package/lib/exercises/math/probaStat/independancy/independancyFindCap.js

@@ -0,0 +1,101 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } 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 { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, add(pA, pB).simplify().toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(0, 1, randint(1, 3)).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    return multiply(pA, pB).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    return `On considère deux événements indépendants $A$ et $B$, tels que $P(A) = ${pA.toTex()}$ et $P(B) = ${pB.toTex()}$.
+  
+Déterminer $P(A\\cap B)$.`;
+};
+const getHint = () => {
+    return `Deux événements $A$ et $B$ sont indépendants si et seulement si $P(A)\\times P(B) = P(A\\cap B)$.`;
+};
+const getCorrection = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    return `Puisque $A$ et $B$ sont indépendants, alors on a :
+  
+${alignTex([
+        ["P(A\\cap B)", "=", "P(A)\\times P(B)"],
+        ["", "=", multiply(pA, pB).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIndependancyFindCapQuestion = () => {
+    const pA = randfloat(0, 1, randint(1, 3));
+    const pB = randfloat(0, 1, randint(1, 3));
+    const identifiers = {
+        pAIds: pA.toTree().toIdentifiers(),
+        pBIds: pB.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const independancyFindCap = {
+    id: "independancyFindCap",
+    connector: "=",
+    label: "Calculer l'intersection de deux événements indépendants",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIndependancyFindCapQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/independancy/independancyFindCup.d.ts

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

package/lib/exercises/math/probaStat/independancy/independancyFindCup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"independancyFindCup.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/independancyFindCup.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAuGF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}

package/lib/exercises/math/probaStat/independancy/independancyFindCup.js

@@ -0,0 +1,118 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } 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 { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, multiply(pA, pB).simplify().toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(0, 1, randint(1, 3)).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    return substract(add(pA, pB), multiply(pA, pB)).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    return `On considère deux événements indépendants $A$ et $B$, tels que $P(A) = ${pA.toTex()}$ et $P(B) = ${pB.toTex()}$.
+  
+Déterminer $P(A\\cup B)$.`;
+};
+const getHint = () => {
+    return `Deux événements $A$ et $B$ sont indépendants si et seulement si $P(A)\\times P(B) = P(A\\cap B)$.
+  
+D'autre part, on rappelle la formule de l'union :
+
+$$
+P(A \\cup B) = P(A) + P(B) - P(A \\cap B)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    const pAB = multiply(pA, pB);
+    const pABSimp = pAB.simplify();
+    return `Puisque $A$ et $B$ sont indépendants, alors on a :
+  
+${alignTex([
+        ["P(A\\cap B)", "=", "P(A)\\times P(B)"],
+        ["", "=", pAB.toTex()],
+        ["", "=", pABSimp.toTex()],
+    ])}
+
+On utilise ensuite la formule de l'union : 
+
+${alignTex([
+        ["P(A \\cup B)", "=", "P(A) + P(B) - P(A \\cap B)"],
+        ["", "=", substract(add(pA, pB), pABSimp).toTex()],
+        ["", "=", substract(add(pA, pB), pABSimp).simplify().toTex()],
+    ])}
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIndependancyFindCupQuestion = () => {
+    const pA = randfloat(0, 1, randint(1, 3));
+    const pB = randfloat(0, 1, randint(1, 3));
+    const identifiers = {
+        pAIds: pA.toTree().toIdentifiers(),
+        pBIds: pB.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const independancyFindCup = {
+    id: "independancyFindCup",
+    connector: "=",
+    label: "Calculer l'union de deux événements indépendants",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIndependancyFindCupQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,5 @@
+export * from "./independancy.js";
+export * from "./isIndependantFromDefinition.js";
+export * from "./independancyFindCap.js";
+export * from "./independancyFindCup.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from "./independancy.js";
+export * from "./isIndependantFromDefinition.js";
+export * from "./independancyFindCap.js";
+export * from "./independancyFindCup.js";

package/lib/exercises/math/probaStat/independancy/isIndependantFromDefinition.d.ts

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

package/lib/exercises/math/probaStat/independancy/isIndependantFromDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isIndependantFromDefinition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/isIndependantFromDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AA8FF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAqB7D,CAAC"}

package/lib/exercises/math/probaStat/independancy/isIndependantFromDefinition.js

@@ -0,0 +1,106 @@
+import { 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 { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pABIds, pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    const pAB = reifyAlgebraic(pABIds);
+    return Math.abs(substract(pAB, multiply(pA, pB)).evaluate()) < 0.0001
+        ? "Oui"
+        : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { pABIds, pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    const pAB = reifyAlgebraic(pABIds);
+    return `On considère deux événements $A$ et $B$ tels que $P(A)= ${pA.toTex()}$, $P(B)=${pB.toTex()}$ et $P(A\\cap B) = ${pAB.toTex()}$.
+  
+Les événements $A$ et $B$ sont-ils indépendants ?`;
+};
+const getHint = () => {
+    return `Deux événements sont indépendants si et seulement si :
+  
+$$
+P(A\\cap B) = P(A)\\times P(B)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    const isIndependant = getAnswer(identifiers) === "Oui";
+    return `Deux événements sont indépendants si et seulement si :
+  
+$$
+P(A\\cap B) = P(A)\\times P(B)
+$$
+
+Ici, on a :
+
+$$
+P(A)\\times P(B) = ${multiply(pA, pB).toSimplificationTex()}
+$$
+
+${isIndependant
+        ? `Puisque $P(A\\cap B) = P(A)\\times P(B)$, les évènements $A$ et $B$ sont bien indépendants.`
+        : `Puisque $P(A\\cap B) \\neq P(A)\\times P(B)$, les évènements $A$ et $B$ ne sont pas indépendants.`}
+`;
+};
+const getIsIndependantFromDefinitionQuestion = () => {
+    const pA = randfloat(0.1, 1, randint(1, 3));
+    const pB = randfloat(0.1, 1, randint(1, 3));
+    const isInde = coinFlip();
+    const pAB = isInde
+        ? round(pA * pB, 5)
+        : randfloat(0, Math.min(pA, pB), randint(1, 3), [round(pA * pB, 5)]);
+    const identifiers = {
+        pAIds: pA.toTree().toIdentifiers(),
+        pABIds: pAB.toTree().toIdentifiers(),
+        pBIds: pB.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const isIndependantFromDefinition = {
+    id: "isIndependantFromDefinition",
+    label: "Déterminer si deux événements sont indépendants en comparant $P(A\\cap B)$ et $P(A)\\times P(B)$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsIndependantFromDefinitionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -2,7 +2,7 @@ export * from "./conditionalProbability.js";
 export * from "./probabilityTree.js";
 export * from "./stats1var/index.js";
 export * from "./stats2var/index.js";
-export * from "./independancy.js";
+export * from "./independancy/index.js";
 export * from "./issuesCountingForCards.js";
 export * from "./probaFromTableNoContext.js";
 export * from "./probaFromTableWithContext.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,+BAA+B,CAAC"}

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

@@ -2,7 +2,7 @@ export * from "./conditionalProbability.js";
 export * from "./probabilityTree.js";
 export * from "./stats1var/index.js";
 export * from "./stats2var/index.js";
-export * from "./independancy.js";
+export * from "./independancy/index.js";
 export * from "./issuesCountingForCards.js";
 export * from "./probaFromTableNoContext.js";
 export * from "./probaFromTableWithContext.js";

package/lib/exercises/math/probaStat/randomVariable/randomVariableStandardDeviation.js

@@ -18,7 +18,7 @@ const getPropositions = (n, { answer }) => {
 const getAnswer = (identifiers) => {
     const { xValuesIds, yValuesIds } = identifiers;
     const va = new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)));
-    return round(va.getStandardDeviation().simplify().evaluate(), 2).frenchify();
+    return round(va.getStandardDeviation().evaluate(), 2).frenchify();
 };
 const getInstruction = (identifiers) => {
     const { xValuesIds, yValuesIds } = identifiers;

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headsOrTailsTwiceOutcomes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAS9B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAsNF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}
+{"version":3,"file":"headsOrTailsTwiceOutcomes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAS9B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA6NF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.js

@@ -158,6 +158,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
                 firstCellIsDivided: true,
             },
         },
+        correctionStyle: {
+            tableOptions: {
+                firstCellIsDivided: true,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: true,
+            },
+        },
     };
     return question;
 };

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headsOrTailsTwiceProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAY9B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAuLF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"headsOrTailsTwiceProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAY9B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8LF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.js

@@ -137,6 +137,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        correctionStyle: {
+            tableOptions: {
+                firstCellIsDivided: true,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: true,
+            },
+        },
     };
     return question;
 };

package/lib/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numberPoolTwiceProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAiB9B,KAAK,WAAW,GAAG;IAEjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6NF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"numberPoolTwiceProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAiB9B,KAAK,WAAW,GAAG;IAEjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAoOF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.js

@@ -171,6 +171,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        correctionStyle: {
+            tableOptions: {
+                firstCellIsDivided: true,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: true,
+            },
+        },
     };
     return question;
 };

package/lib/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"twoStepExperimentProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AA0B9B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAijBF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"twoStepExperimentProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AA0B9B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAwjBF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.js

@@ -442,6 +442,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        correctionStyle: {
+            tableOptions: {
+                firstCellIsDivided: true,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: true,
+            },
+        },
     };
     return question;
 };

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFirstTermRandom.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    firstValue: number;
+    reason: number;
+    firstRank: number;
+};
+export declare const arithmeticFindExplicitFormulaFirstTermRandom: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=arithmeticFindExplicitFormulaFirstTermRandom.d.ts.map

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFirstTermRandom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindExplicitFormulaFirstTermRandom.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFirstTermRandom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyHF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAoB5E,CAAC"}