math-exercises 3.0.177 → 3.0.179

package/lib/exercises/math/functions/trinoms/sign/signOfProductOfAffineAndTrinom.js

@@ -0,0 +1,226 @@
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { signTableVEA } from "../../../../../exercises/vea/signTableVEA.js";
+import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { firstDegreeInequationResolutionTex } from "../../../../../tree/nodes/inequations/inequationNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../../tree/nodes/numbers/infiniteNode.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";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getAnswerTable = (identifiers) => {
+    const fcts = buildFcts(identifiers);
+    const roots = [
+        fcts.affine.getRoot().toTree(),
+        ...fcts.trinom.getRootsNode(),
+    ].sort((a, b) => a.evaluate() - b.evaluate());
+    const affineRootIndex = roots.findIndex((r) => r.evaluate() === fcts.affine.getRoot().toTree().evaluate());
+    const startAffSign = fcts.affine.a > 0 ? "-" : "+";
+    const endAffSign = startAffSign === "+" ? "-" : "+";
+    const trinomSigns = fcts.trinom.a > 0 ? ["+", "-", "+"] : ["-", "+", "-"];
+    const partial = [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            roots[0].toTex(),
+            "\\ ",
+            roots[1].toTex(),
+            "\\ ",
+            roots[2].toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        [
+            `$${fcts.affine.toTree().toTex()}$`,
+            "\\ ",
+            startAffSign,
+            affineRootIndex === 0 ? "0" : startAffSign,
+            affineRootIndex === 0 ? endAffSign : startAffSign,
+            affineRootIndex === 1
+                ? "0"
+                : affineRootIndex === 0
+                    ? endAffSign
+                    : startAffSign,
+            affineRootIndex < 2 ? endAffSign : startAffSign,
+            affineRootIndex === 2 ? "0" : endAffSign,
+            endAffSign,
+            "\\ ",
+        ],
+        [
+            `$${fcts.trinom.toTree().toTex()}$`,
+            "\\ ",
+            trinomSigns[0],
+            affineRootIndex === 0 ? trinomSigns[0] : "0",
+            affineRootIndex === 0 ? trinomSigns[0] : trinomSigns[1],
+            affineRootIndex === 1 ? trinomSigns[1] : "0",
+            affineRootIndex === 2 ? trinomSigns[2] : trinomSigns[1],
+            affineRootIndex === 2 ? trinomSigns[2] : "0",
+            trinomSigns[2],
+            "\\ ",
+        ],
+    ];
+    const buildSign = (sign1, sign2) => {
+        if (sign1 === sign2)
+            return "+";
+        return "-";
+    };
+    const thirdLine = [
+        `$f(x)$`,
+        "\\ ",
+        buildSign(partial[1][2], partial[2][2]),
+        "0",
+        buildSign(partial[1][4], partial[2][4]),
+        "0",
+        buildSign(partial[1][6], partial[2][6]),
+        "0",
+        buildSign(partial[1][8], partial[2][8]),
+        "\\ ",
+    ];
+    return [...partial, thirdLine];
+};
+const buildFcts = (identifiers) => {
+    const { affineCoeffs, trinomCoeffs } = identifiers;
+    const affine = new Affine(affineCoeffs[1], affineCoeffs[0]);
+    const trinom = new Trinom(trinomCoeffs[2], trinomCoeffs[1], trinomCoeffs[0]);
+    return { affine, trinom };
+};
+const getInstruction = (identifiers) => {
+    const fcts = buildFcts(identifiers);
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par : 
+
+$$
+f(x) = ${multiply(fcts.affine.toTree(), fcts.trinom.toTree()).toTex()}
+$$
+
+Dresser le tableau de signes de $f$.`;
+};
+const getHint = () => {
+    return `$f(x)$ est un produit de deux fonctions : une fonction affine $g$ et une fonction polynôme du second degré $h$. 
+  
+Détermine le signe de la fonction affine en résolvant l'inéquation $g(x)\\geq 0$. 
+
+Puis détermine le signe de la fonction polynôme du second degré $h$ en trouvant ses racines.
+
+Enfin, entre tes résultats dans le tableau. Le signe de $f(x)$ s'obtiendra alors en utilisant la règle des signes.`;
+};
+const getCorrection = (identifiers) => {
+    const fcts = buildFcts(identifiers);
+    const trinomRoots = fcts.trinom.getRootsNode();
+    const affRoot = fcts.affine.getRoot().toTree();
+    const allRoots = [affRoot, ...trinomRoots].sort((a, b) => a.evaluate() - b.evaluate());
+    const firstSign = fcts.affine.a * fcts.trinom.a > 0 ? "négative" : "positive";
+    const alternateSign = fcts.affine.a * fcts.trinom.a > 0 ? "positive" : "négative";
+    return `On commence par déterminer le signe de $${fcts.affine
+        .toTree()
+        .toTex()}$ : 
+  
+$$
+${firstDegreeInequationResolutionTex(fcts.affine, "\\ge", (0).toTree())}
+$$
+
+Puis, on détermine le signe de $${fcts.trinom
+        .toTree()
+        .toTex()}$. Pour cela, on calcule ses racines. On trouve $\\Delta = ${fcts.trinom
+        .getDeltaNode()
+        .toTex()}$, donc cette fonction admet deux racines : 
+
+$$
+x_1 = ${trinomRoots[0].toTex()} 
+$$
+
+et 
+
+$$
+x_2 = ${trinomRoots[1].toTex()}
+$$
+
+Cette fonction est donc ${fcts.trinom.a > 0 ? "négative" : "positive"} sur $${new IntervalNode(trinomRoots[0], trinomRoots[1], ClosureType.FF).toTex()}$, et ${fcts.trinom.a > 0 ? "positive" : "négative"} sur le reste de $\\mathbb{R}$.
+
+On note toutes ces informations dans un tableau de signes. On applique enfin la règle des signes pour trouver le signe de $f$.
+
+On en conclut que $f$ est ${firstSign} sur $${new IntervalNode(MinusInfinityNode, allRoots[0], ClosureType.OF).toTex()}$ et sur $${new IntervalNode(allRoots[1], allRoots[2], ClosureType.FF).toTex()}$, et elle est ${alternateSign} sur $${new IntervalNode(allRoots[0], allRoots[1], ClosureType.FF).toTex()}$ et sur $${new IntervalNode(allRoots[2], PlusInfinityNode, ClosureType.FO).toTex()}$.`;
+};
+const getKeys = () => {
+    return ["infty"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return signTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSignOfProductOfAffineAndTrinomQuestion = () => {
+    let affine;
+    let trinom;
+    do {
+        affine = AffineConstructor.randomNiceRoot();
+        trinom = TrinomConstructor.randomNiceRoots(2);
+    } while (trinom
+        .getRootsNode()
+        .some((root) => root.evaluate() === affine.getRoot().toTree().evaluate()));
+    const identifiers = {
+        affineCoeffs: affine.coefficients,
+        trinomCoeffs: trinom.coefficients,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const fcts = buildFcts(identifiers);
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: [
+            ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+            [
+                `$${fcts.affine.toTree().toTex()}$`,
+                "\\ ",
+                "",
+                "",
+                "",
+                "",
+                "",
+                "",
+                "",
+                "\\ ",
+            ],
+            [
+                `$${fcts.trinom.toTree().toTex()}$`,
+                "\\ ",
+                "",
+                "",
+                "",
+                "",
+                "",
+                "",
+                "",
+                "\\ ",
+            ],
+            [`$f(x)$`, "\\ ", "", "", "", "", "", "", "", "\\ "],
+        ],
+    };
+};
+export const signOfProductOfAffineAndTrinom = {
+    id: "signOfProductOfAffineAndTrinom",
+    label: "Dresser le tableau de signes du produit d'une fonction affine et d'une fonction polynôme du second degré",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSignOfProductOfAffineAndTrinomQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "signTable",
+};

package/lib/exercises/math/geometry/angles/parallelogramFourthAngle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallelogramFourthAngle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/parallelogramFourthAngle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA4FF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAkB1D,CAAC"}
+{"version":3,"file":"parallelogramFourthAngle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/parallelogramFourthAngle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAyFF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAkB1D,CAAC"}

package/lib/exercises/math/geometry/angles/parallelogramFourthAngle.js

@@ -6,21 +6,21 @@ import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getPropositions = (n, { answer, singleAngle, doubleAngle }) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    tryToAddWrongProp(propositions, `${singleAngle}^{\\circ}`);
-    tryToAddWrongProp(propositions, `${doubleAngle}^{\\circ}`);
-    tryToAddWrongProp(propositions, `${360 - singleAngle}^{\\circ}`);
-    tryToAddWrongProp(propositions, `${360 - doubleAngle}^{\\circ}`);
-    tryToAddWrongProp(propositions, `${360 - singleAngle - doubleAngle}^{\\circ}`);
-    tryToAddWrongProp(propositions, `${Math.abs(180 - 2 * singleAngle - doubleAngle)}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${singleAngle}^\\circ`);
+    tryToAddWrongProp(propositions, `${doubleAngle}^\\circ`);
+    tryToAddWrongProp(propositions, `${360 - singleAngle}^\\circ`);
+    tryToAddWrongProp(propositions, `${360 - doubleAngle}^\\circ`);
+    tryToAddWrongProp(propositions, `${360 - singleAngle - doubleAngle}^\\circ`);
+    tryToAddWrongProp(propositions, `${Math.abs(180 - 2 * singleAngle - doubleAngle)}^\\circ`);
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
     const { singleAngle, doubleAngle } = identifiers;
     const fourthAngle = 360 - singleAngle - 2 * doubleAngle;
-    return `${fourthAngle}^{\\circ}`;
+    return `${fourthAngle}^\\circ`;
 };
 const getInstruction = (identifiers) => {
-    return `Un parallélogramme a deux angles de mesure $${identifiers.doubleAngle}^{\\circ}$ et un angle de mesure $${identifiers.singleAngle}^{\\circ}$. 
+    return `Un parallélogramme a deux angles de mesure $${identifiers.doubleAngle}^\\circ$ et un angle de mesure $${identifiers.singleAngle}^\\circ$. 
 
 Quelle est la mesure de son quatrième angle ?`;
 };
@@ -33,13 +33,13 @@ const getCorrection = (identifiers) => {
     return `La somme des angles d'un parallélogramme est égale à $360°$. Ici, la somme des trois angles connus vaut : 
   
 $$
-${singleAngle}^{\\circ} + 2\\times ${doubleAngle}^{\\circ} = ${sum}^{\\circ}
+${singleAngle}^\\circ + 2\\times ${doubleAngle}^\\circ = ${sum}^\\circ
 $$
 
 Le quatrième angle vaut donc : 
 
 $$
-360^{\\circ} - ${sum}^{\\circ} = ${singleAngle} ^{\\circ}
+360^\\circ - ${sum}^\\circ = ${singleAngle} ^\\circ
 $$`;
 };
 const isAnswerValid = (ans, { answer }) => {

package/lib/exercises/math/geometry/quadrilaterals/parallelogramAngles.js

@@ -12,11 +12,11 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     const para = ParallelogramConstructor.fromIdentifiers(identifiers.paraIdentifiers);
     const value = round(para.angles[identifiers.givenAngleIndex].evaluate(), 0);
     addValidProp(propositions, answer);
-    tryToAddWrongProp(propositions, "180^{\\circ}");
-    tryToAddWrongProp(propositions, (180 - value).frenchify() + "^{\\circ}");
-    tryToAddWrongProp(propositions, value.frenchify() + "^{\\circ}");
+    tryToAddWrongProp(propositions, "180^\\circ");
+    tryToAddWrongProp(propositions, (180 - value).frenchify() + "^\\circ");
+    tryToAddWrongProp(propositions, value.frenchify() + "^\\circ");
     propWhile(propositions, n, () => {
-        tryToAddWrongProp(propositions, randint(20, 160) + "^{\\circ}");
+        tryToAddWrongProp(propositions, randint(20, 160) + "^\\circ");
     });
     return shuffleProps(propositions, n);
 };
@@ -24,19 +24,19 @@ const getAnswer = (identifiers) => {
     const para = ParallelogramConstructor.fromIdentifiers(identifiers.paraIdentifiers);
     const value = round(para.angles[identifiers.givenAngleIndex].evaluate(), 0);
     const isOpposite = identifiers.askedAngleIndex === (identifiers.givenAngleIndex + 2) % 4;
-    return (isOpposite ? value : 180 - value).frenchify() + "^{\\circ}";
+    return (isOpposite ? value : 180 - value).frenchify() + "^\\circ";
 };
 const getInstruction = (identifiers) => {
     const para = ParallelogramConstructor.fromIdentifiers(identifiers.paraIdentifiers);
     const value = round(para.angles[identifiers.givenAngleIndex].evaluate(), 0);
     return `On considère le parallélogramme $ABCD$ ci-dessous. 
   
-L'angle $${para.angles[identifiers.givenAngleIndex].toTex()}$ vaut $${value}^{\\circ}$.
+L'angle $${para.angles[identifiers.givenAngleIndex].toTex()}$ vaut $${value}^\\circ$.
 
 Que vaut l'angle $${para.angles[identifiers.askedAngleIndex].toTex()}$ ?`;
 };
 const getHint = () => {
-    return "Dans un parallélogramme, la somme totale des angles vaut $360^{\\circ}$. Les angles opposés sont égaux, et la somme de deux angles consécutifs est égale à $180^{\\circ}$.";
+    return "Dans un parallélogramme, la somme totale des angles vaut $360^\\circ$. Les angles opposés sont égaux, et la somme de deux angles consécutifs est égale à $180^\\circ$.";
 };
 const getCorrection = (identifiers) => {
     const para = ParallelogramConstructor.fromIdentifiers(identifiers.paraIdentifiers);
@@ -51,7 +51,7 @@ On a donc :
 $$
 ${askedAngle.toTex()} = ${getAnswer(identifiers)}
 $$`
-        : `Dans un parallélogramme, la somme de deux angles consécutifs vaut $180^{\\circ}$.
+        : `Dans un parallélogramme, la somme de deux angles consécutifs vaut $180^\\circ$.
 
 Ainsi, 
 

package/lib/exercises/math/geometry/triangles/similar/isSimilarTrianglesWithAngles.js

@@ -24,8 +24,8 @@ const getInstruction = (identifiers) => {
     const { firstAngleValue, sameAngleValue, secondAngleValue, triangleNames } = identifiers;
     return `On considère deux triangles : 
   
-- le triangle $${triangleNames[0]}$, dans lequel l'angle $\\widehat{${triangleNames[0][0]}}$ a une mesure de $${sameAngleValue.frenchify()}^{\\circ}$ et l'angle $\\widehat{${triangleNames[0][1]}}$ a une mesure de $${firstAngleValue.frenchify()}^{\\circ}$ ;
-- le triangle $${triangleNames[1]}$, dans lequel l'angle $\\widehat{${triangleNames[1][0]}}$ a une mesure de $${sameAngleValue.frenchify()}^{\\circ}$ et l'angle $\\widehat{${triangleNames[1][1]}}$ a une mesure de $${secondAngleValue.frenchify()}^{\\circ}$.
+- le triangle $${triangleNames[0]}$, dans lequel l'angle $\\widehat{${triangleNames[0][0]}}$ a une mesure de $${sameAngleValue.frenchify()}^\\circ$ et l'angle $\\widehat{${triangleNames[0][1]}}$ a une mesure de $${firstAngleValue.frenchify()}^\\circ$ ;
+- le triangle $${triangleNames[1]}$, dans lequel l'angle $\\widehat{${triangleNames[1][0]}}$ a une mesure de $${sameAngleValue.frenchify()}^\\circ$ et l'angle $\\widehat{${triangleNames[1][1]}}$ a une mesure de $${secondAngleValue.frenchify()}^\\circ$.
 
 Les triangles $${triangleNames[0]}$ et $${triangleNames[1]}$ sont-ils semblables ?`;
 };
@@ -42,25 +42,25 @@ On calcule donc la mesure du troisième angle de chacun des triangles. Pour cela
 - pour le triangle $${triangleNames[0]}$, la somme des deux angles connus vaut : 
 
 $$
-${sameAngleValue.frenchify()}^{\\circ} + ${firstAngleValue.frenchify()}^{\\circ} = ${round(sameAngleValue + firstAngleValue, 4).frenchify()}^{\\circ}
+${sameAngleValue.frenchify()}^\\circ + ${firstAngleValue.frenchify()}^\\circ = ${round(sameAngleValue + firstAngleValue, 4).frenchify()}^\\circ
 $$
 
 donc le troisième angle vaut : 
 
 $$
-180 - ${round(sameAngleValue + firstAngleValue, 4).frenchify()} = ${round(180 - (sameAngleValue + firstAngleValue), 4).frenchify()}^{\\circ}
+180 - ${round(sameAngleValue + firstAngleValue, 4).frenchify()} = ${round(180 - (sameAngleValue + firstAngleValue), 4).frenchify()}^\\circ
 $$
 
 - pour le triangle $${triangleNames[1]}$, la somme des deux angles connus vaut : 
 
 $$
-${sameAngleValue.frenchify()}^{\\circ} + ${secondAngleValue.frenchify()}^{\\circ} = ${round(sameAngleValue + secondAngleValue, 4).frenchify()}^{\\circ}
+${sameAngleValue.frenchify()}^\\circ + ${secondAngleValue.frenchify()}^\\circ = ${round(sameAngleValue + secondAngleValue, 4).frenchify()}^\\circ
 $$
 
 donc le troisième angle vaut : 
 
 $$
-180 - ${round(sameAngleValue + secondAngleValue, 4).frenchify()} = ${round(180 - (sameAngleValue + secondAngleValue), 4).frenchify()}^{\\circ}
+180 - ${round(sameAngleValue + secondAngleValue, 4).frenchify()} = ${round(180 - (sameAngleValue + secondAngleValue), 4).frenchify()}^\\circ
 $$
 
 ${isSimilar

package/lib/exercises/math/geometry/triangles/triangleThirdAngleValue.js

@@ -18,10 +18,10 @@ const getPropositions = (n, { answer, angleAsked, triangleIdentifiers }) => {
         triangle.angles[(angleAsked + 2) % 3].getValueNode(true),
     ];
     const addAnglesEv = add(angles[0], angles[1]).evaluate();
-    tryToAddWrongProp(propositions, "180^{\\circ}");
-    tryToAddWrongProp(propositions, addAnglesEv.frenchify() + "^{\\circ}");
+    tryToAddWrongProp(propositions, "180^\\circ");
+    tryToAddWrongProp(propositions, addAnglesEv.frenchify() + "^\\circ");
     propWhile(propositions, n, () => {
-        tryToAddWrongProp(propositions, randint(20, 160) + "^{\\circ}");
+        tryToAddWrongProp(propositions, randint(20, 160) + "^\\circ");
     });
     return shuffleProps(propositions, n);
 };
@@ -34,7 +34,7 @@ const getAnswer = (identifiers) => {
     ];
     const addAngles = add(angles[0], angles[1]);
     const simp = addAngles.simplify();
-    return substract(180, simp).simplify().toTex() + "^{\\circ}";
+    return substract(180, simp).simplify().toTex() + "^\\circ";
 };
 const getInstruction = (identifiers) => {
     const { triangleIdentifiers, angleAsked } = identifiers;
@@ -42,10 +42,10 @@ const getInstruction = (identifiers) => {
     const angles = [
         `${triangle.angles[(angleAsked + 1) % 3].toTex()}=${triangle.angles[(angleAsked + 1) % 3]
             .getValueNode(true)
-            .toTex()}^{\\circ}`,
+            .toTex()}^\\circ`,
         `${triangle.angles[(angleAsked + 2) % 3].toTex()}=${triangle.angles[(angleAsked + 2) % 3]
             .getValueNode(true)
-            .toTex()}^{\\circ}`,
+            .toTex()}^\\circ`,
     ];
     return `Dans le triangle $${triangle.name}$ ci-dessous, on a $${angles[0]}$ et $${angles[1]}$.
     
@@ -68,13 +68,13 @@ const getCorrection = (identifiers) => {
 En additionnant les deux angles donnés dans l'énoncé, on obtient :
 
 $$
-${angles[0].toTex()}^{\\circ}  + ${angles[1].toTex()}^{\\circ} =${simp.toTex()}^{\\circ}
+${angles[0].toTex()}^\\circ  + ${angles[1].toTex()}^\\circ =${simp.toTex()}^\\circ
 $$
 
 L'angle recherché a donc une mesure de : 
 
 $$
-180^{\\circ} - ${simp.toTex()}^{\\circ}=${getAnswer(identifiers)}
+180^\\circ - ${simp.toTex()}^\\circ=${getAnswer(identifiers)}
 $$`;
 };
 const getGGBOptions = (identifiers) => {

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiAngle.js

@@ -198,7 +198,7 @@ const getKeys = () => {
 };
 const isAnswerValid = (ans, { answer, ...identifiers }) => {
     const strForKeyIdDegreeReceivedFromTests = "^\\circ";
-    const strForKeyIdDegreeReceivedFromFront = "^{\\circ}"; //different from strForKeyIdDegreeSent: "^\\circ"
+    const strForKeyIdDegreeReceivedFromFront = "^\\circ"; //different from strForKeyIdDegreeSent: "^\\circ"
     const ansRefined = ans
         .replace(strForKeyIdDegreeReceivedFromTests, "")
         .replace(strForKeyIdDegreeReceivedFromFront, "");

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiSideLength.js

@@ -62,7 +62,7 @@ ${triangle.sides
 
 - $${triangle.angles[indexAngle].toTexMini()} = ${triangle.angles[indexAngle]
         .evaluate()
-        .frenchify()} {}^{\\circ} $
+        .frenchify()} {}^\\circ $
   
 Calculer la longueur $${triangle.sides[indexSide].toTex()}$ (donner une valeur arrondie à $${precision}$ décimales).`;
 };
@@ -73,7 +73,7 @@ const getAnswerStuff = (identifiers) => {
     const nodeAngleInDegrees = triangle.angles[indexAngle].evaluate().toTree();
     const nodeAngleInRadians = multiply(nodeAngleInDegrees, frac(PiNode, 180));
     //"nodeStr"
-    const nodeStrLengthSquared = substract(add(power(sides[1].getLengthNode(), 2), power(sides[2].getLengthNode(), 2)), multiply(2, multiply(multiply(sides[1].getLengthNode(), sides[2].getLengthNode()), cos(multiply(nodeAngleInDegrees, "{}^{\\circ}".toTree())))));
+    const nodeStrLengthSquared = substract(add(power(sides[1].getLengthNode(), 2), power(sides[2].getLengthNode(), 2)), multiply(2, multiply(multiply(sides[1].getLengthNode(), sides[2].getLengthNode()), cos(multiply(nodeAngleInDegrees, "{}^\\circ".toTree())))));
     const nodeStrLength = sqrt(nodeStrLengthSquared.simplify());
     //"true" nodes
     const nodeLengthSquared = substract(add(power(sides[1].getLengthNode(), 2), power(sides[2].getLengthNode(), 2)), multiply(2, multiply(multiply(sides[1].getLengthNode(), sides[2].getLengthNode()), cos(nodeAngleInRadians))));

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

@@ -17,7 +17,7 @@ const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     propWhile(propositions, n, () => {
-        tryToAddWrongProp(propositions, randint(0, 180) + "^{\\circ}");
+        tryToAddWrongProp(propositions, randint(0, 180) + "^\\circ");
     });
     return shuffleProps(propositions, n);
 };
@@ -30,7 +30,7 @@ const getAnswer = (identifiers) => {
     const normV = v.getNorm();
     const cos = frac(ps, multiply(normU, normV)).simplify();
     const arc = round((180 * Math.acos(cos.evaluate())) / Math.PI, 0);
-    return arc.frenchify() + "^{\\circ}";
+    return arc.frenchify() + "^\\circ";
 };
 const getInstruction = (identifiers) => {
     const points = getPoints(identifiers);

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

@@ -1 +1 @@
-{"version":3,"file":"scalarProductOrthoInSquare.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAkOF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}
+{"version":3,"file":"scalarProductOrthoInSquare.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAoPF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}

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

@@ -102,7 +102,7 @@ const getScalarProductOrthoInSquareQuestion = () => {
     //puis on reverse tout possiblement
     const isFirstVecOnAB = coinFlip();
     const vecs = {
-        AB: { projLength: c, reps: ["AB", "DC"] },
+        AB: { projLength: c, reps: ["AB", "DC"] }, //base
         AC: { projLength: c, reps: ["AC"] },
         AD: { projLength: c, reps: ["AD", "IK", "BC"] },
         AJ: { projLength: isFirstVecOnAB ? c : c / 2, reps: ["AJ", "LC"] },
@@ -141,7 +141,7 @@ const getScalarProductOrthoInSquareQuestion = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
+// const getHint: GetHint<Identifiers> = () => {
 //   return `Utilise la définition du produit scalaire par projeté orthogonal : si $H$ est le projeté orthogonal du point $C$ sur la droite $(AB)$, alors :
 // $$
 // \\overline{AB}\\cdot\\overline{AC} = \\overline{AB}\\cdot\\overline{AH}
@@ -159,33 +159,48 @@ const getScalarProductOrthoInSquareQuestion = () => {
 // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
 //   const { areSameDirection, vec1Name, vec2Name, c } = identifiers;
 //   const vecs = [
-//     ["AB", "DC"],
+//     ["AB", "DC"], //base
 //     ["AC"],
-//     ["AD", "IK", "BC"],
+//     ["AD", "IK", "BC"], //base
 //     ["AJ", "LC"],
 //     ["AO", "LK", "OC", "IJ"],
 //     ["AK", "IC"],
-//     ["AI", "IB", "LO", "OJ", "DK", "KC"],
-//     ["AL", "LD", "IO", "OK", "BJ", "JC"],
+//     ["AI", "IB", "LO", "OJ", "DK", "KC"], //base
+//     ["AL", "LD", "IO", "OK", "BJ", "JC"], //base
 //   ];
+//   const baseIndexes = [0, 2, 6, 7];
+//   if (!areSameDirection) return `plus tard`;
+//   const reversedVecs = vecs.map((e) =>
+//     e.map((f) => f.split("").reverse().join("")),
+//   );
+//   const reversedFirst = vec1Name.split("").reverse().join("");
 //   const index1 = vecs.findIndex(
-//     (e) =>
-//       e.includes(vec1Name) || e.includes(vec1Name.split("").reverse().join("")),
+//     (e) => e.includes(vec1Name) || e.includes(reversedFirst),
 //   );
 //   const firstIsReversed = !vecs[index1].includes(vec1Name);
+//   const reversedSecond = vec2Name.split("").reverse().join("");
 //   const index2 = vecs.findIndex(
-//     (e) =>
-//       e.includes(vec2Name) || e.includes(vec2Name.split("").reverse().join("")),
+//     (e) => e.includes(vec2Name) || e.includes(reversedSecond),
 //   );
 //   const secondIsReversed = !vecs[index2].includes(vec2Name);
-//   if (vec1Name[0] === vec2Name[0]) return `immédiat`;
-//   for (let i = 0; i < vecs[index1].length; i++) {
-//     const rep = vecs[index1][i];
-//     const origin1 = rep[0];
-//     const sameOrigin = vecs[index2].find((e) => e[0] === origin1);
-//     if (sameOrigin)
-//       return `on prend $${rep}$ et $${sameOrigin}$. ${sameOrigin[1]} à projeter sur ${rep}`;
+//   if (vec1Name[0] === vec2Name[0]) {
+//     const firstIsBase = baseIndexes.includes(index1);
+//     return `Le projeté orthogonal de $${
+//       firstIsBase ? vec2Name[1] : vec1Name[1]
+//     }$ sur la droite $(${firstIsBase ? vec1Name : vec2Name})$ est $${"a"}$.
+// On a donc :
+// immédiat`;
 //   }
+//   const sameOrigin =
+//     vecs[index2].find((e) => e[0] === vec1Name[0]) ||
+//     reversedVecs[index2].find((e) => e[0] === vec1Name[0]);
+//   if (sameOrigin)
+//     return `on prend $${vec1Name}$ et $${sameOrigin}$. eet ${sameOrigin[1]} à projeter sur ${vec1Name}`;
+//   const sameOrigin2 =
+//     vecs[index1].find((e) => e[0] === vec2Name[0]) ||
+//     reversedVecs[index1].find((e) => e[0] === vec2Name[0]);
+//   if (sameOrigin2)
+//     return `on prend $${vec2Name}$ et $${sameOrigin2}$. ${vec2Name[1]} à projeter sur ${sameOrigin2}`;
 //   return `On a :
 // ${alignTex([[]])}
 // `;

package/lib/exercises/math/probaStat/conditional/conditionalProbaFromTableWithContext.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    situationIndex: number;
+    aCapB: number;
+    aCapBBarre: number;
+    aBarreCapB: number;
+    aBarreCapBBarre: number;
+    knowing: "A" | "\\overline{A}" | "B" | "\\overline{B}";
+    asked: "A" | "\\overline{A}" | "B" | "\\overline{B}";
+};
+export declare const conditionalProbaFromTableWithContext: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=conditionalProbaFromTableWithContext.d.ts.map

package/lib/exercises/math/probaStat/conditional/conditionalProbaFromTableWithContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionalProbaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/conditional/conditionalProbaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,GAAG,GAAG,eAAe,GAAG,GAAG,GAAG,eAAe,CAAC;IACvD,KAAK,EAAE,GAAG,GAAG,eAAe,GAAG,GAAG,GAAG,eAAe,CAAC;CACtD,CAAC;AA+NF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAsBtE,CAAC"}