math-exercises 3.0.157 → 3.0.158

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusB.js

@@ -0,0 +1,101 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../../tree/nodes/numbers/infiniteNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { ClosureType } from "../../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../../tree/nodes/sets/intervalNode.js";
+const createNodeAEXPlusB = (a, b) => {
+    return add(multiply(a, exp("x".toTree())), b);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "$f$ est décroissante", "raw");
+    tryToAddWrongProp(propositions, "$f$ est croissante", "raw");
+    tryToAddWrongProp(propositions, "$f$ n'est pas monotone", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a } = identifiers;
+    return a > 0 ? "$f$ est croissante" : "$f$ est décroissante";
+};
+const getInterval = (identifiers) => {
+    const { intervalAskedIndex, a, b } = identifiers;
+    const interval = intervalAskedIndex === 0
+        ? new IntervalNode(MinusInfinityNode, a.toTree(), ClosureType.OF)
+        : intervalAskedIndex === 1
+            ? new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF)
+            : new IntervalNode(b.toTree(), PlusInfinityNode, ClosureType.FO);
+    return interval;
+};
+const getInstructionNode = (identifiers) => {
+    const { a, b } = identifiers;
+    return createNodeAEXPlusB(a, b);
+};
+const getInstruction = (identifiers) => {
+    const interval = getInterval(identifiers);
+    const nodeInstruction = getInstructionNode(identifiers);
+    return `Soit la fonction $f$ définie sur $\\mathbb{R}$ par :
+
+$$
+f(x) = ${nodeInstruction.toTex()}
+$$
+
+Quel est le sens de variation de $f$ sur $${interval.toTex()}$ ?`;
+};
+const getHint = (identifiers) => {
+    const interval = getInterval(identifiers);
+    return `Observe comment varient les valeurs de $f(x)$ pour les valeurs de $x$ comprises dans l'intervalle $${interval.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const interval = getInterval(identifiers);
+    const nodeAffine = AffineConstructor.fromCoeffs([b, a]).toTree();
+    return `On sait que :
+- $x \\mapsto e^x$ est strictement croissante sur $\\mathbb{R}$
+- $x \\mapsto ${nodeAffine.toTex()}$ est strictement ${a > 0 ? "croissante" : "décroissante"} sur $\\mathbb{R}$
+
+Par composition, on en conclut que ${getAnswer(identifiers).toLocaleLowerCase()} sur $${interval.toTex()}$.`;
+};
+const getVarOfAEXPlusBQuestion = () => {
+    const a = randint(-10, 11, [0]);
+    const b = randint(-10, 11);
+    const intervalAskedIndex = randint(0, 3);
+    const identifiers = {
+        a,
+        b,
+        intervalAskedIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const varOfAEXPlusB = {
+    id: "varOfAEXPlusB",
+    label: "Sens de variation de $ae^x+b$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVarOfAEXPlusBQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusBOverCEXPlusD.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    intervalAskedIndex: number;
+};
+export declare const varOfAEXPlusBOverCEXPlusD: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=varOfAEXPlusBOverCEXPlusD.d.ts.map

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusBOverCEXPlusD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varOfAEXPlusBOverCEXPlusD.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/variations/exp/varOfAEXPlusBOverCEXPlusD.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAsMF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAiB3D,CAAC"}

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusBOverCEXPlusD.js

@@ -0,0 +1,192 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../../tree/nodes/numbers/infiniteNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.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 { ClosureType } from "../../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../../tree/nodes/sets/intervalNode.js";
+const createNodeAEXPlusB = (a, b) => {
+    return add(multiply(a, exp("x".toTree())), b);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "$f$ est décroissante", "raw");
+    tryToAddWrongProp(propositions, "$f$ est croissante", "raw");
+    tryToAddWrongProp(propositions, "$f$ n'est pas monotone", "raw");
+    return shuffleProps(propositions, n);
+};
+const getDerivativeNodeSimplified1 = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const nodeDen = createNodeAEXPlusB(c, d);
+    return frac(multiply(substract(multiply(a, d), multiply(c, b)), exp("x".toTree())), power(nodeDen, 2));
+};
+const getDerivativeNodeSimplified2 = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const nodeDen = createNodeAEXPlusB(c, d);
+    return frac(multiply(substract(multiply(a, d), multiply(c, b)).evaluate(), exp("x".toTree())), power(nodeDen, 2));
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const discr = substract(multiply(a, d), multiply(c, b)).evaluate();
+    return discr > 0 ? "$f$ est croissante" : "$f$ est décroissante";
+};
+const getInterval = (identifiers) => {
+    const { intervalAskedIndex, a, b } = identifiers;
+    const interval = intervalAskedIndex === 0
+        ? new IntervalNode(MinusInfinityNode, a.toTree(), ClosureType.OF)
+        : intervalAskedIndex === 1
+            ? new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF)
+            : new IntervalNode(b.toTree(), PlusInfinityNode, ClosureType.FO);
+    return interval;
+};
+const getInstructionNode = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const nodeNum = createNodeAEXPlusB(a, b);
+    const nodeDen = createNodeAEXPlusB(c, d);
+    return frac(nodeNum, nodeDen);
+};
+const getInstruction = (identifiers) => {
+    const interval = getInterval(identifiers);
+    const nodeInstruction = getInstructionNode(identifiers);
+    return `Soit la fonction $f$ définie sur $\\mathbb{R}$ par :
+
+$$
+f(x) = ${nodeInstruction.toTex()}
+$$
+
+Quel est le sens de variation de $f$ sur $${interval.toTex()}$ ?`;
+};
+const getHint = (identifiers) => {
+    const interval = getInterval(identifiers);
+    return `Calcule la dérivée de $f$ pour en déduire les variations de $f$ sur $${interval.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const nodeU = createNodeAEXPlusB(a, b);
+    const nodeV = createNodeAEXPlusB(c, d);
+    const nodeUPrime = nodeU.derivative().simplify();
+    const nodeVPrime = nodeV.derivative().simplify();
+    const discr = substract(multiply(a, d), multiply(c, b)).evaluate();
+    const interval = getInterval(identifiers);
+    return `On va calculer la dérivée du quotient.
+    
+Ici, on a : 
+
+$$
+u(x) = ${nodeU.toTex()}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+On calcule : 
+
+$$
+u'(x) = ${nodeUPrime.toTex()}
+$$
+
+$$
+v'(x) = ${nodeVPrime.toTex()}
+$$
+
+Donc :
+
+$$
+f'(x) = (\\frac{u}{v})'(x) = ${frac(substract(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrime)), power(nodeV, 2)).toTex()}
+$$
+
+$$
+f'(x) = (\\frac{u}{v})'(x) = ${getDerivativeNodeSimplified1(identifiers).toTex()}
+$$
+
+$$
+f'(x) = (\\frac{u}{v})'(x) = ${getDerivativeNodeSimplified2(identifiers).toTex()}
+$$
+
+Conclusion : Pour tout $x$ réel :
+
+$
+f'(x) ${discr > 0 ? ">" : "<"} 0
+$
+
+Autrement dit :
+
+${getAnswer(identifiers).toLocaleLowerCase()} sur $${interval.toTex()}$.`;
+};
+const getVarOfAEXPlusBOverCEXPlusDQuestion = () => {
+    function createRandomIdentifiers() {
+        const a = randint(-10, 11, [0]);
+        const b = randint(-10, 11, [0]);
+        const c = randint(-10, 11, [0]);
+        const d = randint(-10, 11, [0]);
+        const intervalAskedIndex = randint(0, 3);
+        const identifiers = {
+            a,
+            b,
+            c,
+            d,
+            intervalAskedIndex,
+        };
+        return identifiers;
+    }
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        isValid = (() => {
+            const { a, b, c, d } = identifiersCandidate;
+            const discr = substract(multiply(a, d), multiply(c, b)).evaluate();
+            return discr !== 0;
+        })();
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            a: 2,
+            b: 3,
+            c: 5,
+            d: 7,
+            intervalAskedIndex: 0,
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const varOfAEXPlusBOverCEXPlusD = {
+    id: "varOfAEXPlusBOverCEXPlusD",
+    label: "Sens de variation de $\\frac{ae^x+b}{ce^x+d}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVarOfAEXPlusBOverCEXPlusDQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/geometry/euclidian/pinPointFromAxialOrCentralSymmetry.js

@@ -284,8 +284,8 @@ const getPinPointFromAxialOrCentralSymmetryQuestion = (optsIn) => {
                     const vecVRaw = VectorConstructor.fromPoints(point1, rotatePoint(point2, frac(PiNode, 2).evaluate(), point1, "N"));
                     const vecVUnit = vecVRaw.times(frac(1, vecVRaw.getNorm().evaluate()).evaluate().toTree());
                     const vecSrc = VectorConstructor.fromPoints(point1, pointSrc);
-                    const dotAx = vecSrc.scalarProduct(vecUUnit);
-                    const dotPerp = vecSrc.scalarProduct(vecVUnit);
+                    const dotAx = vecSrc.scalarProduct(vecUUnit).simplify();
+                    const dotPerp = vecSrc.scalarProduct(vecVUnit).simplify();
                     const vecDst = vecUUnit
                         .times(dotAx)
                         .add(vecVUnit.times(multiply(-1, dotPerp)));

package/lib/exercises/math/geometry/thales/thales.js

@@ -23,7 +23,7 @@ const getSubTriangle = ({ triangle, insidePointsNames, ratio, }) => {
 const getInstruction = (identifiers) => {
     const { triangleIdentifiers, insidePointsNames } = identifiers;
     const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
-    return `En utilisant le théoreme de Thalès, écrire l'égalité des quotients sachant que  $\\left(${insidePointsNames.join("")}\\right)//\\left(${triangle.sides[2].toInsideName()}\\right)$.`;
+    return `En utilisant le théorème de Thalès, écrire l'égalité des quotients sachant que  $\\left(${insidePointsNames.join("")}\\right)//\\left(${triangle.sides[2].toInsideName()}\\right)$.`;
 };
 const getAnswer = (identifiers) => {
     const { triangleIdentifiers, insidePointsNames, isPapillon, ratio } = identifiers;

package/lib/exercises/math/geometry/thales/thalesCalcul.js

@@ -244,7 +244,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 export const thalesCalcul = {
     id: "thalesCalcul",
     connector: "=",
-    label: "Utiliser le théoreme de Thalès pour calculer un côté",
+    label: "Utiliser le théorème de Thalès pour calculer un côté",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getThalesFindSideQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/geometry/vectors/colinearity/determinant.js

@@ -75,7 +75,7 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     const { u, v } = getVectors(identifiers);
-    tryToAddWrongProp(propositions, u.scalarProduct(v).toTex());
+    tryToAddWrongProp(propositions, u.scalarProduct(v).simplify().toTex());
     propWhile(propositions, n, () => {
         const wrongAnswer = randint(-20, 20) + "";
         tryToAddWrongProp(propositions, wrongAnswer);

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

@@ -24,7 +24,7 @@ const getAnswer = (identifiers) => {
     const points = getPoints(identifiers);
     const u = VectorConstructor.fromPoints(points[1], points[0]);
     const v = VectorConstructor.fromPoints(points[1], points[2]);
-    const ps = u.scalarProduct(v);
+    const ps = u.scalarProduct(v).simplify();
     const normU = u.getNorm();
     const normV = v.getNorm();
     const cos = frac(ps, multiply(normU, normV)).simplify();

package/lib/exercises/math/geometry/vectors/scalarProduct/findCoordinatesToOrthogonalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findCoordinatesToOrthogonalize.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/findCoordinatesToOrthogonalize.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAOvC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,iBAAiB,CAAC;CACzB,CAAC;AAoGF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAqBhE,CAAC"}
+{"version":3,"file":"findCoordinatesToOrthogonalize.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/findCoordinatesToOrthogonalize.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAQvC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,iBAAiB,CAAC;CACzB,CAAC;AA0HF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAsBhE,CAAC"}

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

@@ -4,9 +4,10 @@ import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
 import { VectorConstructor, } from "../../../../../math/geometry/vector.js";
 import { RationalConstructor } from "../../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-import { equal } from "../../../../../tree/nodes/equations/equalNode.js";
+import { equal, EqualNode } from "../../../../../tree/nodes/equations/equalNode.js";
 import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -29,10 +30,34 @@ const getInstruction = (identifiers) => {
   
 Pour quelle valeur de $x$ les vecteurs $${u.toTex()}$ et $${v.toTex()}$ sont-ils orthogonaux ?`;
 };
-// const getHint : GetHint<Identifiers> = (identifiers)=>{
-// }
-// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
-// }
+const getHint = () => {
+    return `Deux vecteurs sont orthogonaux si et seulement leur produit scalaire est nul.`;
+};
+const getCorrection = (identifiers) => {
+    const { uIds, vIds } = identifiers;
+    const u = VectorConstructor.fromIdentifiers(uIds);
+    const v = VectorConstructor.fromIdentifiers(vIds);
+    const psNode = u.scalarProduct(v);
+    const psNodeSimp = psNode.simplify();
+    const equation = new EqualNode(psNodeSimp, (0).toTree());
+    const steps = [];
+    const res = equation.isolate("x", { steps });
+    return `On sait que deux vecteurs sont orthogonaux si et seulement si leur produit scaraire est nul.
+  
+On commence donc par calculer $${u.toTex()}\\cdot ${v.toTex()}$ :
+
+${alignTex([
+        [`${u.toTex()}\\cdot ${v.toTex()}`, "=", u.scalarProduct(v).toTex()],
+        ["", "=", u.scalarProduct(v).simplify().toTex()],
+    ])}
+
+Il suffit alors de résoudre l'équation $${u.toTex()}\\cdot ${v.toTex()} = 0$ : 
+
+${alignTex(steps.map((e) => [e]))}
+
+Les vecteurs $${u.toTex()}$ et $${v.toTex()}$ sont donc orthogonaux si et seulement si $${res.toTex()}$.
+`;
+};
 const getKeys = () => {
     return [];
 };
@@ -88,8 +113,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers)
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
 };
 export const findCoordinatesToOrthogonalize = {
@@ -108,4 +133,5 @@ export const findCoordinatesToOrthogonalize = {
     // getCorrection,
     getAnswer,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -27,7 +27,7 @@ const getAnswer = (identifiers) => {
     const { uCoords, vCoords } = identifiers;
     const u = new Vector("u", new NumberNode(Number(uCoords[0])), new NumberNode(Number(uCoords[1])));
     const v = new Vector("v", new NumberNode(Number(vCoords[0])), new NumberNode(Number(vCoords[1])));
-    const answer = u.scalarProduct(v).toTex();
+    const answer = u.scalarProduct(v).simplify().toTex();
     return answer;
 };
 const getHint = () => {

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductViaCos.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA+EF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAerD,CAAC"}
+{"version":3,"file":"scalarProductViaCos.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAqBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAkHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

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

@@ -3,13 +3,47 @@ import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinct
 import { mainTrigoValues, remarkableTrigoValues, } from "../../../../../math/trigonometry/remarkableValues.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
-import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { multiply, MultiplyNode, } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { randomLetter } from "../../../../../utils/strings/randomLetter.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
 import { random } from "../../../../../utils/alea/random.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { cos } from "../../../../../tree/nodes/functions/cosNode.js";
 //|u| |v| cos(u,v)
+const getHint = () => {
+    return `Utilise la formule du produit scalaire suivante : 
+  
+$$
+\\overrightarrow{u}\\cdot \\overrightarrow{v} = ||\\overrightarrow{u}|| \\times ||\\overrightarrow{v}||\\times \\cos(\\widehat{\\overrightarrow{u}, \\overrightarrow{v}})
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { AB, AC, trigoPoint, letters } = identifiers;
+    const trigo = mainTrigoValues.find((v) => v.point === trigoPoint);
+    const [letterA, letterB, letterC] = letters;
+    const u = letterA + letterB;
+    const v = letterA + letterC;
+    return `Utilise la formule du produit scalaire suivante : 
+  
+$$
+\\overrightarrow{u}\\cdot \\overrightarrow{v} = ||\\overrightarrow{u}|| \\times ||\\overrightarrow{v}||\\times \\cos(\\widehat{\\overrightarrow{u}, \\overrightarrow{v}})
+$$
+
+Ici, on a donc : 
+
+${alignTex([
+        [
+            `\\overrightarrow{${u}}\\cdot \\overrightarrow{${v}}`,
+            "=",
+            `${u}\\times ${v}\\times \\cos\\left(${letterB}${letterA}${letterC}\\right)`,
+        ],
+        ["", "=", multiply(multiply(AB, AC), cos(trigo.angle)).toTex()],
+        ["", "=", multiply(multiply(AB, AC), trigo.cos).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getInstruction = (identifiers) => {
     const { AB, AC, trigoPoint, letters } = identifiers;
     const [letterA, letterB, letterC] = letters;
@@ -45,6 +79,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["pi"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -83,4 +119,5 @@ export const scalarProductViaCos = {
     getInstruction,
     getAnswer,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -7,6 +7,9 @@ type Identifiers = {
     pA_B?: number;
     pB_A?: number;
 };
-export declare const conditionalProbability: Exercise<Identifiers>;
+type Options = {
+    probaType: string[];
+};
+export declare const conditionalProbability: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=conditionalProbability.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"conditionalProbability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/conditionalProbability.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,QAAQ,EAeT,MAAM,mBAAmB,CAAC;AAM3B,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AA8SF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"conditionalProbability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/conditionalProbability.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,QAAQ,EAmBT,MAAM,mBAAmB,CAAC;AAO3B,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAoRF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAyDF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBjE,CAAC"}

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

@@ -1,12 +1,13 @@
 /* eslint-disable @typescript-eslint/naming-convention*/
 //? it makes sense here to use pA_B
 import { randint } from "../../../math/utils/random/randint.js";
-import { addValidProp, propWhile, tryToAddWrongProp, } from "../../exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
 import { round } from "../../../math/utils/round.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { alignTex } from "../../../utils/latex/alignTex.js";
 import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { random } from "../../../utils/alea/random.js";
 const getInstruction = (identifiers) => {
     const { flip, pA, pAB, pA_B, pB, pB_A } = identifiers;
     let instruction = `On considère deux événements $A$ et $B$ tels que `;
@@ -223,9 +224,18 @@ ${alignTex([
         }
     }
 };
-const getConditionalProbability = () => {
+const getConditionalProbability = (opts) => {
     let pA, pB, pAB, pA_B, pB_A;
-    const flip = randint(1, 7);
+    const types = opts?.probaType ?? ["$P(A)$", "$P(A\\cap B)$", "$P_A(B)$"];
+    const flipChoices = [];
+    if (types.includes("$P(A)$"))
+        flipChoices.push(5, 6);
+    if (types.includes("$P(A\\cap B)$"))
+        flipChoices.push(3, 4);
+    if (types.includes("$P_A(B)$"))
+        flipChoices.push(1, 2);
+    const flip = random(flipChoices);
+    //1,2 = P_AB, 3,4 = PANB, 5,6 = PA
     switch (flip) {
         case 1:
             pA = randint(2, 100);
@@ -259,6 +269,27 @@ const getConditionalProbability = () => {
     const identifiers = { flip, pA, pAB, pB, pA_B, pB_A };
     return getQuestionFromIdentifiers(identifiers);
 };
+const options = [
+    {
+        id: "probaType",
+        label: "Probabilité demandée",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["$P(A)$", "$P(A\\cap B)$", "$P_A(B)$"],
+        defaultValue: ["$P(A)$", "$P(A\\cap B)$", "$P_A(B)$"],
+    },
+];
+const validateOptions = (opts) => {
+    if (!opts?.probaType?.length)
+        return {
+            valid: false,
+            message: "Veuillez choisir au moins un type de probabilité demandée.",
+        };
+    return {
+        valid: true,
+        message: "",
+    };
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -286,9 +317,9 @@ const isAnswerValid = (ans, { answer }) => {
 export const conditionalProbability = {
     id: "conditionalProbability",
     connector: "=",
-    label: "Calcul de probabilité conditionnelle avec la formule de Bayes",
+    label: "Calcul de probabilité conditionnelle avec la formule de Bayes $P(A \\cap B) = P_A(B) \\times P(A)$",
     isSingleStep: false,
-    generator: (nb) => getDistinctQuestions(getConditionalProbability, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getConditionalProbability(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -296,4 +327,6 @@ export const conditionalProbability = {
     subject: "Mathématiques",
     hasHintAndCorrection: true,
     getQuestionFromIdentifiers,
+    options,
+    validateOptions,
 };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"independancy.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/independancy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAkHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}