math-exercises 3.0.188 → 3.0.190

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

@@ -14,7 +14,12 @@ 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";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 const tryToSimplify = (node, simplifyOptions) => {
     try {
         return node.simplify(simplifyOptions);
@@ -399,12 +404,21 @@ 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;
-    const typeF = random(arrayedOptions.typeF);
-    const typeRoots = random(arrayedOptions.typeRoots);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
+    const typeRoots = random(arrayedOpts.typeRoots);
     let identifiers;
     let isValid = false;
     let counter = -1;
@@ -418,67 +432,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/plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAQtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6J7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAubF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,iEAAiE,EAAE,QAAQ,CACtF,WAAW,EACX,OAAO,CAuBR,CAAC"}
+{"version":3,"file":"plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAQtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6J7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqbF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,iEAAiE,EAAE,QAAQ,CACtF,WAAW,EACX,OAAO,CAuBR,CAAC"}

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

@@ -1,5 +1,6 @@
 import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { blueMain, greenMain } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
@@ -313,8 +314,8 @@ const isGGBAnswerValid = (ggbAns, { ggbAnswer: _ggbAnswer, ...identifiers }) =>
     }
 };
 const getPlausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomialQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
     const [arrX, nodeF] = (() => {
         let arrX;
         let nodeF;

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

@@ -1 +1 @@
-{"version":3,"file":"plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAYtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkK7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAokBF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkCF,eAAO,MAAM,iEAAiE,EAAE,QAAQ,CACtF,WAAW,EACX,OAAO,CAuBR,CAAC"}
+{"version":3,"file":"plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAYtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkK7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkkBF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkCF,eAAO,MAAM,iEAAiE,EAAE,QAAQ,CACtF,WAAW,EACX,OAAO,CAuBR,CAAC"}

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

@@ -1,5 +1,6 @@
 import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { blueMain, greenMain, orange } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { ggbPointsToPoints } from "../../../../geogebra/parsers/ggbPointsToPoints.js";
@@ -417,8 +418,8 @@ const isGGBAnswerValid = (ggbAns, { ggbAnswer: _ggbAnswer, ...identifiers }) =>
     }
 };
 const getPlausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomialQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
     const [arrX, nodeF] = (() => {
         let arrX;
         let nodeF;

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

@@ -1 +1 @@
-{"version":3,"file":"signVarTableFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/signVarTableFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgM7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAmXF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyCF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,WAAW,EACX,OAAO,CAuBR,CAAC"}
+{"version":3,"file":"signVarTableFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/signVarTableFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgM7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkXF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyCF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,WAAW,EACX,OAAO,CAuBR,CAAC"}

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

@@ -1,5 +1,6 @@
 import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { varSignTableVEA } from "../../../../exercises/vea/varSignTableVEA.js";
 import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
 import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
@@ -374,9 +375,9 @@ const createRandomIdentifiers = (typeF, typeRoots) => {
     return identifiers;
 };
 const getSignVarTableFromFunctionExpressionQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? arrayedOptsDefault;
-    const typeF = random(arrayedOptions.typeF);
-    const typeRoots = random(arrayedOptions.typeRoots);
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const typeF = random(arrayedOpts.typeF);
+    const typeRoots = random(arrayedOpts.typeRoots);
     let identifiers;
     let isValid = false;
     let counter = -1;

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

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

@@ -0,0 +1,108 @@
+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 { generateAffineCloud } from "../../../../../math/utils/stats/generateAffineCloud.js";
+import { leastSquares } from "../../../../../math/utils/stats/leastSquares.js";
+import { rSquared } from "../../../../../math/utils/stats/rSquared.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 { PowerNode } from "../../../../../tree/nodes/operators/powerNode.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 getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const { a, b } = leastSquares(xValues, yValues);
+    const aFixed = round(a, 1);
+    const bFixed = round(b, 1);
+    const answerEq = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const r2 = round(rSquared(xValues, yValues), 2);
+    const answerR = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), r2.toTree()).toTex();
+    return `${answerEq}\\newline ${answerR}`;
+};
+const getInstruction = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    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. A l'aide de la calculatrice, déterminer l'équation de la droite d'ajustement et la valeur du coefficient de détermination. ${dataTable}
+`;
+};
+const getAffineAdjustmentCompleteQuestion = () => {
+    const data = generateAffineCloud(6);
+    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: [],
+        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 r2 = round(rSquared(xValues, yValues), 2);
+    const aFixed = round(a, 1);
+    const bFixed = round(b, 1);
+    const answerEq = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const answerR = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), r2.toTree()).toTex();
+    const wrongAnswerEq1 = new EqualNode(new VariableNode("y"), new SubstractNode(new MultiplyNode(new NumberNode(aFixed), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const awrong = randfloat(1, 10, 1);
+    const wrongAnswerEq2 = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(round(awrong, 1)), new VariableNode("x")), new NumberNode(bFixed)).simplify({ forbidFactorize: true })).toTex();
+    const wrongAnswerR1 = new EqualNode(new VariableNode("R"), r2.toTree()).toTex();
+    const wrongAnswerR2 = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), (r2 + 0.01).toTree()).toTex();
+    const wrongAnswer1 = `${answerEq}\\newline ${wrongAnswerR1}`;
+    const wrongAnswer2 = `${answerEq}\\newline ${wrongAnswerR2}`;
+    const wrongAnswer3 = `${wrongAnswerEq1}\\newline ${answerR}`;
+    const wrongAnswer4 = `${wrongAnswerEq2}\\newline ${answerR}`;
+    tryToAddWrongProp(propositions, wrongAnswer1);
+    tryToAddWrongProp(propositions, wrongAnswer2);
+    tryToAddWrongProp(propositions, wrongAnswer3);
+    tryToAddWrongProp(propositions, wrongAnswer4);
+    propWhile(propositions, n, () => {
+        const a = randint(-10, 10, [0]);
+        const b = randint(-10, 10);
+        const wrongAnswerEq = new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(a), new VariableNode("x")), new NumberNode(b)).simplify({ forbidFactorize: true })).toTex();
+        const wrongAnswerR = new EqualNode(new PowerNode(new VariableNode("R"), new NumberNode(2)), round(Math.random(), 2).toTree()).toTex();
+        const wrongAnswer = `${wrongAnswerEq}\\newline ${wrongAnswerR}`;
+        tryToAddWrongProp(propositions, wrongAnswer);
+    });
+    return shuffleProps(propositions, n);
+};
+export const affineAdjustmentCompleteExercise = {
+    id: "affineAdjustmentComplete",
+    label: "Déterminer l'équation de la droite d'ajustement et le coefficient de détermination",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getAffineAdjustmentCompleteQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+};

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

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

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

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