math-exercises 3.0.199 → 3.0.200

package/lib/exercises/math/derivation/derivative/trigo/sinCosDerivativeRewriteUsingCos2PlusSin2Equals1.js

@@ -0,0 +1,445 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeByReplacingNodeAtPath } from "../../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { cos, CosNode } from "../../../../../tree/nodes/functions/cosNode.js";
+import { isFunctionNode } from "../../../../../tree/nodes/functions/functionNode.js";
+import { sin, SinNode } from "../../../../../tree/nodes/functions/sinNode.js";
+import { NodeIds } from "../../../../../tree/nodes/node.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { multiply, } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode, } from "../../../../../tree/nodes/operators/operatorNode.js";
+import { isPowerNode, isSquareNode, power, 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 { NodePrinter } from "../../../../../tree/utilities/nodePrinter.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+function myRewrite(node, createFuncRewrite) {
+    const funcRewrite = createFuncRewrite(node);
+    if (funcRewrite !== undefined) {
+        const nodeRewritten = funcRewrite(node);
+        return nodeRewritten;
+    }
+    else {
+        if (isOperatorNode(node)) {
+            return nodeByReplacingNodeAtPath(nodeByReplacingNodeAtPath(node, { keys: ["leftChild"] }, myRewrite(node.leftChild, createFuncRewrite)), { keys: ["rightChild"] }, myRewrite(node.rightChild, createFuncRewrite));
+        }
+        else if (isFunctionNode(node)) {
+            return nodeByReplacingNodeAtPath(node, { keys: ["child"] }, myRewrite(node.child, createFuncRewrite));
+        }
+        else {
+            return node;
+        }
+    }
+}
+const mySimplify = (node) => {
+    const rewriteCosToCAndSinToS = (node) => myRewrite(node, (node) => {
+        if (node.toTex() === "\\cos\\left(x\\right)") {
+            return () => new VariableNode("c");
+        }
+        else if (node.toTex() === "\\sin\\left(x\\right)") {
+            return () => new VariableNode("s");
+        }
+        else {
+            return undefined;
+        }
+    });
+    const rewriteCToCosAndSToSin = (node) => myRewrite(node, (node) => {
+        if (node.toTex() === "c") {
+            return () => new CosNode(new VariableNode("x"));
+        }
+        else if (node.toTex() === "s") {
+            return () => new SinNode(new VariableNode("x"));
+        }
+        else {
+            return undefined;
+        }
+    });
+    const nodeCSRaw = rewriteCosToCAndSinToS(node);
+    const nodeCSSimplified = nodeCSRaw.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const nodeMySimplified = rewriteCToCosAndSToSin(nodeCSSimplified);
+    return nodeMySimplified;
+};
+const getPrettyNodeDerivative = (node) => {
+    if (isPowerNode(node)) {
+        const nodeDerivativeUgly = node.derivative();
+        const nodeDerivativeLeft = nodeDerivativeUgly.leftChild;
+        const nodeDerivativeRight = nodeDerivativeUgly.rightChild;
+        const nodeDerivativePretty = multiply(nodeDerivativeLeft.leftChild, multiply(nodeDerivativeLeft.rightChild.simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        }), nodeDerivativeRight));
+        return nodeDerivativePretty;
+    }
+    else {
+        return node.derivative();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsLambda, nodeIdsU, nodeIdsV, nodeIdsRewriteUsing } = identifiers;
+    const [nodeLambda, nodeU, nodeV, nodeRewriteUsing] = [
+        nodeIdsLambda,
+        nodeIdsU,
+        nodeIdsV,
+        nodeIdsRewriteUsing,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = multiply(nodeLambda, multiply(nodeU, nodeV)).simplify();
+    return `Soit la fonction $f$ définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+Calculer $f'(x)$, et l'exprimer uniquement en fonction de $${nodeRewriteUsing.toTex()}$.`;
+};
+const getNodeFDerivativeStuff = (identifiers) => {
+    const { nodeIdsLambda, nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeLambda, nodeU, nodeV] = [nodeIdsLambda, nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    // const nodeF = multiply(nodeLambda, multiply(nodeU, nodeV)).simplify();
+    const [nodeUPrime, nodeVPrime] = [nodeU, nodeV].map(getPrettyNodeDerivative);
+    //f' = lambda (u'v+uv')
+    return {
+        nodeFDerivative0: multiply(nodeLambda, add(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrime))),
+        nodeFDerivative1: multiply(nodeLambda, add(mySimplify(multiply(nodeUPrime, nodeV).simplify()), mySimplify(multiply(nodeU, nodeVPrime).simplify()))),
+    };
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsRewriteUsing } = identifiers;
+    const { nodeFDerivative1: nodeDerivative1 } = getNodeFDerivativeStuff(identifiers);
+    const createFuncRewrite = (node) => {
+        const isPowerNode2 = (node) => isPowerNode(node) &&
+            isNumberNode(node.rightChild) &&
+            node.rightChild.value === 2;
+        if (isSquareNode(node) || isPowerNode2(node)) {
+            const nodeIdsLeftChild = node.leftChild.toIdentifiers();
+            switch (nodeIdsRewriteUsing.id) {
+                case NodeIds.cos:
+                    if (nodeIdsLeftChild.id === NodeIds.sin) {
+                        return (node) => {
+                            const nodeSin = node.leftChild;
+                            return substract(1, power(cos(nodeSin.child), 2));
+                        };
+                    }
+                    else {
+                        return undefined;
+                    }
+                case NodeIds.sin:
+                    if (nodeIdsLeftChild.id === NodeIds.cos) {
+                        return (node) => {
+                            const nodeCos = node.leftChild;
+                            return substract(1, power(sin(nodeCos.child), 2));
+                        };
+                    }
+                    else {
+                        return undefined;
+                    }
+            }
+        }
+        else {
+            return undefined;
+        }
+    };
+    const nodeDerivative2 = myRewrite(nodeDerivative1, createFuncRewrite);
+    return nodeDerivative2;
+};
+const getAnswer = (identifiers) => {
+    return mySimplify(getAnswerNode(identifiers)).toTex();
+};
+const getHint = (_identifiers) => {
+    return `Si $u$ et $v$ sont deux fonctions dérivables alors, 
+pour $x$ dans l'ensemble de dérivation de $u \\circ v = x \\mapsto u(v(x))$, on a : 
+
+$$
+(u \\circ v)'(x) = v'(x)u'(v(x))
+$$
+
+Une fois que tu as obtenu la dérivée, réécris-la en utilisant la formule,
+pour tout $x$ réel :
+
+$$
+\\sin^{2}{(x)} + \\cos^{2}{(x)} = 1
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsLambda, nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeLambda, nodeU, nodeV] = [nodeIdsLambda, nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeUPrime, nodeVPrime] = [nodeU, nodeV].map(getPrettyNodeDerivative);
+    const { nodeFDerivative0, nodeFDerivative1 } = getNodeFDerivativeStuff(identifiers);
+    const nodeAnswer = getAnswerNode(identifiers);
+    return `On doit calculer la dérivée d'un produit.
+  
+${(() => {
+        if (nodeLambda.evaluate() === 1) {
+            return `Ici, $f(x) = u(x) v(x)$ avec :`;
+        }
+        else {
+            return `Ici, $f(x) = \\lambda u(x) v(x)$ avec :
+
+$$
+\\lambda = ${nodeLambda.toTex({})}
+$$
+
+`;
+        }
+    })()}
+
+
+$$
+u(x) = ${nodeU.toTex({})}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+On calcule (dérivées de fonctions composées): 
+
+$$
+u'(x) = ${nodeUPrime.toTex()}
+$$
+
+$$
+v'(x) = ${nodeVPrime.toTex()}
+$$
+
+Donc :
+
+${alignTex([
+        [
+            `f'(x)`,
+            `=`,
+            nodeLambda.evaluate() === 1
+                ? `u'(x)v(x)+u(x)v'(x)`
+                : `\\lambda(u'(x)v(x)+u(x)v'(x))`,
+        ],
+        [``, `=`, NodePrinter.toTexWithMaxWidth(nodeFDerivative0, 70)],
+        [``, `=`, nodeFDerivative1.toTex()],
+    ])}
+
+Pour tout $x$ réel, on a :
+
+$$
+\\sin^{2}{(x)} + \\cos^{2}{(x)} = 1
+$$
+
+On peut donc réécrire :
+
+${alignTex([
+        [`f'(x)`, `=`, nodeAnswer.toTex()],
+        [``, `=`, mySimplify(nodeAnswer).toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer: _answer, ...identifiers }) => {
+    const { nodeIdsU, nodeIdsV, nodeIdsRewriteUsing } = identifiers;
+    const [nodeU, nodeV] = [nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [_nodeUPrime, _nodeVPrime] = [nodeU, nodeV].map((node) => node.derivative().simplify());
+    const maxWidthForTex = 70;
+    const propositions = [];
+    const nodeAnswer = mySimplify(getAnswerNode(identifiers));
+    addValidProp(propositions, NodePrinter.toTexWithMaxWidth(nodeAnswer, maxWidthForTex));
+    //student: cos^2(x) - sin^2(x) = 1
+    {
+        const { nodeFDerivative1: nodeDerivative1 } = getNodeFDerivativeStuff(identifiers);
+        const createFuncRewrite = (node) => {
+            const isPowerNode2 = (node) => isPowerNode(node) &&
+                isNumberNode(node.rightChild) &&
+                node.rightChild.value === 2;
+            if (isSquareNode(node) || isPowerNode2(node)) {
+                const nodeIdsLeftChild = node.leftChild.toIdentifiers();
+                switch (nodeIdsRewriteUsing.id) {
+                    case NodeIds.cos:
+                        if (nodeIdsLeftChild.id === NodeIds.sin) {
+                            return (node) => {
+                                const nodeSin = node.leftChild;
+                                return substract(power(cos(nodeSin.child), 2), 1);
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                    case NodeIds.sin:
+                        if (nodeIdsLeftChild.id === NodeIds.cos) {
+                            return (node) => {
+                                const nodeCos = node.leftChild;
+                                return add(1, power(sin(nodeCos.child), 2));
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                }
+            }
+            else {
+                return undefined;
+            }
+        };
+        const nodeDerivative2 = myRewrite(nodeDerivative1, createFuncRewrite);
+        try {
+            const nodeWrong = mySimplify(nodeDerivative2);
+            tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeWrong, maxWidthForTex));
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    //student: cos^2(x) + sin^2(x) = -1
+    {
+        const { nodeFDerivative1: nodeDerivative1 } = getNodeFDerivativeStuff(identifiers);
+        const createFuncRewrite = (node) => {
+            const isPowerNode2 = (node) => isPowerNode(node) &&
+                isNumberNode(node.rightChild) &&
+                node.rightChild.value === 2;
+            if (isSquareNode(node) || isPowerNode2(node)) {
+                const nodeIdsLeftChild = node.leftChild.toIdentifiers();
+                switch (nodeIdsRewriteUsing.id) {
+                    case NodeIds.cos:
+                        if (nodeIdsLeftChild.id === NodeIds.sin) {
+                            return (node) => {
+                                const nodeSin = node.leftChild;
+                                return substract(-1, power(cos(nodeSin.child), 2));
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                    case NodeIds.sin:
+                        if (nodeIdsLeftChild.id === NodeIds.cos) {
+                            return (node) => {
+                                const nodeCos = node.leftChild;
+                                return substract(-1, power(sin(nodeCos.child), 2));
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                }
+            }
+            else {
+                return undefined;
+            }
+        };
+        const nodeDerivative2 = myRewrite(nodeDerivative1, createFuncRewrite);
+        try {
+            const nodeWrong = mySimplify(nodeDerivative2);
+            tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeWrong, maxWidthForTex));
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    //student: cos(x) = sin(x)
+    {
+        const { nodeFDerivative1: nodeDerivative1 } = getNodeFDerivativeStuff(identifiers);
+        const createFuncRewrite = (node) => {
+            const isPowerNode2 = (node) => isPowerNode(node) &&
+                isNumberNode(node.rightChild) &&
+                node.rightChild.value === 2;
+            if (isSquareNode(node) || isPowerNode2(node)) {
+                const nodeIdsLeftChild = node.leftChild.toIdentifiers();
+                switch (nodeIdsRewriteUsing.id) {
+                    case NodeIds.cos:
+                        if (nodeIdsLeftChild.id === NodeIds.sin) {
+                            return (node) => {
+                                const nodeSin = node.leftChild;
+                                return power(cos(nodeSin.child), 2);
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                    case NodeIds.sin:
+                        if (nodeIdsLeftChild.id === NodeIds.cos) {
+                            return (node) => {
+                                const nodeCos = node.leftChild;
+                                return power(sin(nodeCos.child), 2);
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                }
+            }
+            else {
+                return undefined;
+            }
+        };
+        const nodeDerivative2 = myRewrite(nodeDerivative1, createFuncRewrite);
+        try {
+            const nodeWrong = mySimplify(nodeDerivative2);
+            tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeWrong, maxWidthForTex));
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return NodeComparator.isEqualViaRandomEvaluations(nodeAns, nodeAnswer, 3);
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getSinCosDerivativeRewriteUsingCos2PlusSin2Equals1Question = () => {
+    const nodeVarX = new VariableNode("x");
+    const createRandomFactorNode = () => ((coinFlip() ? +1 : -1) * randint(1, 7)).toTree();
+    const [func1, func2] = shuffle([sin, cos]);
+    const nodeLambda = createRandomFactorNode();
+    const node1 = square(func1(nodeVarX));
+    const node2 = func2(nodeVarX);
+    const [nodeU, nodeV] = shuffle([node1, node2]);
+    const identifiers = {
+        nodeIdsLambda: nodeLambda.toIdentifiers(),
+        nodeIdsU: nodeU.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+        nodeIdsRewriteUsing: func1(nodeVarX).toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x", "sin", "cos", "tan"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const sinCosDerivativeRewriteUsingCos2PlusSin2Equals1 = {
+    id: "sinCosDerivativeRewriteUsingCos2PlusSin2Equals1",
+    connector: "=",
+    label: "Dérivée de $\\sin{(x)}\\cos^{2}{(x)}$ ou $\\sin^{2}{(x)}\\cos{(x)}$ à exprimer en fonction de $\\cos{(x)}$ ou $\\sin{(x)}$ uniquement",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSinCosDerivativeRewriteUsingCos2PlusSin2Equals1Question, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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/index.d.ts

@@ -25,4 +25,5 @@ export * from "./dataRepresentations/index.js";
 export * from "./tests/index.js";
 export * from "./pcExosInMath.js";
 export * from "./scratch/index.js";
+export * from "./_debug/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC"}

package/lib/exercises/math/index.js

@@ -25,4 +25,4 @@ export * from "./dataRepresentations/index.js";
 export * from "./tests/index.js";
 export * from "./pcExosInMath.js";
 export * from "./scratch/index.js";
-// export * from "./_debug/index.js";
+export * from "./_debug/index.js";

package/lib/exercises/math/limits/sequenceGeometricLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequenceGeometricLimit.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/sequenceGeometricLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAE7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,SAAS,EAAE,eAAe,CAAC;CAC5B,CAAC;AAmEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"sequenceGeometricLimit.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/sequenceGeometricLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAE7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,SAAS,EAAE,eAAe,CAAC;CAC5B,CAAC;AA4EF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}

package/lib/exercises/math/limits/sequenceGeometricLimit.js

@@ -17,6 +17,12 @@ const getAnswer = (identifiers) => {
     const answer = sequence.getLimit();
     return answer.toTex();
 };
+// const getHint: GetHint<Identifiers> = (identifiers)=>{
+//   return ``
+// }
+// const getCorrection: GetCorrection<Identifiers> = (identifiers)=>{
+//   return ``
+// }
 const getSequenceGeometricLimitQuestion = () => {
     const sequence = GeometricSequenceConstructor.randomWithLimit();
     const identifiers = {
@@ -32,6 +38,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["infty"],
         answerFormat: "tex",
         identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -62,4 +70,5 @@ export const sequenceGeometricLimit = {
     getAnswer,
     getInstruction,
     getQuestionFromIdentifiers,
+    // hasHintAndCorrection: true,
 };

package/lib/exercises/math/primitive/constantPrimitive.d.ts

@@ -2,10 +2,13 @@ import { Exercise, GetQuestionFromIdentifiers, QCMGenerator, QuestionGenerator,
 type Identifiers = {
     c: number;
 };
-export declare const getConstantPrimitive: QuestionGenerator<Identifiers>;
-export declare const getConstantPrimitiveQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers>;
-export declare const getConstantPrimitivePropositions: QCMGenerator<Identifiers>;
-export declare const isConstantPrimitiveAnswerValid: VEA<Identifiers>;
-export declare const constantPrimitive: Exercise<Identifiers>;
+type Options = {
+    askParticularPrimitive?: boolean;
+};
+export declare const getConstantPrimitive: QuestionGenerator<Identifiers, Options>;
+export declare const getConstantPrimitiveQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers, Options>;
+export declare const getConstantPrimitivePropositions: QCMGenerator<Identifiers, Options>;
+export declare const isConstantPrimitiveAnswerValid: VEA<Identifiers, Options>;
+export declare const constantPrimitive: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=constantPrimitive.d.ts.map

package/lib/exercises/math/primitive/constantPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constantPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/constantPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoBF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,CAAC,WAAW,CAI/D,CAAC;AAEF,eAAO,MAAM,2CAA2C,EAAE,0BAA0B,CAClF,WAAW,CAYZ,CAAC;AACF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CAAC,WAAW,CActE,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,GAAG,CAAC,WAAW,CAO3D,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAYnD,CAAC"}
+{"version":3,"file":"constantPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/constantPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAOJ,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAgCF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,CAAC,WAAW,EAAE,OAAO,CAMxE,CAAC;AAEF,eAAO,MAAM,2CAA2C,EAAE,0BAA0B,CAClF,WAAW,EACX,OAAO,CAaR,CAAC;AACF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CAAC,WAAW,EAAE,OAAO,CAmB/E,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,GAAG,CAAC,WAAW,EAAE,OAAO,CAQpE,CAAC;AAYF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAc5D,CAAC"}

package/lib/exercises/math/primitive/constantPrimitive.js

@@ -1,66 +1,85 @@
-import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { addValidProp, propWhile, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Monom } from "../../../math/polynomials/monom.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { AddNode } from "../../../tree/nodes/operators/addNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-const getInstruction = (identifiers) => {
+const getAnswerNode = (identifiers, opts) => {
     const { c } = identifiers;
-    return `Déterminer la forme générale des primitives de la fonction constante $f$ définie par : 
+    const monom = new Monom(1, c);
+    if (opts?.askParticularPrimitive)
+        return monom.toTree();
+    return new AddNode(monom.toTree(), new VariableNode("C"));
+};
+const getInstruction = (identifiers, opts) => {
+    const { c } = identifiers;
+    const isAskingParticularPrimitive = opts?.askParticularPrimitive;
+    return `${isAskingParticularPrimitive
+        ? "Déterminer une primitive en particulier de la fonction constante $f$ définie par"
+        : "Déterminer la forme générale des primitives de la fonction constante $f$ définie par"} : 
   
 $$
 f(x) = ${c}
 $$`;
 };
-const getAnswer = (identifiers) => {
-    const { c } = identifiers;
-    const monom = new Monom(1, c);
-    const answer = new AddNode(monom.toTree(), new VariableNode("C")).toTex();
-    return answer;
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers, opts).toTex();
 };
-export const getConstantPrimitive = () => {
+export const getConstantPrimitive = (opts) => {
     const c = randint(-19, 20, [0]);
     const identifiers = { c };
-    return getConstantPrimitiveQuestionFromIdentifiers(identifiers);
+    return getConstantPrimitiveQuestionFromIdentifiers(identifiers, opts);
 };
-export const getConstantPrimitiveQuestionFromIdentifiers = (identifiers) => {
+export const getConstantPrimitiveQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        instruction: getInstruction(identifiers),
+        instruction: getInstruction(identifiers, opts),
         startStatement: `F(x)`,
-        answer: getAnswer(identifiers),
-        keys: ["x", "C"],
+        answer: getAnswer(identifiers, opts),
+        keys: opts?.askParticularPrimitive ? ["x"] : ["x", "C"],
         answerFormat: "tex",
         identifiers,
+        options: opts,
     };
     return question;
 };
-export const getConstantPrimitivePropositions = (n, { answer }) => {
+export const getConstantPrimitivePropositions = (n, { answer, c }, opts) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    const cNode = new VariableNode("C");
     propWhile(propositions, n, () => {
-        const monom = new Monom(1, randint(-9, 10, [-1, 0, 1]));
-        const wrongAnswer = new AddNode(monom.toTree(), cNode);
+        const monom = new Monom(1, randint(-9, 10, opts?.askParticularPrimitive ? [-1, 0, 1, c] : [-1, 0, 1]));
+        const wrongAnswer = opts?.askParticularPrimitive
+            ? monom.toTree()
+            : new AddNode(monom.toTree(), new VariableNode("C"));
         tryToAddWrongProp(propositions, wrongAnswer.toTex());
     });
     return shuffle(propositions);
 };
-export const isConstantPrimitiveAnswerValid = (ans, { c }) => {
-    const answer = new AddNode(new Monom(1, c).toTree(), new VariableNode("C"));
+export const isConstantPrimitiveAnswerValid = (ans, { c }, opts) => {
+    const answer = getAnswerNode({ c }, opts);
     const texs = answer.toAllValidTexs();
     return texs.includes(ans);
 };
+const options = [
+    {
+        id: "askParticularPrimitive",
+        label: "Demander une primitive en particulier",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
 export const constantPrimitive = {
     id: "constantPrimitive",
     connector: "=",
     label: "Primitive d'une constante",
     isSingleStep: false,
-    generator: (nb) => getDistinctQuestions(getConstantPrimitive, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getConstantPrimitive(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions: getConstantPrimitivePropositions,
     isAnswerValid: isConstantPrimitiveAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers: getConstantPrimitiveQuestionFromIdentifiers,
+    options,
 };

package/lib/exercises/math/probaStat/stats2var/averagePoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averagePoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/averagePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAyEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}
+{"version":3,"file":"averagePoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/averagePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAkHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}