math-exercises 3.0.188 → 3.0.189

package/lib/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"valueDerivativeFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgF7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0QF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgDF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"valueDerivativeFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgF7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqQF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgDF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.js

@@ -155,32 +155,37 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     const { nodeIdsXAsked, nodeIdsF } = identifiers;
     const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
     const nodeDerivative = getPrettyDerivativeNode(nodeF);
-    function tryToAddWrongPropWithSuccess(propositions, tex, format) {
+    function tryToAddWrongPropWithSuccess(propositions, func) {
         const nbPropsBefore = propositions.length;
-        tryToAddWrongProp(propositions, tex, format);
-        const nbPropsAfter = propositions.length;
-        return nbPropsAfter !== nbPropsBefore;
+        try {
+            tryToAddWrongProp(propositions, func());
+            const nbPropsAfter = propositions.length;
+            return nbPropsAfter !== nbPropsBefore;
+        }
+        catch (_) {
+            return false;
+        }
     }
     propWhile(propositions, n, () => {
-        if (!tryToAddWrongPropWithSuccess(propositions, (() => {
+        if (!tryToAddWrongPropWithSuccess(propositions, () => {
             const nodeFShuffled = NodeShuffler.deepShuffle(nodeF);
             const identifiersWrong = {
                 ...identifiers,
                 nodeIdsF: nodeFShuffled.toIdentifiers(),
             };
             return getAnswer(identifiersWrong);
-        })())) {
-            if (!tryToAddWrongPropWithSuccess(propositions, (() => {
+        })) {
+            if (!tryToAddWrongPropWithSuccess(propositions, () => {
                 const nodeDerivativeShuffled = NodeShuffler.deepShuffle(nodeDerivative);
                 const nodeWrong = nodeBySubstitutingVar(nodeDerivativeShuffled, nodeXAsked, "x".toTree()).simplify();
                 return nodeWrong.simplify().toTex();
-            })())) {
+            })) {
                 try {
-                    tryToAddWrongPropWithSuccess(propositions, (() => {
+                    tryToAddWrongPropWithSuccess(propositions, () => {
                         const typeF = random(arrayedOptsDefault.typeF);
                         const identifiersWrong = createRandomIdentifiers(typeF);
                         return getAnswer(identifiersWrong);
-                    })());
+                    });
                 }
                 catch (_) {
                     tryToAddWrongProp(propositions, randint(-20, 20).frenchify());
@@ -214,48 +219,50 @@ const createRandomIdentifiers = (typeF) => {
     };
     return identifiers;
 };
-const getValueDerivativeFromFunctionExpressionQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        const { nodeIdsXAsked, nodeIdsF } = identifiers;
+        const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+        const nodeDerivative = getPrettyDerivativeNode(nodeF);
+        let isExploding = false;
+        try {
+            const _nodeValueFunction = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+            const _nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+            getAnswer(identifiers);
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const createQCPassedIdentifiers = (typeF) => {
     let identifiers;
-    let isValid = false;
     let counter = -1;
+    let isValid = false;
     while (!isValid && counter < 100) {
         counter++;
         const identifiersCandidate = createRandomIdentifiers(typeF);
-        const isExploding = (identifiers) => {
-            const { nodeIdsXAsked, nodeIdsF } = identifiers;
-            const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-            const nodeDerivative = getPrettyDerivativeNode(nodeF);
-            let isExploding = false;
-            try {
-                const _nodeValueFunction = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
-                const _nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
-            }
-            catch (_) {
-                isExploding = true;
-            }
-            return isExploding;
-        };
-        isValid = !isExploding(identifiersCandidate);
+        isValid = isIdentifiersQCPassed(identifiersCandidate);
         if (isValid) {
             identifiers = identifiersCandidate;
         }
     }
     if (!isValid) {
         const identifiersDefault = {
-            nodeIdsXAsked: {
-                id: 7,
-                value: 3,
-            },
-            nodeIdsF: {
-                id: 10,
-                name: "x",
-            },
+            nodeIdsXAsked: (3).toTree().toIdentifiers(),
+            nodeIdsF: "x".toTree().toIdentifiers(),
             typeF: "$x$",
         };
         identifiers = identifiersDefault;
     }
+    return identifiers;
+};
+const getValueDerivativeFromFunctionExpressionQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    const identifiers = createQCPassedIdentifiers(typeF);
     return getQuestionFromIdentifiers(identifiers);
 };
 const getQuestionFromIdentifiers = (identifiers) => {

package/lib/exercises/math/derivation/variations/findExtremaFromFunctionExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findExtremaFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/findExtremaFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA+R7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAwUF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoCF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqB1E,CAAC"}
+{"version":3,"file":"findExtremaFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/findExtremaFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkS7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAiSF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoCF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqB1E,CAAC"}

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

@@ -14,7 +14,11 @@ import { SetVEA } from "../../../../exercises/vea/setVEA.js";
 import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
 import { probaFlip } from "../../../../utils/alea/probaFlip.js";
 import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { NodeUtils } from "../../../../tree/utilities/nodeUtils.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
 const tryToSimplify = (node, simplifyOptions) => {
     try {
         return node.simplify(simplifyOptions);
@@ -399,7 +403,16 @@ const isIdentifiersQCPassed = (identifiers) => {
             return false;
         }
     };
-    return isSolutionPrettyAndNotExploding(identifiers);
+    const isVEAOk = (identifiers) => {
+        try {
+            const answer = getAnswer(identifiers);
+            return isAnswerValid(answer, { answer, ...identifiers });
+        }
+        catch (_) {
+            return false;
+        }
+    };
+    return isSolutionPrettyAndNotExploding(identifiers) && isVEAOk(identifiers);
 };
 const getFindExtremaFromFunctionExpressionQuestion = (optsIn) => {
     const arrayedOptions = optsIn ?? arrayedOptsDefault;
@@ -418,67 +431,9 @@ const getFindExtremaFromFunctionExpressionQuestion = (optsIn) => {
     }
     if (!isValid) {
         // console.log("will use identifiersDefault");
+        const nodeF = frac(add(multiply(30, new VariableNode("x")), 10), add(add(multiply(6, power(new VariableNode("x"), 2)), multiply(3, new VariableNode("x"))), 1));
         const identifiersDefault = {
-            nodeIdsF: {
-                id: 3,
-                leftChild: {
-                    id: 0,
-                    leftChild: {
-                        id: 2,
-                        leftChild: {
-                            id: 7,
-                            value: 30,
-                        },
-                        rightChild: {
-                            id: 10,
-                            name: "x",
-                        },
-                    },
-                    rightChild: {
-                        id: 7,
-                        value: 10,
-                    },
-                },
-                rightChild: {
-                    id: 0,
-                    leftChild: {
-                        id: 0,
-                        leftChild: {
-                            id: 2,
-                            leftChild: {
-                                id: 7,
-                                value: 6,
-                            },
-                            rightChild: {
-                                id: 5,
-                                leftChild: {
-                                    id: 10,
-                                    name: "x",
-                                },
-                                rightChild: {
-                                    id: 7,
-                                    value: 2,
-                                },
-                            },
-                        },
-                        rightChild: {
-                            id: 2,
-                            leftChild: {
-                                id: 7,
-                                value: 3,
-                            },
-                            rightChild: {
-                                id: 10,
-                                name: "x",
-                            },
-                        },
-                    },
-                    rightChild: {
-                        id: 7,
-                        value: 1,
-                    },
-                },
-            },
+            nodeIdsF: nodeF.toIdentifiers(),
             typeF: "$\\frac{dx+m}{ax^2+bx+c}$",
             typeRoots: "entières",
         };

package/lib/exercises/math/derivation/variations/signVarTableQuotientFExp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signVarTableQuotientFExp.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/signVarTableQuotientFExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAsIrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAubF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAiBF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBnE,CAAC"}
+{"version":3,"file":"signVarTableQuotientFExp.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/signVarTableQuotientFExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AA6HrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAqbF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAiBF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBnE,CAAC"}

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

@@ -10,29 +10,27 @@ 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 { NodeSimplifier } from "../../../../tree/utilities/nodeSimplifier.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;
+const tryToSimplify = (node) => {
+    try {
+        return NodeSimplifier.simplifyByVibrating(node, 5, true);
+    }
+    catch (_) {
         try {
-            return multiply(nodeLeft.simplify({ forbidFactorize: true, towardsDistribute: true }), nodeRight.simplify({ forbidFactorize: true, towardsDistribute: true }));
+            return NodeSimplifier.simplifyByVibrating(node, 5, false);
         }
         catch (_) {
             return node;
         }
     }
-    else {
-        return node;
-    }
 };
 const getInstructionNode = (a, b, c, isFOverExp) => {
     const nodeF = getNodeF(a, b, c);
@@ -42,10 +40,10 @@ const getInstructionNode = (a, b, c, isFOverExp) => {
 };
 const getNodeF = (a, b, c) => {
     if (a !== undefined) {
-        return TrinomConstructor.fromCoeffs([c, b, a]).toTree().simplify();
+        return tryToSimplify(TrinomConstructor.fromCoeffs([c, b, a]).toTree());
     }
     else if (b !== undefined) {
-        return AffineConstructor.fromCoeffs([c, b]).toTree().simplify();
+        return tryToSimplify(AffineConstructor.fromCoeffs([c, b]).toTree());
     }
     else {
         return c.toTree();
@@ -67,7 +65,7 @@ const getRootNodesOfDerivative = (a, b, c) => {
     }
     else {
         const [c, b] = coeffs;
-        return [frac(opposite(c), b).simplify()];
+        return [tryToSimplify(frac(opposite(c), b))];
     }
 };
 const getTrinomInequationSolutionNode = (coeffs, ineqType) => {
@@ -144,11 +142,9 @@ const getAnswerTable = (identifiers) => {
             x: rootNodeMinus1.evaluate(),
         });
         const [strSignHPrimeRootMinus1, strSignHPrimeRootPlus1] = hPrimeRootMinus1 > 0 ? ["+", "-"] : ["-", "+"];
-        const nodeHRoot = nodeH
-            .toDetailedEvaluation({
+        const nodeHRoot = tryToSimplify(nodeH.toDetailedEvaluation({
             x: rootNode,
-        })
-            .simplify();
+        }));
         return [
             ["$x$", "-\\infty", "\\ ", rootNode.toTex(), "\\ ", "+\\infty"],
             //sign
@@ -181,11 +177,9 @@ const getAnswerTable = (identifiers) => {
             x: root1Minus1.evaluate(),
         });
         const [strSignHPrimeRoot1Minus1, strSignHPrimeRootAvg, strSignHPrimeRoot2Plus1,] = hPrimeRoot1Minus1 > 0 ? ["+", "-", "+"] : ["-", "+", "-"];
-        const [nodeHRoot1, nodeHRoot2] = [rootNode1, rootNode2].map((nodeX) => nodeH
-            .toDetailedEvaluation({
+        const [nodeHRoot1, nodeHRoot2] = [rootNode1, rootNode2].map((nodeX) => tryToSimplify(nodeH.toDetailedEvaluation({
             x: nodeX,
-        })
-            .simplify());
+        })));
         return [
             [
                 "$x$",
@@ -301,32 +295,30 @@ const getCorrection = (identifiers) => {
         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({
+        const image = tryToSimplify(nodeH.toDetailedEvaluation({
             x: rootNode,
-        })
-            .simplify();
+        }));
         return `On calcule $h'$ :
   
 $$
-h'(x) = ${nodeHPrime.simplify().toTex()}
+h'(x) = ${tryToSimplify(nodeHPrime).toTex()}
 $$
 
 On détermine ensuite le signe de $h'(x)$ : 
 
 ${alignTex([
             ["", "h'(x) \\geq 0"],
-            ["\\iff", nodeHPrime.simplify().toTex() + "\\geq 0"],
+            ["\\iff", tryToSimplify(nodeHPrime).toTex() + "\\geq 0"],
             [
                 "\\iff",
                 (() => {
                     if (isFOverExp) {
-                        return frac(nodeHPrime, exp(opposite("x".toTree()))).simplify();
+                        return tryToSimplify(frac(nodeHPrime, exp(opposite("x".toTree()))));
                     }
                     else {
-                        const nodeWithoutExp = frac(nodeHPrime, exp("x".toTree())).simplify();
+                        const nodeWithoutExp = tryToSimplify(frac(nodeHPrime, exp("x".toTree())));
                         if (isFractionNode(nodeWithoutExp)) {
-                            return nodeWithoutExp.leftChild.simplify({ towardsDistribute: true });
+                            return tryToSimplify(nodeWithoutExp.leftChild);
                         }
                         else {
                             return nodeWithoutExp;
@@ -344,7 +336,7 @@ On en conclut que $h$ est ${words[0]} sur $]-\\infty; ${rootTex}]$, puis ${words
 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()}
+h\\left(${rootTex}\\right) = ${image.toTex()} = ${tryToSimplify(image).toTex()}
 $$`;
     }
     else {
@@ -361,24 +353,24 @@ $$`;
         return `On calcule $h'$ :
   
 $$
-h'(x) = ${nodeHPrime.simplify().toTex()}
+h'(x) = ${tryToSimplify(nodeHPrime).toTex()}
 $$
 
 On détermine ensuite le signe de $h'(x)$ : 
 
 ${alignTex([
             ["", "h'(x) \\geq 0"],
-            ["\\iff", nodeHPrime.simplify().toTex() + "\\geq 0"],
+            ["\\iff", tryToSimplify(nodeHPrime).toTex() + "\\geq 0"],
             [
                 "\\iff",
                 (() => {
                     if (isFOverExp) {
-                        return frac(nodeHPrime, exp(opposite("x".toTree()))).simplify();
+                        return tryToSimplify(frac(nodeHPrime, exp(opposite("x".toTree()))));
                     }
                     else {
-                        const nodeWithoutExp = frac(nodeHPrime, exp("x".toTree())).simplify();
+                        const nodeWithoutExp = tryToSimplify(frac(nodeHPrime, exp("x".toTree())));
                         if (isFractionNode(nodeWithoutExp)) {
-                            return nodeWithoutExp.leftChild.simplify({ towardsDistribute: true });
+                            return tryToSimplify(nodeWithoutExp.leftChild);
                         }
                         else {
                             return nodeWithoutExp;

package/lib/exercises/math/functions/affines/adjustment/affineAdjustment.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    xValues: number[];
+    yValues: number[];
+};
+export declare const affineAdjustmentExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=affineAdjustment.d.ts.map

package/lib/exercises/math/functions/affines/adjustment/affineAdjustment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineAdjustment.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/affines/adjustment/affineAdjustment.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA8KF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/math/functions/affines/adjustment/affineAdjustment.js

@@ -0,0 +1,129 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { leastSquares } from "../../../../../math/utils/stats/leastSquares.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 { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { SubstractNode } from "../../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { dollarize } from "../../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../../utils/markdown/mdTable.js";
+const getInstruction = ({ xValues, yValues }) => {
+    const dataTable = mdTable([
+        ["$x$", ...xValues.map((n) => dollarize(n.frenchify()))],
+        ["$y$", ...yValues.map((n) => dollarize(n.frenchify()))],
+    ]);
+    return `On considère la série statistique ci-dessous. Déterminer l'équation de la droite d'ajustement obtenue par la méthode des moindres carrés. 
+
+${dataTable}
+
+Arrondir les coefficients au dixième.
+`;
+};
+function generateLinearData(n) {
+    const slope = randint(-500, 500, [0]) / 100;
+    const intercept = randint(100, 5000) / 100;
+    const data = [];
+    const generatedXs = new Set();
+    let counter = 0;
+    while (data.length < n) {
+        counter++;
+        if (counter > 1000) {
+            throw new Error("affineAdjustement too many iterations");
+        }
+        let x = randint(1, 100);
+        let cnt = 0;
+        while (generatedXs.has(x)) {
+            cnt++;
+            if (cnt > 1000) {
+                throw new Error("affineAdjustement too many iterations");
+            }
+            x = randint(1, 100);
+        }
+        generatedXs.add(x);
+        const y = round(slope * x + intercept, 2);
+        data.push({ x, y });
+    }
+    return data;
+}
+const getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const { a, b } = leastSquares(xValues, yValues);
+    const aFixed = round(a, 1);
+    const bFixed = round(b, 1);
+    const answer = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    return answer;
+};
+const getAffineAdjustmentQuestion = () => {
+    const data = generateLinearData(5);
+    data.sort((a, b) => a.x - b.x);
+    const xValues = data.map((point) => point.x);
+    const yValues = data.map((point) => point.y);
+    const identifiers = { xValues, yValues };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["equal", "y", "x", "a", "b"],
+        answerFormat: "tex",
+        identifiers,
+        style: {
+            tableOptions: {
+                firstCellIsDivided: false,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xValues, yValues }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "tex");
+    const { a, b } = leastSquares(xValues, yValues);
+    const aFixed = round(a, 1);
+    const bFixed = round(b, 1);
+    const wrongAnswer1 = new EqualNode(new VariableNode("y"), new SubstractNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true }));
+    const awrong = randfloat(-5, 5, 1, [0]);
+    const bwrong = randfloat(-20, 20, 1);
+    const wrongAnswer2 = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(round(awrong, 1)), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true }));
+    const wrongAnswer3 = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(round(bwrong, 1))).simplify({ forbidFactorize: true }));
+    const wrongAnswer4 = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(round(awrong, 1)), new VariableNode("x")), new NumberNode(round(bwrong, 1))).simplify({ forbidFactorize: true }));
+    tryToAddWrongProp(propositions, wrongAnswer1.toTex());
+    tryToAddWrongProp(propositions, wrongAnswer2.toTex());
+    tryToAddWrongProp(propositions, wrongAnswer3.toTex());
+    tryToAddWrongProp(propositions, wrongAnswer4.toTex());
+    propWhile(propositions, n, () => {
+        const a = randint(-10, 10, [0]);
+        const b = randint(-10, 10);
+        const wrongAnswer = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(a), new VariableNode("x")), new NumberNode(b)).simplify({ forbidFactorize: true }));
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { xValues, yValues }) => {
+    const { a, b } = leastSquares(xValues, yValues);
+    const aFixed = round(a, 1);
+    const bFixed = round(b, 1);
+    const valid = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true }));
+    const latexs = valid.toAllValidTexs({ allowRawRightChildAsSolution: true });
+    return latexs.includes(ans);
+};
+export const affineAdjustmentExercise = {
+    id: "affineAdjustment",
+    label: "Déterminer l'équation de la droite d'ajustement à partir d'un tableau de données",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getAffineAdjustmentQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/functions/affines/adjustment/affineAdjustmentComplete.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    xValues: number[];
+    yValues: number[];
+};
+export declare const affineAdjustmentCompleteExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=affineAdjustmentComplete.d.ts.map

package/lib/exercises/math/functions/affines/adjustment/affineAdjustmentComplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineAdjustmentComplete.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/affines/adjustment/affineAdjustmentComplete.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA4JF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}