math-exercises 3.0.200 → 3.0.201

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

@@ -0,0 +1,172 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+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 { exp, ExpNode } from "../../../../tree/nodes/functions/expNode.js";
+import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { DiscreteSetNode, EmptySet, } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { splitAndKeep } from "../../../../utils/strings/splitAndKeep.js";
+const getKeys = () => {
+    return [
+        "x",
+        "equal",
+        "lnBrackets",
+        "e",
+        "epower",
+        "exp",
+        "lbrace",
+        "S",
+        "semicolon",
+        "rbrace",
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { a, b, k } = identifiers;
+    const nodeVarX = new VariableNode("x");
+    const nodeAffine = add(multiply(a, nodeVarX), b);
+    const nodeLogOfAffine = new LogNode(nodeAffine);
+    const nodeEquation = new EqualNode(nodeLogOfAffine, k.toTree());
+    return `Résoudre l'équation : 
+    
+$$
+${nodeEquation.toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { a, b, k } = identifiers;
+    const nodeAnswer = new EquationSolutionNode(new DiscreteSetNode([frac(substract(exp(k), b), a)]));
+    return nodeAnswer;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { a, b } = identifiers;
+    const nodeVarX = new VariableNode("x");
+    const nodeAffine = add(multiply(a, nodeVarX), b);
+    const nodeLogOfAffine = new LogNode(nodeAffine);
+    return `Suppose qu'une solution existe et calcule-la, puis vérifie qu'elle appartient bien au domaine de définition de $x \\mapsto ${nodeLogOfAffine.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, k } = identifiers;
+    const nodeVarXS = new VariableNode("x_{S}");
+    const nodeAffineXS = add(multiply(a, nodeVarXS), b);
+    const nodeLogOfAffineXS = new LogNode(nodeAffineXS);
+    const nodeXSolution = frac(substract(exp(k), b), a);
+    const nodeEquation1 = new EqualNode(nodeLogOfAffineXS, k.toTree());
+    const nodeEquation2 = new EqualNode(nodeAffineXS, exp(k));
+    const nodeEquation3 = new EqualNode(nodeVarXS, nodeXSolution);
+    const nodeIntervalBoundLow = frac(-b, a);
+    const nodeSolution = new EquationSolutionNode(new DiscreteSetNode([nodeXSolution]));
+    const nodeVarX = new VariableNode("x");
+    const nodeAffineX = add(multiply(a, nodeVarX), b);
+    const nodeLogOfAffineX = new LogNode(nodeAffineX);
+    return `Supposons qu'une solution $${nodeVarXS.toTex()}$ existe.
+
+On aurait :
+
+${alignTex([
+        ["\\ \\ ", ...splitAndKeep(nodeEquation1.toTex(), "=")],
+        ["\\Leftrightarrow", ...splitAndKeep(nodeEquation2.toTex(), "=")],
+        ["\\Leftrightarrow", ...splitAndKeep(nodeEquation3.toTex(), "=")],
+    ])}
+
+La fonction $x \\mapsto ${new LogNode(nodeVarX).toTex()}$ est définie sur $]0; +\\infty[$.
+La fonction $x \\mapsto ${nodeLogOfAffineX.toTex()}$ est définie sur $]${nodeIntervalBoundLow.toTex()}; +\\infty[$.
+
+On a :
+
+$$
+${nodeVarXS.toTex()} = ${nodeXSolution.toTex()} > ${nodeIntervalBoundLow.toTex()}
+$$
+
+La solution de l'équation proposée est donc :
+
+$$
+${nodeSolution.toTex()}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { a, b, k } = identifiers;
+    //student: not possible
+    {
+        tryToAddWrongProp(propositions, new EquationSolutionNode(EmptySet).toTex());
+    }
+    //student: ln instead of exp
+    {
+        const nodeWrong = frac(substract(new LogNode(k.toTree()), b), a);
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([nodeWrong])).toTex());
+    }
+    //student: (k/b)^a
+    {
+        const nodeWrong = power(frac(k, b), a);
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([nodeWrong])).toTex());
+    }
+    propWhile(propositions, n, () => {
+        const randomA = randint(1, 10);
+        const randomK = randint(1, 20);
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([
+            new ExpNode(new Rational(randomK, randomA).simplify().toTree()),
+        ])).toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const nodeEqSolAnswer = getAnswerNode(identifiers);
+    const [nodeAnswer] = nodeEqSolAnswer.solutionsSet.elements;
+    const nodeEqSolAns = discreteSetParser(ans);
+    if (!nodeEqSolAns) {
+        return false;
+    }
+    const [nodeAns] = nodeEqSolAns.elements;
+    return NodeComparator.isEqualViaSub(nodeAns, nodeAnswer);
+};
+const getLogEquationLnAXPlusBEqualsKQuestion = () => {
+    const a = randint(-9, 20, [0]);
+    const b = randint(-9, 20, [0]);
+    const k = randint(-9, 20, [0]);
+    const identifiers = { a, b, k };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const logEquationLnAXPlusBEqualsK = {
+    id: "logEquationLnAXPlusBEqualsK",
+    connector: "=",
+    label: "Résoudre des équations de type $\\ln(ax+b) = k$",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getLogEquationLnAXPlusBEqualsKQuestion, nb),
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+import { InegalitySymbols } from "../../../../math/inequations/inequation.js";
+type Identifiers = {
+    nodeIdsQ: NodeIdentifiers;
+    nodeIdsS: NodeIdentifiers;
+    inegSymbol: InegalitySymbols;
+};
+export declare const logInequationIntegerSolutions: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=logInequationIntegerSolutions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logInequationIntegerSolutions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logInequationIntegerSolutions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAOxE,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAuMF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}

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

@@ -0,0 +1,163 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { splitAndKeep } from "../../../../utils/strings/splitAndKeep.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { InequationNode } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { round } from "../../../../math/utils/round.js";
+const getInstruction = (identifiers) => {
+    const { nodeIdsQ, nodeIdsS, inegSymbol } = identifiers;
+    const [nodeQ, nodeS] = [nodeIdsQ, nodeIdsS].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVarN = new VariableNode("n");
+    const nodeInequation = new InequationNode([power(nodeQ, nodeVarN), nodeS], inegSymbol);
+    return `Résoudre dans $\\mathbb{N}$ l'inéquation : 
+    
+$$
+${nodeInequation.toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsQ, nodeIdsS } = identifiers;
+    const [nodeQ, nodeS] = [nodeIdsQ, nodeIdsS].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeIneq = new InequationNode([
+        new VariableNode("n"),
+        Math.ceil(frac(new LogNode(nodeS), new LogNode(nodeQ)).evaluate()).toTree(),
+    ], "\\ge");
+    return nodeIneq;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `La fonction $x \\mapsto \\ln(x)$ est strictement croissante.
+
+Ainsi, si $a$ et $b$ sont deux réels positifs :
+
+${alignTex([
+        ["", "a", ">", "b"],
+        ["\\Leftrightarrow", "\\ln(a)", ">", "\\ln(b)"],
+    ])}
+
+Utilise cette propriété pour arriver à une inéquation du type $n > ...$
+puis arrondis à l'entier supérieur pour arriver à une inéquation du type $n >= ...$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsQ, nodeIdsS, inegSymbol } = identifiers;
+    const [nodeQ, nodeS] = [nodeIdsQ, nodeIdsS].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVarN = new VariableNode("n");
+    const nodeInequation1 = new InequationNode([power(nodeQ, nodeVarN), nodeS], inegSymbol);
+    const nodeInequation2 = new InequationNode([new LogNode(power(nodeQ, nodeVarN)), new LogNode(nodeS)], inegSymbol);
+    const nodeInequation3 = new InequationNode([multiply(nodeVarN, new LogNode(nodeQ)), new LogNode(nodeS)], inegSymbol);
+    const nodeInequation4 = new InequationNode([nodeVarN, frac(new LogNode(nodeS), new LogNode(nodeQ))], ">");
+    const nodeInequation6 = new InequationNode([
+        nodeVarN,
+        Math.ceil(frac(new LogNode(nodeS), new LogNode(nodeQ)).evaluate()).toTree(),
+    ], "\\ge");
+    console.log("nodeInequation6", nodeInequation6.toTex());
+    return `La fonction $x \\mapsto \\ln(x)$ est strictement croissante.
+
+Soit $n$ un entier. On a :
+
+${alignTex([
+        ["\\ \\ ", ...splitAndKeep(nodeInequation1.toTex(), inegSymbol)],
+        ["\\Leftrightarrow", ...splitAndKeep(nodeInequation2.toTex(), inegSymbol)],
+        ["\\Leftrightarrow", ...splitAndKeep(nodeInequation3.toTex(), inegSymbol)],
+        [
+            "\\Leftrightarrow",
+            ...splitAndKeep(nodeInequation4.toTex(), ">"),
+            "\\approx",
+            round(frac(new LogNode(nodeS), new LogNode(nodeQ)).evaluate(), 2).frenchify(),
+        ],
+        ["\\Leftrightarrow", ...splitAndKeep(nodeInequation6.toTex(), "\\\\ge")],
+    ])}
+
+La solution de l'inéquation proposée est donc :
+
+$$
+${nodeInequation6.toTex()}
+$$
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["n", "inf", "leq", "equal", "geq", "sup", "lnBrackets", "epower"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const createRandomIdentifiers = () => {
+    const [nodeQ, nodeS, inegSymbol] = (() => {
+        const isQGreaterThan1 = coinFlip();
+        if (isQGreaterThan1) {
+            const nodeQ = randint(2, 10).toTree();
+            const nodeS = multiply(randint(10, 500), power(10, 3)).simplify({
+                towardsDistribute: true,
+                calculatePowers: true,
+            });
+            const inegSymbol = ">";
+            return [nodeQ, nodeS, inegSymbol];
+        }
+        else {
+            const nodeQ = frac(1, randint(2, 10));
+            const nodeS = multiply(randint(10, 500), power(10, -5)).simplify({
+                towardsDistribute: true,
+                calculatePowers: true,
+            });
+            const inegSymbol = "<";
+            return [nodeQ, nodeS, inegSymbol];
+        }
+    })();
+    const identifiers = {
+        nodeIdsQ: nodeQ.toIdentifiers(),
+        nodeIdsS: nodeS.toIdentifiers(),
+        inegSymbol: inegSymbol,
+    };
+    return identifiers;
+};
+const getLogInequationIntegerSolutionsQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const logInequationIntegerSolutions = {
+    id: "logInequationIntegerSolutions",
+    connector: "=",
+    label: "Résoudre dans $\\mathbb{N}$ une inéquation du type $q^n > s$ ou $q^n < s$ (suivant les valeurs de $q$)",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getLogInequationIntegerSolutionsQuestion, nb),
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+import { InegalitySymbols } from "../../../../math/inequations/inequation.js";
+/**ln(ax+b)<k */
+type Identifiers = {
+    a: number;
+    b: number;
+    nodeIdsK: NodeIdentifiers;
+    inegSymbol: InegalitySymbols;
+    nodeIdsIntervalRequired: NodeIdentifiers;
+};
+type Options = {
+    typeIntervalRequired: string;
+    typeK: string;
+};
+export declare const logInequationLnAXPlusBInfK: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=logInequationLnAXPlusBInfK.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logInequationLnAXPlusBInfK.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logInequationLnAXPlusBInfK.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAgBrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,gBAAgB,EAEjB,MAAM,sCAAsC,CAAC;AAW9C,gBAAgB;AAChB,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,uBAAuB,EAAE,eAAe,CAAC;CAC1C,CAAC;AA+YF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,MAAM,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwBF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}