math-exercises 3.0.178 → 3.0.180

package/lib/exercises/math/derivation/variations/signVarTableQuotientFExp.js

@@ -0,0 +1,514 @@
+import { GeneratorOptionType, GeneratorOptionTarget, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { varSignTableVEA } from "../../../../exercises/vea/varSignTableVEA.js";
+import { InequationSymbol, } from "../../../../math/inequations/inequation.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { Trinom, TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { InequationSolutionNode } from "../../../../tree/nodes/inequations/inequationSolutionNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.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";
+import { isUnionIntervalNode, UnionIntervalNode, } from "../../../../tree/nodes/sets/unionIntervalNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const _simplifyMore = (node) => {
+    if (isMultiplyNode(node)) {
+        const nodeLeft = node.leftChild;
+        const nodeRight = node.rightChild;
+        try {
+            return multiply(nodeLeft.simplify({ forbidFactorize: true, towardsDistribute: true }), nodeRight.simplify({ forbidFactorize: true, towardsDistribute: true }));
+        }
+        catch (_) {
+            return node;
+        }
+    }
+    else {
+        return node;
+    }
+};
+const getInstructionNode = (a, b, c, isFOverExp) => {
+    const nodeF = getNodeF(a, b, c);
+    const nodeG = "x".toTree();
+    const nodeExpG = exp(nodeG);
+    return isFOverExp ? frac(nodeF, nodeExpG) : frac(nodeExpG, nodeF);
+};
+const getNodeF = (a, b, c) => {
+    if (a !== undefined) {
+        return TrinomConstructor.fromCoeffs([c, b, a]).toTree().simplify();
+    }
+    else if (b !== undefined) {
+        return AffineConstructor.fromCoeffs([c, b]).toTree().simplify();
+    }
+    else {
+        return c.toTree();
+    }
+};
+const getRootNodesOfDerivative = (a, b, c) => {
+    //get coeffs
+    let coeffs;
+    if (a !== undefined) {
+        coeffs = zip([c, b, a], [b, 2 * a, 0]).map(([c1, c2]) => c1 - c2);
+    }
+    else {
+        coeffs = zip([c, b], [b, 0]).map(([c1, c2]) => c1 - c2);
+    }
+    //get roots
+    if (coeffs.length === 3) {
+        const trinom = TrinomConstructor.fromCoeffs(coeffs);
+        return trinom.getRootsNode();
+    }
+    else {
+        const [c, b] = coeffs;
+        return [frac(opposite(c), b).simplify()];
+    }
+};
+const getTrinomInequationSolutionNode = (coeffs, ineqType) => {
+    const [c, b, a] = coeffs;
+    const ineq = new InequationSymbol(ineqType);
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const aPositive = a > 0;
+    const insideInterval = new IntervalNode(roots[0], roots[1], ineq.isStrict ? ClosureType.OO : ClosureType.FF);
+    const outsideUnion = new UnionIntervalNode([
+        new IntervalNode(MinusInfinityNode, roots[0], ineq.isStrict ? ClosureType.OO : ClosureType.OF),
+        new IntervalNode(roots[1], PlusInfinityNode, ineq.isStrict ? ClosureType.OO : ClosureType.FO),
+    ]);
+    const tree = ineq.isSup
+        ? aPositive
+            ? outsideUnion
+            : insideInterval
+        : aPositive
+            ? insideInterval
+            : outsideUnion;
+    return new InequationSolutionNode(tree);
+};
+const getInstruction = (identifiers) => {
+    const { coeffsF, isFOverExp } = identifiers;
+    const [c, b, a] = coeffsF;
+    const nodeH = getInstructionNode(a, b, c, isFOverExp);
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par : 
+
+$$
+h(x) = ${nodeH.toTex()}
+$$
+
+Dresser le tableau de signes de $h'$ et de variations de $h$.
+
+`;
+};
+const getInitTable = (identifiers) => {
+    const { coeffsF } = identifiers;
+    const [c, b, a] = coeffsF;
+    const nbRoots = getRootNodesOfDerivative(a, b, c).length;
+    if (nbRoots === 1) {
+        return [
+            ["$x$", "", "\\ ", "", "\\ ", ""],
+            //sign
+            ["$h'(x)$", "\\ ", "", "", "", "\\ "],
+            //var
+            ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+            ["$h(x)$", "\\ ", "", "", "", "\\ "],
+            ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+        ];
+    }
+    else {
+        return [
+            ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+            //sign
+            ["$h'(x)$", "\\ ", "", "", "", "", "", "\\ "],
+            //var
+            ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+            ["$h(x)$", "\\ ", "", "", "", "", "", "\\ "],
+            ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+        ];
+    }
+};
+const getAnswerTable = (identifiers) => {
+    const { coeffsF, isFOverExp } = identifiers;
+    const [c, b, a] = coeffsF;
+    const rootNodes = getRootNodesOfDerivative(a, b, c);
+    const nodeH = getInstructionNode(a, b, c, isFOverExp);
+    const nodeHPrime = nodeH.derivative();
+    if (rootNodes.length === 1) {
+        const [rootNode] = rootNodes;
+        const rootNodeMinus1 = substract(rootNode, 1);
+        const hPrimeRootMinus1 = nodeHPrime.evaluate({
+            x: rootNodeMinus1.evaluate(),
+        });
+        const [strSignHPrimeRootMinus1, strSignHPrimeRootPlus1] = hPrimeRootMinus1 > 0 ? ["+", "-"] : ["-", "+"];
+        const nodeHRoot = nodeH
+            .toDetailedEvaluation({
+            x: rootNode,
+        })
+            .simplify();
+        return [
+            ["$x$", "-\\infty", "\\ ", rootNode.toTex(), "\\ ", "+\\infty"],
+            //sign
+            [
+                "$h'(x)$",
+                "\\ ",
+                strSignHPrimeRootMinus1,
+                "0",
+                strSignHPrimeRootPlus1,
+                "\\ ",
+            ],
+            //var
+            ...(strSignHPrimeRootMinus1 === "+"
+                ? [
+                    ["$\\ $", "\\ ", "\\ ", nodeHRoot.toTex(), "\\ ", "\\ "],
+                    ["$h(x)$", "\\ ", "\\nearrow", "\\ ", "\\searrow", "\\ "],
+                    ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+                ]
+                : [
+                    ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+                    ["$h(x)$", "\\ ", "\\searrow", "\\ ", "\\nearrow", "\\ "],
+                    ["$\\ $", "\\ ", "\\ ", nodeHRoot.toTex(), "\\ ", "\\ "],
+                ]),
+        ];
+    }
+    else {
+        const [rootNode1, rootNode2] = rootNodes;
+        const root1Minus1 = substract(rootNode1, 1);
+        const hPrimeRoot1Minus1 = nodeHPrime.evaluate({
+            x: root1Minus1.evaluate(),
+        });
+        const [strSignHPrimeRoot1Minus1, strSignHPrimeRootAvg, strSignHPrimeRoot2Plus1,] = hPrimeRoot1Minus1 > 0 ? ["+", "-", "+"] : ["-", "+", "-"];
+        const [nodeHRoot1, nodeHRoot2] = [rootNode1, rootNode2].map((nodeX) => nodeH
+            .toDetailedEvaluation({
+            x: nodeX,
+        })
+            .simplify());
+        return [
+            [
+                "$x$",
+                "-\\infty",
+                "\\ ",
+                rootNode1.toTex(),
+                "\\ ",
+                rootNode2.toTex(),
+                "\\ ",
+                "+\\infty",
+            ],
+            //sign
+            [
+                "$h'(x)$",
+                "\\ ",
+                strSignHPrimeRoot1Minus1,
+                "0",
+                strSignHPrimeRootAvg,
+                "0",
+                strSignHPrimeRoot2Plus1,
+                "\\ ",
+            ],
+            //var
+            ...(strSignHPrimeRoot1Minus1 === "+"
+                ? [
+                    [
+                        "$\\ $",
+                        "\\ ",
+                        "\\ ",
+                        nodeHRoot1.toTex(),
+                        "\\ ",
+                        "\\ ",
+                        "\\ ",
+                        "\\ ",
+                    ],
+                    [
+                        "$h(x)$",
+                        "\\ ",
+                        "\\nearrow",
+                        "\\ ",
+                        "\\searrow",
+                        "\\ ",
+                        "\\nearrow",
+                        "\\ ",
+                    ],
+                    [
+                        "$\\ $",
+                        "\\ ",
+                        "\\ ",
+                        "\\ ",
+                        "\\ ",
+                        nodeHRoot2.toTex(),
+                        "\\ ",
+                        "\\ ",
+                    ],
+                ]
+                : [
+                    [
+                        "$\\ $",
+                        "\\ ",
+                        "\\ ",
+                        "\\ ",
+                        "\\ ",
+                        nodeHRoot2.toTex(),
+                        "\\ ",
+                        "\\ ",
+                    ],
+                    [
+                        "$h(x)$",
+                        "\\ ",
+                        "\\searrow",
+                        "\\ ",
+                        "\\nearrow",
+                        "\\ ",
+                        "\\searrow",
+                        "\\ ",
+                    ],
+                    [
+                        "$\\ $",
+                        "\\ ",
+                        "\\ ",
+                        nodeHRoot1.toTex(),
+                        "\\ ",
+                        "\\ ",
+                        "\\ ",
+                        "\\ ",
+                    ],
+                ]),
+        ];
+    }
+};
+const getHint = () => {
+    return `Commence par déterminer la fonction dérivée $h'$ de $h$. Puis, étudie le signe de $h'$ en résolvant l'inéquation $h'(x)\\geq 0$.
+  
+Enfin, sers-toi de la propriété suivante : 
+
+- si $h'$ est positive sur un intervalle $I$, alors $h$ est croissante sur $I$;
+- si $h'$ est négative sur un intervalle $I$, alors $h$ est décroissante sur $I$.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffsF, isFOverExp } = identifiers;
+    const [c, b, a] = coeffsF;
+    const rootNodes = getRootNodesOfDerivative(a, b, c);
+    const nodeH = getInstructionNode(a, b, c, isFOverExp);
+    const nodeHPrime = nodeH.derivative();
+    if (rootNodes.length === 1) {
+        const [rootNode] = rootNodes;
+        const rootTex = rootNode.toTex();
+        const rootNodeMinus1 = substract(rootNode, 1);
+        const hPrimeRootMinus1 = nodeHPrime.evaluate({
+            x: rootNodeMinus1.evaluate(),
+        });
+        const signs = hPrimeRootMinus1 > 0 ? ["+", "-"] : ["-", "+"];
+        const signWords = signs.map((strSign) => strSign === "+" ? "positive" : "négative");
+        const words = signs.map((strSign) => strSign === "+" ? "croissante" : "décroissante");
+        const image = nodeH
+            .toDetailedEvaluation({
+            x: rootNode,
+        })
+            .simplify();
+        return `On calcule $h'$ :
+  
+$$
+h'(x) = ${nodeHPrime.simplify().toTex()}
+$$
+
+On détermine ensuite le signe de $h'(x)$ : 
+
+${alignTex([
+            ["", "h'(x) \\geq 0"],
+            ["\\iff", nodeHPrime.simplify().toTex() + "\\geq 0"],
+            [
+                "\\iff",
+                (() => {
+                    if (isFOverExp) {
+                        return frac(nodeHPrime, exp(opposite("x".toTree()))).simplify();
+                    }
+                    else {
+                        const nodeWithoutExp = frac(nodeHPrime, exp("x".toTree())).simplify();
+                        if (isFractionNode(nodeWithoutExp)) {
+                            return nodeWithoutExp.leftChild.simplify({ towardsDistribute: true });
+                        }
+                        else {
+                            return nodeWithoutExp;
+                        }
+                    }
+                })().toTex() + "\\geq 0",
+            ],
+            ["\\iff", "x" + (b > 0 ? "\\geq" : "\\leq") + rootTex],
+        ])}
+
+$h'$ est donc ${signWords[0]} sur $]-\\infty; ${rootTex}]$, puis ${signWords[1]} sur $[${rootTex}; +\\infty[$.
+
+On en conclut que $h$ est ${words[0]} sur $]-\\infty; ${rootTex}]$, puis ${words[1]} sur $[${rootTex}; +\\infty[$.
+  
+Pour compléter le tableau, il ne reste plus qu'à calculer l'image par $h$ de $${rootTex}$ : 
+
+$$
+h\\left(${rootTex}\\right) = ${image.toTex()} = ${image.simplify().toTex()}
+$$`;
+    }
+    else {
+        const coeffs = zip([c, b, a], [b, 2 * a, 0]).map(([c1, c2]) => c1 - c2);
+        const inequationSolutionNode = getTrinomInequationSolutionNode(coeffs, "\\ge");
+        const arrIntervalNode = (() => {
+            if (isUnionIntervalNode(inequationSolutionNode.intervalSolution)) {
+                return inequationSolutionNode.intervalSolution.sets;
+            }
+            else {
+                return [inequationSolutionNode.intervalSolution];
+            }
+        })();
+        return `On calcule $h'$ :
+  
+$$
+h'(x) = ${nodeHPrime.simplify().toTex()}
+$$
+
+On détermine ensuite le signe de $h'(x)$ : 
+
+${alignTex([
+            ["", "h'(x) \\geq 0"],
+            ["\\iff", nodeHPrime.simplify().toTex() + "\\geq 0"],
+            [
+                "\\iff",
+                (() => {
+                    if (isFOverExp) {
+                        return frac(nodeHPrime, exp(opposite("x".toTree()))).simplify();
+                    }
+                    else {
+                        const nodeWithoutExp = frac(nodeHPrime, exp("x".toTree())).simplify();
+                        if (isFractionNode(nodeWithoutExp)) {
+                            return nodeWithoutExp.leftChild.simplify({ towardsDistribute: true });
+                        }
+                        else {
+                            return nodeWithoutExp;
+                        }
+                    }
+                })().toTex() + "\\geq 0",
+            ],
+        ])}
+
+On résout l'inéquation :
+
+$$
+${inequationSolutionNode.toTex()}
+$$
+
+$h$ est donc croissante sur ${arrIntervalNode
+            .map((node) => `$${node.toTex()}$`)
+            .join(" et ")}.
+
+On calcule enfin les extrema locaux de $h$.
+
+`;
+    }
+};
+const getKeys = () => {
+    return ["infty"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return varSignTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const { typeF } = opts;
+    const coeffsF = (() => {
+        switch (typeF) {
+            case "affine": {
+                const b = randint(-8, 9, [0]);
+                const c = randint(-4, 5) * b;
+                return [c, b];
+            }
+            case "second degré": {
+                // return TrinomConstructor.randomNiceRoots().coefficients;
+                //we want integer roots for h'
+                const b = randint(1, 11);
+                return [1, b, 1];
+            }
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    const isFOverExp = coinFlip();
+    const identifiers = {
+        coeffsF,
+        isFOverExp,
+    };
+    return identifiers;
+};
+const getSignVarTableQuotientFExpQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers(opts);
+        try {
+            getAnswerTable(identifiersCandidate, opts);
+            isValid = true;
+        }
+        catch (_) {
+            (() => { })();
+        }
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            coeffsF: [1, 5, 1],
+            isFOverExp: true,
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        options: opts,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: getInitTable(identifiers),
+    };
+};
+const optsDefault = {
+    typeF: "affine",
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Fonction $f$",
+        type: GeneratorOptionType.select,
+        target: GeneratorOptionTarget.generation,
+        values: ["affine", "second degré"],
+        defaultValue: optsDefault.typeF,
+    },
+];
+export const signVarTableQuotientFExp = {
+    id: "signVarTableQuotientFExp",
+    label: "Dresser le tableau de variations de $x \\mapsto \\frac{f(x)}{\\exp(x)}$ ou de $x \\mapsto \\frac{\\exp(x)}{f(x)}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSignVarTableQuotientFExpQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "signVarTable",
+};

package/lib/exercises/math/functions/trinoms/sign/signOfProductOfAffineAndTrinom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signOfProductOfAffineAndTrinom.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/signOfProductOfAffineAndTrinom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA2PF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAqBhE,CAAC"}
+{"version":3,"file":"signOfProductOfAffineAndTrinom.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/signOfProductOfAffineAndTrinom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmPF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAqBhE,CAAC"}

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

@@ -66,7 +66,7 @@ const getAnswerTable = (identifiers) => {
         return "-";
     };
     const thirdLine = [
-        `$${buildF(identifiers).toTex()}$`,
+        `$f(x)$`,
         "\\ ",
         buildSign(partial[1][2], partial[2][2]),
         "0",
@@ -79,12 +79,6 @@ const getAnswerTable = (identifiers) => {
     ];
     return [...partial, thirdLine];
 };
-const buildF = (identifiers) => {
-    const { affineCoeffs, trinomCoeffs } = identifiers;
-    const affine = new Affine(affineCoeffs[1], affineCoeffs[0]);
-    const trinom = new Trinom(trinomCoeffs[2], trinomCoeffs[1], trinomCoeffs[0]);
-    return multiply(affine.toTree(), trinom.toTree());
-};
 const buildFcts = (identifiers) => {
     const { affineCoeffs, trinomCoeffs } = identifiers;
     const affine = new Affine(affineCoeffs[1], affineCoeffs[0]);
@@ -106,7 +100,7 @@ const getHint = () => {
   
 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é $g$ en trouvant ses racines.
+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.`;
 };
@@ -175,7 +169,6 @@ const getSignOfProductOfAffineAndTrinomQuestion = () => {
 };
 const getQuestionFromIdentifiers = (identifiers) => {
     const fcts = buildFcts(identifiers);
-    const f = buildF(identifiers);
     return {
         answerTable: getAnswerTable(identifiers),
         instruction: getInstruction(identifiers),
@@ -185,7 +178,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
         initTable: [
-            ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", "", "\\ ", "+\\infty"],
+            ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", "", "\\ ", ""],
             [
                 `$${fcts.affine.toTree().toTex()}$`,
                 "\\ ",
@@ -210,7 +203,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
                 "",
                 "\\ ",
             ],
-            [`$${f.toTex()}$`, "\\ ", "", "", "", "", "", "", "", "\\ "],
+            [`$f(x)$`, "\\ ", "", "", "", "", "", "", "", "\\ "],
         ],
     };
 };

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"}