math-exercises 3.0.208 → 3.0.211

package/lib/exercises/math/functions/continuity/pyContinuityDichotomyInstructionCompletion.js

@@ -0,0 +1,265 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const createStrPythonForNode = (node) => {
+    return node.toMathString().replaceAll("^", "**");
+};
+const getHydrated = (identifiers) => {
+    const { nodeIdsInterval, nodeIdsDistanceMax } = identifiers;
+    const nodeInterval = NodeConstructor.fromIdentifiers(nodeIdsInterval);
+    const nodeDistanceMax = NodeConstructor.fromIdentifiers(nodeIdsDistanceMax);
+    return {
+        nodeInterval,
+        nodeDistanceMax,
+    };
+};
+const _getStrPythonProgram = (identifiers) => {
+    const { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    const [strIntervalBoundA, strIntervalBoundB] = [
+        nodeInterval.a,
+        nodeInterval.b,
+    ].map(createStrPythonForNode);
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    return `def encadrement(f,a,b, precision):
+    xL,xR = a,b                                  #
+    while True:
+        xL,xR = dichotomie(f,xL,xR)              #
+        if(xR-xL < precision):                   #                                
+            return xL,xR                                                            
+
+def dichotomie(f, a, b):
+    m = (a+b) / 2                                #
+    if f(a) * f(m) <= 0:                         #
+        return a, m                              #
+    else:
+        return m,b                               #
+
+xL,xR = encadrement(f, ${strIntervalBoundA} , ${strIntervalBoundB} , ${strDistanceMax})
+print(xL, "<=", "alpha", "<=", xR)`;
+};
+const getStrPythonProgramComplete = (identifiers) => {
+    const identifiersTweaked = {
+        ...identifiers,
+        keyIncomplete: "",
+    };
+    return getStrPythonProgramIncomplete(identifiersTweaked);
+};
+const getStrPythonProgramIncomplete = (identifiers) => {
+    const { keyIncomplete } = identifiers;
+    const { strEncadrementInitialization, strEncadrementDichotomie, strEncadrementCondition, strDichotomieM, strDichotomieCondition, strDichotomieBlockValid, strDichotomieBlockInvalid, strCallEncadrement, } = Object.fromEntries(Object.entries(getDictStrCompletion(identifiers)).map(([key, str]) => key === keyIncomplete ? [key, "..."] : [key, str]));
+    return `def encadrement(f,a,b, precision):
+    ${strEncadrementInitialization}
+    while True:
+        ${strEncadrementDichotomie}
+        ${strEncadrementCondition}                                
+            return xL,xR                                                            
+
+def dichotomie(f, a, b):
+    ${strDichotomieM}
+    ${strDichotomieCondition}
+      ${strDichotomieBlockValid}
+    else:
+      ${strDichotomieBlockInvalid}
+
+${strCallEncadrement}
+print(xL, "<=", "alpha", "<=", xR)`;
+};
+const getDictStrCompletion = (identifiers) => {
+    const { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    const [strIntervalBoundA, strIntervalBoundB] = [
+        nodeInterval.a,
+        nodeInterval.b,
+    ].map(createStrPythonForNode);
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    return {
+        strEncadrementInitialization: `xL,xR = a,b`,
+        strEncadrementDichotomie: `xL,xR = dichotomie(f,xL,xR)`,
+        strEncadrementCondition: `if(xR-xL < precision):`,
+        strDichotomieM: `m = (a+b)/2`,
+        strDichotomieCondition: `if f(a) * f(m) <= 0:`,
+        strDichotomieBlockValid: `return a,m`,
+        strDichotomieBlockInvalid: `return m,b`,
+        strCallEncadrement: `xL,xR = encadrement(f,${strIntervalBoundA}, ${strIntervalBoundB},${strDistanceMax})`,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    return `On considère une fonction $f$ strictement monotone sur $${nodeInterval.toTex()}$ et qui change de signe sur cet intervalle.
+On veut déterminer un encadrement de $\\alpha$ tel que $f(\\alpha)=0$ en utilisant un algorithme de dichotomie.
+
+Dans le programme suivant, 
+on suppose que l'on dispose d'une fonction ${codifyChunk("f")} 
+telle que ${codifyChunk("f(x)")} retourne $f(x)$.
+
+Par quoi faut-il remplacer les pointillés dans le programme suivant 
+pour qu'il affiche un encadrement de $\\alpha$ avec un écart strictement inférieur à $${nodeDistanceMax.toTex()}$ ?
+
+${codify(getStrPythonProgramIncomplete(identifiers))}
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { keyIncomplete } = identifiers;
+    const dictStrCompletion = getDictStrCompletion(identifiers);
+    return codifyChunk(dictStrCompletion[keyIncomplete]);
+};
+const getHint = (identifiers) => {
+    const { keyIncomplete } = identifiers;
+    switch (keyIncomplete) {
+        case "strEncadrementInitialization":
+            return `Au départ, notre première estimation pour l'abscisse "à gauche" est $a$ et notre première estimation pour l'abscisse "à droite" est $b$.`;
+        case "strEncadrementDichotomie":
+            return `On veut trouver les nouvelles abscisses "à gauche" et "à droite" obtenue après dichotomie.`;
+        case "strEncadrementCondition":
+            return `Écris en Python "Si la différence de l'abscisse "à droite" avec l'abscisse "à gauche" est inférieure à $precision$ alors"`;
+        case "strDichotomieM":
+            return `Dans un algorithme par dichotomie, on coupe l'intervalle considéré en $2$ et on détermine si l'on garde le côté gauche ou le côté droit.`;
+        case "strDichotomieCondition":
+            return `Pour détecter un changement de signe de $f$, on utilise la propriété suivante : Le produit de deux nombres de signes différents est négatif.`;
+        case "strDichotomieBlockValid":
+            return `On a coupé en deux et dans ce cas, on veut garder le côté gauche.`;
+        case "strDichotomieBlockInvalid":
+            return `On a coupé en deux et dans ce cas, on veut garder le côté droit.`;
+        default:
+            throw new Error("Unsupported keyIncomplete: " + keyIncomplete);
+    }
+};
+const getCorrection = (identifiers) => {
+    return `Voici le programme complet :
+
+${codify(getStrPythonProgramComplete(identifiers))}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const { keyIncomplete } = identifiers;
+    switch (keyIncomplete) {
+        case "strEncadrementInitialization":
+            {
+                ["xL,xR = 0,0", "xR,xL = a,b", "xR,xL = 0,0"].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strEncadrementDichotomie":
+            {
+                [
+                    "xR,xL = dichotomie(f,a,b)",
+                    "a,b = dichotomie(f,xL,xR)",
+                    `dichotomie(f,xL,xR)`,
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strEncadrementCondition":
+            {
+                [
+                    "if(xR-xL < precision):",
+                    "if(xR-xL > precision):",
+                    "if(xL-xR < precision):",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strDichotomieM":
+            {
+                ["m = (b-a)/2", "m = a+b", "m = b-a"].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strDichotomieCondition":
+            {
+                [
+                    "if f(a) - f(m) <= 0:",
+                    "if f(a) < 0 and f(m) > 0:",
+                    "if f(a) > 0 and f(m) < 0:",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strDichotomieBlockValid":
+            {
+                [
+                    "return a, (a+m)/2",
+                    "return (a+m)/2, m",
+                    "return (a+m)/2, (b+m)/2",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strDichotomieBlockInvalid":
+            {
+                [
+                    "return m, (m+b)/2",
+                    "return (m+b)/2, b",
+                    "return (a+m)/2, (b+m)/2",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        default:
+            throw new Error("Unsupported keyIncomplete: " + keyIncomplete);
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = () => {
+    const nodeDistanceMax = power(10, randint(-3, 0));
+    const keyIncomplete = random([
+        "strEncadrementInitialization",
+        "strEncadrementDichotomie",
+        "strEncadrementCondition",
+        "strDichotomieM",
+        "strDichotomieCondition",
+        "strDichotomieBlockValid",
+        "strDichotomieBlockInvalid",
+        // "strCallEncadrement",
+    ]);
+    const nodeInterval = (() => {
+        const a = randint(-5, 5);
+        const b = a + randint(1, 5);
+        return new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF);
+    })();
+    const identifiers = {
+        nodeIdsInterval: nodeInterval.toIdentifiers(),
+        nodeIdsDistanceMax: nodeDistanceMax.toIdentifiers(),
+        keyIncomplete,
+    };
+    return identifiers;
+};
+const getPyContinuityDichotomyInstructionCompletionQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+export const pyContinuityDichotomyInstructionCompletion = {
+    id: "pyContinuityDichotomyInstructionCompletion",
+    label: "Compléter le script d'un algorithme d'encadrement par dichotomie de $\\alpha$ tel que $f(\\alpha)=0$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyContinuityDichotomyInstructionCompletionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -1 +1 @@
-{"version":3,"file":"log10Simplifying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/log10Simplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAuIF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB9D,CAAC;AACF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB5D,CAAC"}
+{"version":3,"file":"log10Simplifying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/log10Simplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AA8KF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB9D,CAAC;AACF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB5D,CAAC"}

package/lib/exercises/math/functions/logarithm/log10Simplifying.js

@@ -1,16 +1,16 @@
 import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { Log10Node } from "../../../../tree/nodes/functions/log10Node.js";
-import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { log10, Log10Node } from "../../../../tree/nodes/functions/log10Node.js";
+import { logn, LogNode } from "../../../../tree/nodes/functions/logNode.js";
 import { OppositeNode } from "../../../../tree/nodes/functions/oppositeNode.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 { power, PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
 import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
 import { random } from "../../../../utils/alea/random.js";
-const getInstruction = (identifiers, opts) => {
+const getStatement = (identifiers, opts) => {
     const { nb, powers, signs } = identifiers;
     const nbNode = new NumberNode(nb);
     const LNode = opts?.isLog10 ? Log10Node : LogNode;
@@ -21,8 +21,13 @@ const getInstruction = (identifiers, opts) => {
         : signs[index] > 0
             ? new LNode(new PowerNode(nbNode, new NumberNode(power)))
             : new OppositeNode(new LNode(new PowerNode(nbNode, new NumberNode(power)))));
-    const trueNb = [2, 4, 8].includes(nb) ? 2 : [3, 9].includes(nb) ? 3 : nb;
     const statement = operatorComposition(AddNode, logs);
+    return statement;
+};
+const getInstruction = (identifiers, opts) => {
+    const { nb } = identifiers;
+    const trueNb = [2, 4, 8].includes(nb) ? 2 : [3, 9].includes(nb) ? 3 : nb;
+    const statement = getStatement(identifiers, opts);
     return `Exprimer le nombre suivant sous la forme $a${opts?.isLog10 ? "\\log" : "\\ln"}\\left(${trueNb}\\right)$ : 
     
 $$
@@ -30,18 +35,7 @@ ${statement.toTex()}
 $$`;
 };
 const getAnswer = (identifiers, opts) => {
-    const { nb, powers, signs } = identifiers;
-    const nbNode = new NumberNode(nb);
-    const LNode = opts?.isLog10 ? Log10Node : LogNode;
-    const logs = powers.map((power, index) => nb ** power < 100
-        ? signs[index] > 0
-            ? new LNode(new NumberNode(nb ** power))
-            : new OppositeNode(new LNode(new NumberNode(nb ** power)))
-        : signs[index] > 0
-            ? new LNode(new PowerNode(nbNode, new NumberNode(power)))
-            : new OppositeNode(new LNode(new PowerNode(nbNode, new NumberNode(power)))));
-    const statement = operatorComposition(AddNode, logs);
-    const answer = statement.simplify();
+    const answer = getStatement(identifiers, opts).simplify();
     return answer.toTex();
 };
 const getQuestionFromIdentifiers = (identifiers, opts) => {
@@ -51,6 +45,9 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         keys: getKeys(identifiers, opts),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
     };
     return question;
 };
@@ -58,7 +55,7 @@ const getKeys = (_identifiers, opts) => {
     return [opts?.isLog10 ? "logBrackets" : "lnBrackets"];
 };
 const getLog10SumSimplifyingQuestion = (opts) => {
-    const nb = randint(2, 10);
+    const nb = random([2, 3, 5, 6, 7]);
     const nbTerms = randint(2, 4);
     const powers = [];
     const signs = [];
@@ -81,25 +78,65 @@ const getPropositions = (n, { answer, nb, isLog10 }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { nb, powers, signs, isLog10 }) => {
-    const nbNode = new NumberNode(nb);
-    const LNode = isLog10 ? Log10Node : LogNode;
-    const logs = powers.map((power, index) => nb ** power < 100
-        ? signs[index] > 0
-            ? new LNode(new NumberNode(nb ** power))
-            : new OppositeNode(new LNode(new NumberNode(nb ** power)))
-        : signs[index] > 0
-            ? new LNode(new PowerNode(nbNode, new NumberNode(power)))
-            : new OppositeNode(new LNode(new PowerNode(nbNode, new NumberNode(power)))));
-    const statement = operatorComposition(AddNode, logs);
-    const answer = statement.simplify();
-    const texs = answer.toAllValidTexs();
+const getHint = (_identifiers, opts) => {
+    const logString = opts?.isLog10 ? "\\log" : "\\ln";
+    return `Pour tous nombres réels $a$ et $b$ strictement positifs, on a : 
+  
+- $${logString}(a) + ${logString}(b) = ${logString}(a\\times b)$
+- $${logString}(a) - ${logString}(b) = ${logString}(\\frac{a}{b})$
+- $${logString}(a^b) = b ${logString}(a)$`;
+};
+const getCorrection = (identifiers, opts) => {
+    const { nb, powers } = identifiers;
+    const fct = opts?.isLog10 ? log10 : logn;
+    const logString = opts?.isLog10 ? "\\log" : "\\ln";
+    const trueNb = [2, 4, 8].includes(nb) ? 2 : [3, 9].includes(nb) ? 3 : nb;
+    const truePowers = powers.map((pow) => {
+        if (nb !== trueNb) {
+            const truePow = Math.floor(Math.log(nb) / Math.log(trueNb));
+            return power(trueNb, truePow);
+        }
+        if (pow === 1)
+            return trueNb.toTree();
+        return power(trueNb, pow);
+    });
+    return `Pour tous nombres réels $a$ et $b$ strictement positifs, on a : 
+  
+- $${logString}(a) + ${logString}(b) = ${logString}(a\\times b)$
+- $${logString}(a) - ${logString}(b) = ${logString}(\\frac{a}{b})$
+- $${logString}(a^b) = b ${logString}(a)$
+
+On applique ces propriétés ici pour simplifier l'expression : 
+
+${truePowers
+        .map((e) => {
+        if (e.evaluate() === trueNb)
+            return "";
+        if (e.evaluate() < 100)
+            return `- $${fct(e.evaluate().frenchify()).toTex()} = ${fct(e).toSimplificationTex()}$`;
+        return `- $${fct(e).toSimplificationTex()}$`;
+    })
+        .filter(Boolean)
+        .join("\n \n")}
+
+En additionnant, on obtient donc l'expression simplifiée : 
+
+$$
+${getStatement(identifiers, opts).toTex()} = ${getAnswer(identifiers, opts)}
+$$
+  `;
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
+    const statement = getStatement(identifiers, opts);
+    console.log(opts, identifiers);
+    const answerNode = statement.simplify();
+    const texs = answerNode.toAllValidTexs();
     return texs.includes(ans);
 };
 export const log10SumSimplifying = {
     id: "log10SumSimplifying",
     connector: "=",
-    label: "Simplifier une somme de logarithmes décimaux",
+    label: "Simplifier une expression avec des logarithmes décimaux",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getLog10SumSimplifyingQuestion({ isLog10: true }), nb),
     qcmTimer: 60,
@@ -108,11 +145,12 @@ export const log10SumSimplifying = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };
 export const logSumSimplifying = {
     id: "logSumSimplifying",
     connector: "=",
-    label: "Simplifier une somme de logarithmes népériens",
+    label: "Simplifier une expression avec des logarithmes népériens",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getLog10SumSimplifyingQuestion({ isLog10: false }), nb),
     qcmTimer: 60,
@@ -121,4 +159,5 @@ export const logSumSimplifying = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"logEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAcrC,cAAc;AACd,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0FF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAY7C,CAAC"}
+{"version":3,"file":"logEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAerC,cAAc;AACd,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgIF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}

package/lib/exercises/math/functions/logarithm/logEquation.js

@@ -3,7 +3,7 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { Rational } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
-import { ExpNode } from "../../../../tree/nodes/functions/expNode.js";
+import { exp, ExpNode } from "../../../../tree/nodes/functions/expNode.js";
 import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
@@ -11,6 +11,7 @@ import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 const getKeys = () => {
     return [
         "x",
@@ -40,11 +41,45 @@ const getAnswer = (identifiers) => {
     return answer;
 };
 const getLnEquation = () => {
-    const a = randint(-9, 20, [0]);
+    const a = randint(-9, 20, [0, 1]);
     const k = randint(-9, 20, [0]);
     const identifiers = { a, k };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = () => {
+    return `Isole $\\ln(x)$ d'un côté de l'équation. Puis, utilise la propriété suivante : pour tout nombre réel $x>0$ et tout nombre réel $k$, on a : 
+  
+$$
+\\ln(x) = k \\iff x = e^{k}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, k } = identifiers;
+    return `On isole $\\ln(x)$ d'un côté de l'équation : 
+  
+$$
+\\ln(x) = ${frac(k, a).toSimplificationTex()}
+$$
+
+Puis, on applique l'exponentielle. En effet, pour tout nombre réel $x>0$ et tout nombre réel $k$, on a :
+
+$$
+\\ln(x) = k \\iff x = e^{k}
+$$
+
+Ici, on a donc : 
+
+$$
+x = ${exp(frac(k, a).simplify()).toTex()}
+$$
+
+La solution de l'équation est donc :
+
+$$
+${getAnswer(identifiers)}
+$$
+  `;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -52,6 +87,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -86,4 +123,5 @@ export const logEquation = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"logPowerEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logPowerEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAmHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAc3D,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB7D,CAAC"}
+{"version":3,"file":"logPowerEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logPowerEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAyKF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe3D,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB7D,CAAC"}

package/lib/exercises/math/functions/logarithm/logPowerEquation.js

@@ -3,18 +3,20 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { randint } from "../../../../math/utils/random/randint.js";
 import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
 import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
-import { Log10Node } from "../../../../tree/nodes/functions/log10Node.js";
-import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { log10, Log10Node } from "../../../../tree/nodes/functions/log10Node.js";
+import { logn, LogNode } from "../../../../tree/nodes/functions/logNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
-import { PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { frac, FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power, PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
 import { equationSolutionParser } from "../../../../tree/parsers/equationSolutionParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 /**a*b^x+c=d */
 const getKeys = (_identifiers, opts) => {
     const keys = ["x", "equal", "S", "lbrace", "semicolon", "rbrace"];
@@ -44,12 +46,55 @@ const getAnswer = (identifiers, opts) => {
 };
 const getLogPowerEquationQuestion = (opts) => {
     const powered = randint(2, 8);
-    const a = randint(1, 10, [powered]);
+    const a = randint(2, 10, [powered]);
     const c = randint(-5, 5, [a]);
     const k = randint(5, 15, [powered]);
     const identifiers = { a, c, k, powered, isLog10: opts?.isLog10 ?? false };
     return getQuestionFromIdentifiers(identifiers, opts);
 };
+const getHint = (identifiers, opts) => {
+    const logString = opts?.isLog10 ? "\\log" : "\\ln";
+    const { powered } = identifiers;
+    const powerN = power(powered, "x");
+    return `Commence par isoler $${powerN.toTex()}$ d'un côté de l'équation.
+
+Puis, applique le logarithme sur les deux membres de l'équation. 
+
+Cela te permettra d'obtenir la solution, en utilisant la propriété suivante : pour tout nombre réel $a>0$ et tout nombre réel $b$, 
+
+$$
+${logString}(a^b) = b${logString}(a)
+$$
+`;
+};
+const getCorrection = (identifiers, opts) => {
+    const { a, powered, c, k } = identifiers;
+    const d = k * a + c;
+    const powerN = power(powered, "x");
+    const loga = opts?.isLog10 ? log10 : logn;
+    //a*powered^x+c = d
+    //poweerd^x = (d-c)/a
+    const b = frac(substract(d, c), a).simplify();
+    return `On commence par isoler $${powerN.toTex()}$ d'un côté de l'équation : 
+  
+$$
+${powerN.toTex()} = ${frac(substract(d, c), a).toSimplificationTex()}
+$$
+
+Ensuite, on applique le logarithme sur les deux membres de l'équation (ce qui est possible car les deux membres sont strictement positifs), et on utilise la propriété $${loga("a^x").toTex()}= x${loga("a").toTex()}$ :
+
+${alignTex([
+        [loga(powerN).toTex(), "=", loga(b).toTex()],
+        [multiply("x", loga(powered)).toTex(), "=", loga(b).toTex()],
+        ["x", "=", frac(loga(b), loga(powered)).toTex()],
+    ])}
+
+La solution est donc : 
+
+$$
+${getAnswer(identifiers, opts)}
+$$`;
+};
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         answer: getAnswer(identifiers, opts),
@@ -57,6 +102,8 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         keys: getKeys(identifiers, opts),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -106,6 +153,7 @@ export const logPowerEquation = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };
 export const log10PowerEquation = {
     id: "log10PowerEquation",
@@ -119,4 +167,5 @@ export const log10PowerEquation = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"logSimplifiying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"logSimplifiying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}