math-exercises 3.0.52 → 3.0.53

package/lib/exercises/math/geometry/vectors/lineFromDirectorVector.js

@@ -1,109 +1,150 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { Line } from "../../../../math/geometry/line.js";
+import { Line, LineConstructor } from "../../../../math/geometry/line.js";
 import { Point, PointConstructor } from "../../../../math/geometry/point.js";
 import { Vector } from "../../../../math/geometry/vector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
-import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
-import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
-import { VariableNode } from "../../../../tree/nodes/variables/variableNode.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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { aX, aY, uX, uY } = identifiers;
+    const u = new Vector("u", uX.toTree(), uY.toTree());
+    const A = new Point("A", aX, aY);
+    const instruction = `Soit $d$ une droite de vecteur directeur $${u.toTexWithCoords()}$ passant par le point $${A.toTexWithCoords()}$. 
+  
+Déterminer l'équation réduite de la droite $d$.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { aX, aY, uX, uY } = identifiers;
+    const A = new Point("A", aX, aY);
+    const B = new Point("B", add(aX, uX).simplify(), add(aY, uY).simplify());
+    const line = new Line(A, B);
+    const correctAnswer = line.getReductEquation().simplify({
+        decimalToFractions: true,
+        forbidFactorize: true,
+        towardsDistribute: true,
+        forceDistributeFractions: true,
+    });
+    return correctAnswer.toTex();
+};
+const getHint = (identifiers) => {
+    return `On cherche d'abord le coefficient directeur $a$ : pour cela, on cherche un vecteur colinéaire à $\\overrightarrow{u}$ d'abscisse $1$. L'ordonnée de ce vecteur est alors le coefficient directeur de $d$.
+  
+Puis, on détermine l'ordonnée à l'origine $b$ en utilisant le fait que le point $A$ appartient à $d$.`;
+};
+const getCorrection = (identifiers) => {
+    const { aX, aY, uX, uY } = identifiers;
+    const u = new Vector("u", uX.toTree(), uY.toTree());
+    const A = new Point("A", aX, aY);
+    const unit = u.toUnited();
+    const xMonom = multiply(unit.y, A.x);
+    const xMonomSimp = xMonom.simplify({ forceDistributeFractions: true });
+    return `Puisque $${u.toTexWithCoords()}$ est un vecteur directeur de $d$, tout vecteur colinéaire à $${u.toTex()}$ est également un vecteur directeur de $d$. 
+  
+Le vecteur de coordonnées $${unit
+        .toBinomCoords()
+        .toTex()}$ est donc un vecteur directeur de $d$. On en déduit que le coefficient directeur de $d$ est $${unit.y.toTex()}$.
+
+L'équation réduite de la droite $d$ est donc de la forme :
+
+$$
+y = ${multiply(unit.y, "x")
+        .simplify({ forceDistributeFractions: true })
+        .toTex()}+b
+$$
+
+On utilise alors les coordonnées de $${A.toTexWithCoords()}$ pour déterminer $b$ :
+
+${alignTex([
+        [A.y.toTex(), "=", `${xMonom.toTex()} + b`],
+        [A.y.toTex(), "=", `${xMonomSimp.toTex()} + b`],
+        ["b", "=", substract(A.y, xMonomSimp).toTex()],
+        ["b", "=", substract(A.y, xMonomSimp).simplify({}).toTex()],
+    ])}
+
+L'équation réduite de la droite $d$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
 const getLineFromDirectorVectorQuestion = () => {
     const a = PointConstructor.random("A");
-    const u = new Vector("u", new NumberNode(randint(-10, 11, [0])), new NumberNode(randint(-10, 11, [0])));
-    const b = new Point("b", new NumberNode(a.getXnumber() - u.getXAsNumber()), new NumberNode(a.getYnumber() - u.getYAsNumber()));
-    const line = new Line(b, a);
-    const correctAnswer = line.getEquation(u, a);
-    const instruction = `Soit $d$ une droite de vecteur directeur $${u.toTexWithCoords()}$ passant par le point $${a.toTexWithCoords()}$. Déterminer l'équation réduite de la droite $d$.`;
+    const u = new Vector("u", new NumberNode(randint(-10, 11, [0, 1])), new NumberNode(randint(-10, 11)));
+    const identifiers = {
+        uX: u.getXAsNumber(),
+        uY: u.getYAsNumber(),
+        aX: a.getXnumber(),
+        aY: a.getYnumber(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: correctAnswer.toTex(),
-        instruction: instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["x", "y", "equal"],
         answerFormat: "tex",
-        identifiers: {
-            uX: u.getXAsNumber(),
-            uY: u.getYAsNumber(),
-            aX: a.getXnumber(),
-            aY: a.getYnumber(),
-        },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
 const getPropositions = (n, { answer, uX, uY, aX, aY }) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    generatePropositions(uX, uY, aX, aY).forEach((value) => tryToAddWrongProp(propositions, value.toTex()));
-    let uXRand;
-    let uYRand;
     while (propositions.length < n) {
-        uXRand = randint(-10, 11, [0, uX]);
-        uYRand = randint(-10, 11, [0, uY]);
-        tryToAddWrongProp(propositions, getCorrecAnswer(uXRand, uYRand, aX, aY).toTex());
+        const line = LineConstructor.random();
+        tryToAddWrongProp(propositions, line
+            .getReductEquation()
+            .simplify({
+            decimalToFractions: true,
+            forbidFactorize: true,
+            towardsDistribute: true,
+            forceDistributeFractions: true,
+        })
+            .toTex());
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { uX, uY, aX, aY }) => {
-    const correctAnswer = getCorrecAnswer(uX, uY, aX, aY);
-    return correctAnswer
-        .toAllValidTexs({
-        allowRawRightChildAsSolution: true,
-        allowFractionToDecimal: true,
-    })
-        .includes(ans);
-};
-const generatePropositions = (uX, uY, aX, aY) => {
-    const y = new VariableNode("y");
-    const x = new VariableNode("x");
-    const uXNode = new NumberNode(uX);
-    const uYNode = new NumberNode(uY);
-    const aYNode = new NumberNode(aY);
-    const aXNode = new NumberNode(aX);
-    const firstProposition = getFirstProposition(y, x, uXNode, uYNode, aYNode, aXNode);
-    const secondProposition = getSecondProposition(y, x, uXNode, uYNode, aXNode, aYNode);
-    return [firstProposition, secondProposition];
-};
-const getFirstProposition = (y, x, uX, uY, aX, aY) => {
-    const uYDivuX = new FractionNode(uY, uX).simplify();
-    const natural = uY.value % uX.value === 0;
-    const aYuX = new MultiplyNode(aY, uX).simplify();
-    const aXuY = new MultiplyNode(aX, uY).simplify();
-    const rightSide = new AddNode(natural
-        ? new MultiplyNode(uYDivuX, x).simplify()
-        : new MultiplyNode(uYDivuX, x), new FractionNode(new SubstractNode(aXuY, aYuX).simplify(), uX).simplify());
-    const equation = new EqualNode(y, rightSide);
-    return equation;
-};
-const getSecondProposition = (y, x, uX, uY, aX, aY) => {
-    const uYDivuX = new FractionNode(uX, uY).simplify();
-    const natural = uX.value % uY.value === 0;
-    const aYuX = new MultiplyNode(aY, aX).simplify();
-    const aXuY = new MultiplyNode(uX, uY).simplify();
-    const rightSide = new AddNode(natural
-        ? new MultiplyNode(uYDivuX, x).simplify()
-        : new MultiplyNode(uYDivuX, x), new SubstractNode(aYuX, aXuY).simplify());
-    const equation = new EqualNode(y, rightSide);
-    return equation;
-};
-const getCorrecAnswer = (uX, uY, aX, aY) => {
-    const a = new Point("A", new NumberNode(aX), new NumberNode(aY));
-    const u = new Vector("u", new NumberNode(uX), new NumberNode(uY));
-    const b = new Point("b", new NumberNode(a.getXnumber() - u.getXAsNumber()), new NumberNode(a.getYnumber() - u.getYAsNumber()));
-    const line = new Line(a, b);
-    return line.getEquation(u, a);
+const isAnswerValid = (ans, { answer, uX, uY, aX, aY }) => {
+    try {
+        const formated = ans.replaceAll("y", "").replaceAll("=", "");
+        const parsed = parseAlgebraic(formated);
+        if (!parsed)
+            return false;
+        return ("y=" +
+            parsed
+                .simplify({
+                forbidFactorize: true,
+                decimalToFractions: true,
+                forceDistributeFractions: true,
+            })
+                .toTex() ===
+            answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const lineFromDirectorVector = {
     id: "lineFromDirectorVector",
     label: "Équation réduite d'une droite connaissant un point et un vecteur directeur",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Droites"],
     generator: (nb) => getDistinctQuestions(getLineFromDirectorVectorQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.js

@@ -60,7 +60,7 @@ const getPropositions = (n, { answer, AB, AC, trigoPoint }) => {
 const isAnswerValid = (ans, { answer, AB, AC, trigoPoint }) => {
     try {
         const parsed = parseAlgebraic(ans);
-        return parsed.simplify().toTex() === answer;
+        return parsed.simplify({ decimalToFractions: true }).toTex() === answer;
     }
     catch (err) {
         return handleVEAError(err);

package/lib/exercises/math/powers/calculateNegativePower.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateNegativePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculateNegativePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAmEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"calculateNegativePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculateNegativePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAmEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAYxD,CAAC"}

package/lib/exercises/math/powers/calculateNegativePower.js

@@ -58,9 +58,7 @@ export const calculateNegativePower = {
     id: "calculateNegativePower",
     connector: "=",
     label: "Calculer une puissance négative",
-    levels: ["4ème", "3ème", "2ndPro", "2nde", "CAP"],
     isSingleStep: true,
-    sections: ["Puissances"],
     generator: (nb) => getDistinctQuestions(getCalculatePowerQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,

package/lib/exercises/math/powers/calculatePower.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculatePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculatePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAuDF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"calculatePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculatePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAuDF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAYhD,CAAC"}

package/lib/exercises/math/powers/calculatePower.js

@@ -51,9 +51,7 @@ export const calculatePower = {
     id: "calculatePower",
     connector: "=",
     label: "Calculer une puissance",
-    levels: ["4ème", "3ème", "2ndPro", "2nde", "CAP"],
     isSingleStep: true,
-    sections: ["Puissances"],
     generator: (nb) => getDistinctQuestions(getCalculatePowerQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,

package/lib/exercises/math/powers/decimalToScientific.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimalToScientific.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/decimalToScientific.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,QAAQ,EAST,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAoDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CA2BrD,CAAC"}
+{"version":3,"file":"decimalToScientific.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/decimalToScientific.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,QAAQ,EAST,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAoDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}

package/lib/exercises/math/powers/decimalToScientific.js

@@ -48,21 +48,6 @@ export const decimalToScientific = {
     id: "decimalToScientific",
     connector: "=",
     label: "Passer d'écriture décimale à écriture scientifique",
-    levels: [
-        "5ème",
-        "4ème",
-        "3ème",
-        "2nde",
-        "CAP",
-        "2ndPro",
-        "1reESM",
-        "1rePro",
-        "1reSpé",
-        "1reTech",
-        "TermPro",
-        "TermTech",
-    ],
-    sections: ["Puissances"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getDecimalToScientificQuestion, nb),
     qcmTimer: 60,

package/lib/exercises/math/powers/scientificToDecimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scientificToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/scientificToDecimal.ts"],"names":[],"mappings":"AAAA;;MAEM;AAYN,OAAO,EACL,QAAQ,EAST,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAiDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CA2BrD,CAAC"}
+{"version":3,"file":"scientificToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/scientificToDecimal.ts"],"names":[],"mappings":"AAAA;;MAEM;AAYN,OAAO,EACL,QAAQ,EAST,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAiDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}

package/lib/exercises/math/powers/scientificToDecimal.js

@@ -45,21 +45,6 @@ export const scientificToDecimal = {
     id: "scientificToDecimal",
     connector: "=",
     label: "Passer d'écriture scientifique à écriture décimale",
-    levels: [
-        "5ème",
-        "4ème",
-        "3ème",
-        "2nde",
-        "CAP",
-        "2ndPro",
-        "1reESM",
-        "1rePro",
-        "1reSpé",
-        "1reTech",
-        "TermPro",
-        "TermTech",
-    ],
-    sections: ["Puissances"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getScientificToDecimalQuestion, nb),
     qcmTimer: 60,

package/lib/exercises/math/primitive/logarithmePrimitive.js

@@ -11,7 +11,7 @@ import { PowerNode } from "../../../tree/nodes/operators/powerNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 const getKeys = () => {
-    return ["x", "C", "lnBrackets", "abs", "epower"];
+    return ["x", "C", "ln", "abs", "epower"];
 };
 const getAnswer = (identifiers) => {
     const { coeffs } = identifiers;

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

@@ -11,4 +11,5 @@ export * from "./probaFromTableNoContext.js";
 export * from "./probaFromTableWithContext.js";
 export * from "./binomial/index.js";
 export * from "./basicStats/index.js";
+export * from "./randomVariable/index.js";
 //# sourceMappingURL=index.d.ts.map

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,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,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"}

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

@@ -11,3 +11,4 @@ export * from "./probaFromTableNoContext.js";
 export * from "./probaFromTableWithContext.js";
 export * from "./binomial/index.js";
 export * from "./basicStats/index.js";
+export * from "./randomVariable/index.js";

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

@@ -0,0 +1,5 @@
+export * from "./randomVariableAverage.js";
+export * from "./randomVariableVariance.js";
+export * from "./isTableProbabilityLaw.js";
+export * from "./randomVariableStandardDeviation.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from "./randomVariableAverage.js";
+export * from "./randomVariableVariance.js";
+export * from "./isTableProbabilityLaw.js";
+export * from "./randomVariableStandardDeviation.js";

package/lib/exercises/math/probaStat/randomVariable/isTableProbabilityLaw.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    xValuesIds: NodeIdentifiers[];
+    yValuesIds: NodeIdentifiers[];
+    isLaw: boolean;
+};
+export declare const isTableProbabilityLaw: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isTableProbabilityLaw.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/isTableProbabilityLaw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTableProbabilityLaw.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/isTableProbabilityLaw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA4EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

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

@@ -0,0 +1,81 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RandomVariable, RandomVariableConstructor, } from "../../../../math/probability/randomVariable.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { isLaw }) => {
+    const propositions = [];
+    addValidProp(propositions, isLaw ? "Oui" : "Non", "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getInstruction = (identifiers) => {
+    const { xValuesIds, yValuesIds } = identifiers;
+    const va = new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)));
+    return `Le tableau suivant décrit-il une loi de probabilité ?
+  
+${va.getLawTable()}
+`;
+};
+const getHint = (identifiers) => {
+    return `Pour qu'un tableau décrive une loi de probabilités, il faut que la somme des probabilités soit égale à $1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { xValuesIds, yValuesIds, isLaw } = identifiers;
+    const probas = yValuesIds.map((e) => reifyAlgebraic(e));
+    const sum = operatorComposition(AddNode, probas);
+    const value = sum.evaluate().frenchify();
+    return `On additionne les probabilités : 
+  
+$$
+${sum.toTex()}=${value}
+$$
+
+${isLaw
+        ? `Puisque la somme est égale à $1$, ce tableau décrit bien une loi de probabilités.`
+        : `Puisque la somme n'est pas égale à $1$, ce tableau ne décrit pas une loi de probailités. `}`;
+};
+const getIsTableProbabilityLawQuestion = (ops) => {
+    const va = RandomVariableConstructor.random();
+    const isLaw = coinFlip();
+    if (!isLaw) {
+        const index = randint(0, va.xValues.length);
+        va.yValues[index] = add(va.yValues[index], randint(-3, 4, [0]) * 0.05).simplify();
+    }
+    const identifiers = {
+        xValuesIds: va.xValues.map((x) => x.toIdentifiers()),
+        yValuesIds: va.yValues.map((x) => x.toIdentifiers()),
+        isLaw,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const isTableProbabilityLaw = {
+    id: "isTableProbabilityLaw",
+    label: "Déterminer si un tableau décrit une loi de probabilité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsTableProbabilityLawQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/randomVariableAverage.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/randomVariableAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableAverage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/randomVariableAverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,UAAU,EAAE,eAAe,EAAE,CAAC;CAC/B,CAAC;AA0FF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAmBvD,CAAC"}

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

@@ -0,0 +1,95 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RandomVariable, RandomVariableConstructor, } from "../../../../math/probability/randomVariable.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randfloat(2, 10, 2).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { xValuesIds, yValuesIds } = identifiers;
+    const va = new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)));
+    return va.getAverage().simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { xValuesIds, yValuesIds } = identifiers;
+    const va = new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)));
+    return `Soit $X$ une variable aléatoire dont la loi de probabilités est donnée ci-dessous.
+
+${va.getLawTable()}
+
+Que vaut l'espérance $E(X)$ de $X$ ?
+`;
+};
+const getHint = (identifiers) => {
+    return `$V(X)$ est la somme des produits des valeurs de $X$ par leur probabilité. `;
+};
+const getCorrection = (identifiers) => {
+    const { xValuesIds, yValuesIds } = identifiers;
+    const va = new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)));
+    const esp = va.getAverage();
+    return `On additionne les produits des valeurs de $X$ par leur probabilité : 
+  
+${alignTex([
+        ["", "E(X)"],
+        ["=", esp.toTex()],
+        ["=", esp.simplify().toTex()],
+    ])}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableAverageQuestion = (ops) => {
+    const va = RandomVariableConstructor.random();
+    const identifiers = {
+        xValuesIds: va.xValues.map((e) => e.toIdentifiers()),
+        yValuesIds: va.yValues.map((e) => e.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 randomVariableAverage = {
+    id: "randomVariableAverage",
+    connector: "=",
+    label: "Calculer l'espérance d'une variable aléatoire à partir de sa loi de probabilité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/randomVariableStandardDeviation.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/randomVariableStandardDeviation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableStandardDeviation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/randomVariableStandardDeviation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,UAAU,EAAE,eAAe,EAAE,CAAC;CAC/B,CAAC;AAoGF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAsBjE,CAAC"}