math-exercises 3.0.199 → 3.0.201

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

@@ -0,0 +1,222 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { varSignTableVEA } from "../../../../exercises/vea/varSignTableVEA.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getNodeF = (nodeA, nodeB, nodeC) => {
+    const nodeVarX = new VariableNode("x");
+    const nodeAffine = add(multiply(nodeA, nodeVarX), nodeB);
+    const nodeF = add(nodeAffine, multiply(nodeC, multiply(nodeVarX, new LogNode(nodeVarX))));
+    return nodeF;
+};
+const getRootNodeOfDerivativeRaw = (nodeA, _nodeB, nodeC) => {
+    //h(x) = ax+b + cxln(x)
+    //h'(x) = a + c (1 + ln(x))
+    //                 h'(x) = 0
+    //<=>  a + c ln(x) + c = 0
+    //<=>              ln(x) = -(a+c)/c
+    //<=>                  x = exp(-(a+c)/c)
+    return exp(frac(opposite(add(nodeA, nodeC)), nodeC));
+};
+const getRootNodeOfDerivativeSimplified = (nodeA, _nodeB, nodeC) => {
+    //h(x) = ax+b + cxln(x)
+    //h'(x) = a + c (1 + ln(x))
+    //                 h'(x) = 0
+    //<=>  a + c ln(x) + c = 0
+    //<=>              ln(x) = -(a+c)/c
+    //<=>                  x = exp(-(a+c)/c)
+    return exp(frac(opposite(add(nodeA, nodeC)), nodeC).simplify());
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsA, nodeIdsB, nodeIdsC } = identifiers;
+    const [nodeA, nodeB, nodeC] = [nodeIdsA, nodeIdsB, nodeIdsC].map((nodeIds) => reifyAlgebraic(nodeIds));
+    const nodeH = getNodeF(nodeA, nodeB, nodeC);
+    return `Soit $h$ la fonction définie sur $]0; +\\infty[$ par : 
+
+$$
+h(x) = ${nodeH.toTex()}
+$$
+
+Dresser le tableau de signes de $h'$ et de variations de $h$.
+
+`;
+};
+const getInitTable = (_identifiers) => {
+    return [
+        ["$x$", "", "\\ ", "", "\\ ", ""],
+        //sign
+        ["$h'(x)$", "\\ ", "", "", "", "\\ "],
+        //var
+        ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+        ["$h(x)$", "\\ ", "", "", "", "\\ "],
+        ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+    ];
+};
+const getAnswerTable = (identifiers) => {
+    const { nodeIdsA, nodeIdsB, nodeIdsC } = identifiers;
+    const [nodeA, nodeB, nodeC] = [nodeIdsA, nodeIdsB, nodeIdsC].map((nodeIds) => reifyAlgebraic(nodeIds));
+    const rootNode = getRootNodeOfDerivativeSimplified(nodeA, nodeB, nodeC);
+    const nodeH = getNodeF(nodeA, nodeB, nodeC);
+    const nodeHPrime = nodeH.derivative();
+    const rootNodePlus1 = add(rootNode, 1);
+    const hPrimeRootPlus1 = nodeHPrime.evaluate({
+        x: rootNodePlus1.evaluate(),
+    });
+    const [strSignHPrimeRootMinus, strSignHPrimeRootPlus] = hPrimeRootPlus1 < 0 ? ["+", "-"] : ["-", "+"];
+    const nodeHRoot = nodeH
+        .toDetailedEvaluation({
+        x: rootNode,
+    })
+        .simplify();
+    return [
+        ["$x$", "0", "\\ ", rootNode.toTex(), "\\ ", "+\\infty"],
+        //sign
+        [
+            "$h'(x)$",
+            "\\ ",
+            strSignHPrimeRootMinus,
+            "0",
+            strSignHPrimeRootPlus,
+            "\\ ",
+        ],
+        //var
+        ...(strSignHPrimeRootMinus === "+"
+            ? [
+                ["$\\ $", "\\ ", "\\ ", nodeHRoot.toTex(), "\\ ", "\\ "],
+                ["$h(x)$", "\\ ", "\\nearrow", "\\ ", "\\searrow", "\\ "],
+                ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+            ]
+            : [
+                ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+                ["$h(x)$", "\\ ", "\\searrow", "\\ ", "\\nearrow", "\\ "],
+                ["$\\ $", "\\ ", "\\ ", nodeHRoot.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 { nodeIdsA, nodeIdsB, nodeIdsC } = identifiers;
+    const [nodeA, nodeB, nodeC] = [nodeIdsA, nodeIdsB, nodeIdsC].map((nodeIds) => reifyAlgebraic(nodeIds));
+    const rootNodeRaw = getRootNodeOfDerivativeRaw(nodeA, nodeB, nodeC);
+    const rootNode = getRootNodeOfDerivativeSimplified(nodeA, nodeB, nodeC);
+    const nodeH = getNodeF(nodeA, nodeB, nodeC);
+    const nodeHPrime = nodeH.derivative();
+    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 nodeImage = nodeBySubstitutingVar(nodeH, rootNode, new VariableNode("x"));
+    //                 h'(x) >= 0
+    //<=>  a + c ln(x) + c   >= 0
+    //<=>              ln(x) >= -(a+c)/c      if (c > 0)
+    //<=>                  x >= exp(-(a+c)/c) if (c > 0)
+    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",
+            `x ${nodeC.evaluate() > 0 ? "\\geq" : "\\leq"} ${rootNodeRaw.toTex()}`,
+        ],
+        ["\\iff", `x ${nodeC.evaluate() > 0 ? "\\geq" : "\\leq"} ${rootTex}`],
+    ])}
+
+$h'$ est donc ${signWords[0]} sur $]0; ${rootTex}]$, puis ${signWords[1]} sur $[${rootTex}; +\\infty[$.
+
+On en conclut que $h$ est ${words[0]} sur $]0; ${rootTex}]$, puis ${words[1]} sur $[${rootTex}; +\\infty[$.
+  
+Pour compléter le tableau, il ne reste plus qu'à calculer l'image par $h$ de $${rootTex}$ : 
+
+${(() => {
+        const texImage1 = nodeImage.toTex();
+        const texImage2 = nodeImage.simplify().toTex();
+        return `
+  
+${alignTex([
+            [`h\\left(${rootTex}\\right)`, "=", nodeImage.toTex()],
+            ...(texImage2 !== texImage1 ? [["", "=", texImage2]] : []),
+        ])}
+
+  `;
+    })()}
+
+`;
+};
+const getKeys = () => {
+    return ["epower", "infty"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return varSignTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSignVarTableAffinePlusCXLogXQuestion = () => {
+    const [nodeA, nodeB, nodeC] = ["a", "b", "c"].map(() => randint(-9, 10, [0]).toTree());
+    const identifiers = {
+        nodeIdsA: nodeA.toIdentifiers(),
+        nodeIdsB: nodeB.toIdentifiers(),
+        nodeIdsC: nodeC.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+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),
+    };
+};
+export const signVarTableAffinePlusCXLogX = {
+    id: "signVarTableAffinePlusCXLogX",
+    label: "Dresser le tableau de variations de $x \\mapsto ax+b + cx\\ln(x)$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSignVarTableAffinePlusCXLogXQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "signVarTable",
+};

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

@@ -93,7 +93,7 @@ const getInstruction = (identifiers) => {
     const { coeffsF } = identifiers;
     const [c, b, a] = coeffsF;
     const nodeH = getInstructionNode(a, b, c);
-    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par : 
+    return `Soit $h$ la fonction définie sur $\\mathbb{R}$ par : 
 
 $$
 h(x) = ${nodeH.toTex()}

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

@@ -92,7 +92,7 @@ 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 : 
+    return `Soit $h$ la fonction définie sur $\\mathbb{R}$ par : 
 
 $$
 h(x) = ${nodeH.toTex()}

package/lib/exercises/math/functions/affines/affineVarTableOnBoundedInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affineVarTableOnBoundedInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineVarTableOnBoundedInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AA8KF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAqBjE,CAAC"}
+{"version":3,"file":"affineVarTableOnBoundedInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineVarTableOnBoundedInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AA6KF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAqBjE,CAAC"}

package/lib/exercises/math/functions/affines/affineVarTableOnBoundedInterval.js

@@ -10,14 +10,13 @@ const getInstruction = (identifiers) => {
     const [nodeX1, nodeX2] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
     const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
     const strInterval = `[${nodeX1.toTex()};${nodeX2.toTex()}]`;
-    return `Dresser le tableau de variations de la fonction $f$ sur l'intervalle $${strInterval}$.
-  
-On donne, pour tout $x$ dans $${strInterval}$ :
+    return `Soit $f$ la fonction définie sur $${strInterval}$ par :
 
 $$
 f(x) = ${nodeF.toTex()}
 $$
 
+Dresser le tableau de variations de la fonction $f$ sur l'intervalle $${strInterval}$.
 `;
 };
 const getAnswerTable = (identifiers) => {

package/lib/exercises/math/functions/affines/index.d.ts

@@ -20,6 +20,11 @@ export * from "./drawAffineFromPointAndLeadingCoeff.js";
 export * from "./drawAffineFromProgCalc.js";
 export * from "./placePointsFromAffine.js";
 export * from "./recognizeAffinePointsFromPoints.js";
+export * from "./affineVariations.js";
+export * from "./affineVariationsFromTwoImages.js";
+export * from "./affineVariationsFromGraph.js";
+export * from "./affineCompareTwoImagesFromVariations.js";
+export * from "./affineVarTableOnBoundedInterval.js";
 export * from "./adjustment/index.js";
 export * from "./situations/index.js";
 export * from "./affineVariations.js";

package/lib/exercises/math/functions/affines/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AAEnD,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yCAAyC,CAAC;AACxD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AACrD,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AAEnD,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yCAAyC,CAAC;AACxD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AACrD,cAAc,uBAAuB,CAAC;AACtC,cAAc,oCAAoC,CAAC;AACnD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,sCAAsC,CAAC;AACrD,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/functions/affines/index.js

@@ -20,6 +20,11 @@ export * from "./drawAffineFromPointAndLeadingCoeff.js";
 export * from "./drawAffineFromProgCalc.js";
 export * from "./placePointsFromAffine.js";
 export * from "./recognizeAffinePointsFromPoints.js";
+export * from "./affineVariations.js";
+export * from "./affineVariationsFromTwoImages.js";
+export * from "./affineVariationsFromGraph.js";
+export * from "./affineCompareTwoImagesFromVariations.js";
+export * from "./affineVarTableOnBoundedInterval.js";
 export * from "./adjustment/index.js";
 export * from "./situations/index.js";
 export * from "./affineVariations.js";

package/lib/exercises/math/functions/integral/index.d.ts

@@ -7,4 +7,5 @@ export * from "./integralExpU.js";
 export * from "./integralExpAxPlusB.js";
 export * from "./integralDerivatedUSinU.js";
 export * from "./integralDerivatedUCosU.js";
+export * from "./integralTrinomialOverX2.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/integral/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/integral/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/integral/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC"}

package/lib/exercises/math/functions/integral/index.js

@@ -7,3 +7,4 @@ export * from "./integralExpU.js";
 export * from "./integralExpAxPlusB.js";
 export * from "./integralDerivatedUSinU.js";
 export * from "./integralDerivatedUCosU.js";
+export * from "./integralTrinomialOverX2.js";

package/lib/exercises/math/functions/integral/integralTrinomialOverX2.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsF: NodeIdentifiers;
+    nodeIdsBounds: [NodeIdentifiers, NodeIdentifiers];
+};
+type Options = {
+    orderOfP: string;
+};
+export declare const integralTrinomialOverX2: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=integralTrinomialOverX2.d.ts.map

package/lib/exercises/math/functions/integral/integralTrinomialOverX2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integralTrinomialOverX2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/integral/integralTrinomialOverX2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;CACnD,CAAC;AAoTF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAelE,CAAC"}

package/lib/exercises/math/functions/integral/integralTrinomialOverX2.js

@@ -0,0 +1,280 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { PolynomialConstructor } from "../../../../math/polynomials/polynomial.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { getArrNodeCoeffOfPolynomialNode } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { IntegralNode } from "../../../../tree/nodes/functions/integralNode.js";
+import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds } = identifiers;
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeP = nodeF.leftChild;
+    const arrNodeCoeff = getArrNodeCoeffOfPolynomialNode(nodeP);
+    const nodeVarX = new VariableNode("x");
+    const arrNodeTerm = zip([frac(1, square(nodeVarX)), frac(1, nodeVarX), 1], arrNodeCoeff).map(([nodeFunction, nodeCoeff]) => multiply(nodeCoeff, nodeFunction));
+    const nodeFRewritten = arrNodeTerm.toReversed().reduce((acc, node, i) => {
+        if (i === 0) {
+            return node;
+        }
+        else {
+            return add(acc, node);
+        }
+    }, (0).toTree());
+    //int(1/x²) = -1/x
+    //int(1/x) = ln(x)
+    //int(1) = x
+    const arrNodePrimitive = zip([frac(-1, nodeVarX), new LogNode(nodeVarX), nodeVarX], arrNodeCoeff).map(([nodeFunction, nodeCoeff]) => multiply(nodeCoeff, nodeFunction));
+    const nodePrimitiveOfF = arrNodePrimitive
+        .toReversed()
+        .reduce((acc, nodeCoeff, i) => {
+        if (i === 0) {
+            return nodeCoeff;
+        }
+        else {
+            return add(acc, nodeCoeff);
+        }
+    }, (0).toTree());
+    const nodeIntegral = new IntegralNode(nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh, "x");
+    const nodeIntegralAsSub = substract(nodeBySubstitutingVar(nodePrimitiveOfF, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodePrimitiveOfF, nodeIntegralBoundLow, nodeVarX));
+    return {
+        nodeF,
+        nodeFRewritten,
+        nodeIntegralBoundLow,
+        nodeIntegralBoundHigh,
+        arrNodeTerm,
+        arrNodePrimitive,
+        nodePrimitiveOfF,
+        nodeIntegral,
+        nodeIntegralAsSub,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIntegral } = getHydrated(identifiers);
+    return `Calculer :
+
+$$
+${nodeIntegral.toTex()}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIntegralAsSub } = getHydrated(identifiers);
+    return nodeIntegralAsSub
+        .simplify({
+        towardsDistribute: true,
+        forceAddFractions: true,
+    })
+        .toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeF, nodeFRewritten } = getHydrated(identifiers);
+    return `On peut réécrire la fonction dans l'intégrale pour faire apparaître des fonctions connues :
+
+$$
+${nodeF.toTex()}
+$$
+
+$$
+=
+$$
+
+$$
+${nodeFRewritten.toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralBoundHigh, nodeIntegralBoundLow, nodeF, nodeFRewritten, nodeIntegral, nodeIntegralAsSub, nodePrimitiveOfF, arrNodeTerm, arrNodePrimitive, } = getHydrated(identifiers);
+    return `On a :
+
+Pour tout $x$ réel,
+
+$$
+${nodeF.toTex()}
+$$
+
+$$
+=
+$$
+
+$$
+${nodeFRewritten.toTex()}
+$$
+
+${zip(arrNodeTerm, arrNodePrimitive)
+        .toReversed()
+        .map(([nodeTerm, nodePrimitive]) => `Une primitive de $x \\mapsto ${nodeTerm.toTex()}$ est $x \\mapsto ${nodePrimitive.toTex()}$.`).join(`
+  
+`)}
+
+On a donc :
+
+${alignTex([
+        [
+            nodeIntegral.toTex(),
+            "=",
+            `\\left[ ${nodePrimitiveOfF.toTex()} \\right]_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}}`,
+        ],
+        [
+            "",
+            "=",
+            nodeIntegralAsSub
+                .simplify({
+                towardsDistribute: true,
+                forceAddFractions: true,
+            })
+                .toTex(),
+        ],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        try {
+            const identifierWrong = createRandomIdentifiers(opts);
+            tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+        }
+        catch (_) {
+            (() => { })();
+        }
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["ln"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        const isValid = NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer);
+        return isValid;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const valueOrderOfP = parseInt(opts.orderOfP);
+    const nodeP = PolynomialConstructor.randomWithOrder(valueOrderOfP).toTree();
+    const nodeF = frac(nodeP, square(new VariableNode("x")));
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = [
+        randint(1, 6).toTree(),
+        randint(6, 11).toTree(),
+    ];
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsBounds: [
+            nodeIntegralBoundLow.toIdentifiers(),
+            nodeIntegralBoundHigh.toIdentifiers(),
+        ],
+    };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        let isExploding = false;
+        try {
+            getAnswer(identifiers);
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const createQCPassedIdentifiers = (opts) => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers(opts);
+        isValid = isIdentifiersQCPassed(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = (() => {
+            const nodeVarX = new VariableNode("x");
+            const nodeIntegralBoundLow = (1).toTree();
+            const nodeIntegralBoundHigh = (3).toTree();
+            const nodeF = frac(add(add(multiply((2).toTree(), square(nodeVarX)), nodeVarX), randint(1, 5).toTree()), square(nodeVarX));
+            return {
+                nodeIdsF: nodeF.toIdentifiers(),
+                nodeIdsBounds: [nodeIntegralBoundLow, nodeIntegralBoundHigh].map((node) => node.toIdentifiers()),
+            };
+        })();
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getIntegralTrinomialOverX2Question = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createQCPassedIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    orderOfP: "2",
+};
+const options = [
+    {
+        id: "orderOfP",
+        label: "Ordre du polynôme au numérateur",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["1", "2"],
+        defaultValue: optsDefault.orderOfP,
+    },
+];
+export const integralTrinomialOverX2 = {
+    id: "integralTrinomialOverX2",
+    connector: "=",
+    label: "Calcul d'intégrales de fonctions du type $\\frac{P(x)}{x^2}$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getIntegralTrinomialOverX2Question(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/logarithm/findLargestPossibleDomainOfLogF.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    dictNodeIds: Record<string, NodeIdentifiers>;
+    nodeIdsF: NodeIdentifiers;
+    typeF: string;
+};
+type Options = {
+    typeF: string;
+};
+export declare const findLargestPossibleDomainOfLogF: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=findLargestPossibleDomainOfLogF.d.ts.map

package/lib/exercises/math/functions/logarithm/findLargestPossibleDomainOfLogF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findLargestPossibleDomainOfLogF.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/findLargestPossibleDomainOfLogF.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkC7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC7C,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA4rBF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkCF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB1E,CAAC"}