math-exercises 2.0.43 → 2.1.0

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log10PowerSimplifying = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../../../math/numbers/decimals/decimal");
+const randint_1 = require("../../../../math/utils/random/randint");
+const log10Node_1 = require("../../../../tree/nodes/functions/log10Node");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const probaFlip_1 = require("../../../../utils/probaFlip");
+const getLog10PowerSimplifyingQuestion = () => {
+    const tenthPower = (0, randint_1.randint)(-5, 6, [0, 1]);
+    const shouldEvaluate = (0, probaFlip_1.probaFlip)(0.7);
+    console.log("log10 power simp q");
+    const nb = shouldEvaluate
+        ? new decimal_1.Decimal(1).multiplyByPowerOfTen(tenthPower).toTree()
+        : new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(tenthPower));
+    const answer = tenthPower + "";
+    const question = {
+        answer,
+        instruction: `Calculer : $${new log10Node_1.Log10Node(nb).toTex()}$`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { tenthPower, nbTex: nb.toTex() },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, tenthPower }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "10");
+    (0, exercise_1.tryToAddWrongProp)(propositions, tenthPower + 1 + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, tenthPower + 2 + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, tenthPower - 1 + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, tenthPower - 2 + "");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, tenthPower }) => {
+    return ans === answer;
+};
+exports.log10PowerSimplifying = {
+    id: "log10PowerSimplifying",
+    connector: "=",
+    label: "Calculer un logarithme décimal",
+    levels: ["TermTech", "MathComp"],
+    isSingleStep: true,
+    sections: ["Logarithme décimal", "Puissances"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLog10PowerSimplifyingQuestion, nb, 15),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    maxAllowedQuestions: 15,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    nb: number;
+    powers: number[];
+    signs: number[];
+    isLog10: boolean;
+};
+export declare const log10SumSimplifying: Exercise<Identifiers>;
+export declare const logSumSimplifying: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=log10Simplifying.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log10Simplifying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/log10Simplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAalC,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;AA0FF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC;AACF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAiBnD,CAAC"}

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logSumSimplifying = exports.log10SumSimplifying = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const log10Node_1 = require("../../../../tree/nodes/functions/log10Node");
+const logNode_1 = require("../../../../tree/nodes/functions/logNode");
+const oppositeNode_1 = require("../../../../tree/nodes/functions/oppositeNode");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const operatorComposition_1 = require("../../../../tree/utilities/operatorComposition");
+const random_1 = require("../../../../utils/random");
+const getLog10SumSimplifyingQuestion = (opts) => {
+    const nb = (0, randint_1.randint)(2, 10);
+    const trueNb = [2, 4, 8].includes(nb) ? 2 : [3, 9].includes(nb) ? 3 : nb;
+    const nbTerms = (0, randint_1.randint)(2, 4);
+    const powers = [];
+    const signs = [];
+    for (let i = 0; i < nbTerms; i++) {
+        const power = (0, randint_1.randint)(powers.includes(1) ? 2 : 1, 6, powers);
+        powers.push(power);
+        signs.push((0, random_1.random)([-1, 1]));
+    }
+    const nbNode = new numberNode_1.NumberNode(nb);
+    const LNode = opts?.isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    const logs = powers.map((power, index) => nb ** power < 100
+        ? signs[index] > 0
+            ? new LNode(new numberNode_1.NumberNode(nb ** power))
+            : new oppositeNode_1.OppositeNode(new LNode(new numberNode_1.NumberNode(nb ** power)))
+        : signs[index] > 0
+            ? new LNode(new powerNode_1.PowerNode(nbNode, new numberNode_1.NumberNode(power)))
+            : new oppositeNode_1.OppositeNode(new LNode(new powerNode_1.PowerNode(nbNode, new numberNode_1.NumberNode(power)))));
+    const statement = (0, operatorComposition_1.operatorComposition)(addNode_1.AddNode, logs);
+    const answer = statement.simplify();
+    const question = {
+        answer: answer.toTex(),
+        instruction: `Exprimer le nombre suivant sous la forme $a${opts?.isLog10 ? "\\log" : "\\ln"}\\left(${trueNb}\\right)$ : $\\newline ${statement.toTex()}$`,
+        keys: [opts?.isLog10 ? "log" : "ln"],
+        answerFormat: "tex",
+        identifiers: { nb, powers, signs, isLog10: opts?.isLog10 ?? false },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, nb, isLog10 }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const LNode = isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode((0, randint_1.randint)(1, 10)), new LNode(new numberNode_1.NumberNode(nb)))
+            .simplify()
+            .toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { nb, powers, signs, isLog10 }) => {
+    const nbNode = new numberNode_1.NumberNode(nb);
+    const LNode = isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    const logs = powers.map((power, index) => nb ** power < 100
+        ? signs[index] > 0
+            ? new LNode(new numberNode_1.NumberNode(nb ** power))
+            : new oppositeNode_1.OppositeNode(new LNode(new numberNode_1.NumberNode(nb ** power)))
+        : signs[index] > 0
+            ? new LNode(new powerNode_1.PowerNode(nbNode, new numberNode_1.NumberNode(power)))
+            : new oppositeNode_1.OppositeNode(new LNode(new powerNode_1.PowerNode(nbNode, new numberNode_1.NumberNode(power)))));
+    const statement = (0, operatorComposition_1.operatorComposition)(addNode_1.AddNode, logs);
+    const answer = statement.simplify();
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.log10SumSimplifying = {
+    id: "log10SumSimplifying",
+    connector: "=",
+    label: "Simplifer une somme de logarithmes décimaux",
+    levels: ["TermTech"],
+    isSingleStep: true,
+    sections: ["Logarithme décimal"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getLog10SumSimplifyingQuestion({ isLog10: true }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};
+exports.logSumSimplifying = {
+    id: "logSumSimplifying",
+    connector: "=",
+    label: "Simplifer une somme de logarithmes népériens",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Logarithme népérien"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getLog10SumSimplifyingQuestion({ isLog10: false }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise";
+/**aln(x)=k */
+type Identifiers = {
+    a: number;
+    k: number;
+};
+export declare const logEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=logEquation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAclC,cAAc;AACd,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoEF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logEquation = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../../math/utils/random/randint");
+const equationSolutionNode_1 = require("../../../../tree/nodes/equations/equationSolutionNode");
+const expNode_1 = require("../../../../tree/nodes/functions/expNode");
+const logNode_1 = require("../../../../tree/nodes/functions/logNode");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const discreteSetNode_1 = require("../../../../tree/nodes/sets/discreteSetNode");
+const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getLnEquation = () => {
+    const a = (0, randint_1.randint)(-9, 20, [0]);
+    const k = (0, randint_1.randint)(-9, 20, [0]);
+    const equation = new equalNode_1.EqualNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new logNode_1.LogNode(new variableNode_1.VariableNode("x"))), new numberNode_1.NumberNode(k));
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([new expNode_1.ExpNode(new rational_1.Rational(k, a).simplify().toTree())])).toTex();
+    const question = {
+        instruction: `Résoudre l'équation $${equation.toTex()}$.`,
+        answer,
+        keys: [
+            "x",
+            "equal",
+            "ln",
+            "e",
+            "epower",
+            "exp",
+            "lbrace",
+            "S",
+            "semicolon",
+            "rbrace",
+        ],
+        answerFormat: "tex",
+        identifiers: { a, k },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const randomA = (0, randint_1.randint)(1, 10);
+        const randomK = (0, randint_1.randint)(1, 20);
+        (0, exercise_1.tryToAddWrongProp)(propositions, new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+            new expNode_1.ExpNode(new rational_1.Rational(randomK, randomA).simplify().toTree()),
+        ])).toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, k }) => {
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+        new expNode_1.ExpNode(new rational_1.Rational(k, a).simplify().toTree({ allowFractionToDecimal: true })),
+    ]));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.logEquation = {
+    id: "logEquation",
+    connector: "=",
+    label: "Résoudre des équations de type $a \\times \\ln(x) = k$",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    sections: ["Logarithme népérien", "Exponentielle"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLnEquation, nb),
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    a: number;
+    powered: number;
+    c: number;
+    k: number;
+    isLog10: boolean;
+};
+export declare const logPowerEquation: Exercise<Identifiers>;
+export declare const log10PowerEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=logPowerEquation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logPowerEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logPowerEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAgBlC,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;AAwGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log10PowerEquation = exports.logPowerEquation = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
+const equationSolutionNode_1 = require("../../../../tree/nodes/equations/equationSolutionNode");
+const log10Node_1 = require("../../../../tree/nodes/functions/log10Node");
+const logNode_1 = require("../../../../tree/nodes/functions/logNode");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const discreteSetNode_1 = require("../../../../tree/nodes/sets/discreteSetNode");
+const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
+/**a*b^x+c=d */
+const getLogPowerEquationQuestion = (opts) => {
+    const powered = (0, randint_1.randint)(2, 8);
+    const a = (0, randint_1.randint)(1, 10, [powered]);
+    const c = (0, randint_1.randint)(-5, 5, [a]);
+    const k = (0, randint_1.randint)(5, 15, [powered]);
+    const d = k * a + c;
+    const xNode = new variableNode_1.VariableNode("x");
+    const poweredNode = new numberNode_1.NumberNode(powered);
+    const LNode = opts?.isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+        new fractionNode_1.FractionNode(new LNode(new numberNode_1.NumberNode(k)), new LNode(poweredNode)).simplify(),
+    ])).toTex();
+    const equation = new equalNode_1.EqualNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new powerNode_1.PowerNode(poweredNode, xNode)), new numberNode_1.NumberNode(c)).simplify(), new numberNode_1.NumberNode(d));
+    const keys = [
+        "log",
+        "x",
+        "equal",
+        "S",
+        "lbrace",
+        "semicolon",
+        "rbrace",
+    ];
+    keys.push(opts?.isLog10 ? "log" : "ln");
+    const question = {
+        answer,
+        instruction: `Résoudre : $${equation.toTex()}$`,
+        keys,
+        answerFormat: "tex",
+        identifiers: { a, c, k, powered, isLog10: opts?.isLog10 ?? false },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, isLog10, a, c, k, powered }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const LNode = isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    const withoutLogs = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+        new fractionNode_1.FractionNode(new numberNode_1.NumberNode(k), new numberNode_1.NumberNode(powered)).simplify(),
+    ]));
+    (0, exercise_1.tryToAddWrongProp)(propositions, withoutLogs.toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+            new fractionNode_1.FractionNode(new LNode(new numberNode_1.NumberNode((0, randint_1.randint)(2, 10))), new LNode(new numberNode_1.NumberNode((0, randint_1.randint)(2, 10)))).simplify(),
+        ])).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { a, c, k, powered, isLog10 }) => {
+    const LNode = isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    const poweredNode = new numberNode_1.NumberNode(powered);
+    const answerSimp = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+        new fractionNode_1.FractionNode(new LNode(new numberNode_1.NumberNode(k)), new LNode(poweredNode)).simplify(),
+    ]));
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+        new fractionNode_1.FractionNode(new LNode(new numberNode_1.NumberNode(k)), new LNode(poweredNode)),
+    ]));
+    const texs = [...answerSimp.toAllValidTexs(), ...answer.toAllValidTexs()];
+    return texs.includes(ans);
+};
+exports.logPowerEquation = {
+    id: "logPowerEquation",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $a\\times b^x + c = d$ grâce au logarithme décimal",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Logarithme népérien", "Puissances"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLogPowerEquationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};
+exports.log10PowerEquation = {
+    id: "log10PowerEquation",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $a\\times b^x + c = d$ grâce au logarithme népérien",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Logarithme décimal", "Puissances"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getLogPowerEquationQuestion({ isLog10: true }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    pm: number;
+    a: number;
+    b: number;
+};
+export declare const logSimplifiying: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=logSimplifiying.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logSimplifiying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logSimplifiying = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../../math/utils/random/randint");
+const logNode_1 = require("../../../../tree/nodes/functions/logNode");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../../../tree/nodes/operators/addNode");
+const substractNode_1 = require("../../../../tree/nodes/operators/substractNode");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getExpSimplifiying = () => {
+    let expression;
+    let simplifiedExpression;
+    let pm = (0, coinFlip_1.coinFlip)() ? 1 : -1;
+    const a = (0, randint_1.randint)(1, 10);
+    let b;
+    do {
+        b = (0, randint_1.randint)(1, 10);
+    } while (pm === -1 && a === b);
+    const opts = { allowLnOfOne: true };
+    if (pm === 1) {
+        expression = new addNode_1.AddNode(new logNode_1.LogNode(new numberNode_1.NumberNode(a), opts), new logNode_1.LogNode(new numberNode_1.NumberNode(b), opts));
+        simplifiedExpression = new logNode_1.LogNode(new numberNode_1.NumberNode(a * b));
+    }
+    else {
+        expression = new substractNode_1.SubstractNode(new logNode_1.LogNode(new numberNode_1.NumberNode(a), opts), new logNode_1.LogNode(new numberNode_1.NumberNode(b), opts));
+        simplifiedExpression = new logNode_1.LogNode(new rational_1.Rational(a, b).simplify().toTree());
+    }
+    const answer = simplifiedExpression.toTex();
+    const question = {
+        instruction: `Ecrire le nombre suivant sous la forme $\\ln\\left(a\\right)$ : $\\newline ${expression.toTex()}$.`,
+        answer,
+        keys: ["ln"],
+        answerFormat: "tex",
+        identifiers: { pm, a, b },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, pm }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const a = (0, randint_1.randint)(1, 10);
+        const b = (0, randint_1.randint)(1, 10);
+        (0, exercise_1.tryToAddWrongProp)(propositions, pm > 0
+            ? new logNode_1.LogNode(new numberNode_1.NumberNode(a * b)).toTex()
+            : new logNode_1.LogNode(new rational_1.Rational(a, b).simplify().toTree()).toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, pm }) => {
+    let answer;
+    if (pm === 1) {
+        answer = new logNode_1.LogNode(new numberNode_1.NumberNode(a * b));
+    }
+    else {
+        answer = new logNode_1.LogNode(new rational_1.Rational(a, b).simplify().toTree({ allowFractionToDecimal: true }));
+    }
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.logSimplifiying = {
+    id: "logSimplifiying",
+    connector: "\\iff",
+    label: "Simplifier des expressions avec $\\ln$",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    sections: ["Logarithme népérien"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getExpSimplifiying, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,3 @@
+export * from "./parityFromAlgebra";
+export * from "./parityFromGraph";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/parity/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parityFromAlgebra"), exports);
+__exportStar(require("./parityFromGraph"), exports);

package/lib/exercises/math/functions/parity/parityFromAlgebra.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    type: string;
+    fctTex: string;
+};
+export declare const parityFromAlgebra: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parityFromAlgebra.d.ts.map

package/lib/exercises/math/functions/parity/parityFromAlgebra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parityFromAlgebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/parity/parityFromAlgebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAoGF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAcnD,CAAC"}

package/lib/exercises/math/functions/parity/parityFromAlgebra.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parityFromAlgebra = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const affine_1 = require("../../../../math/polynomials/affine");
+const polynomial_1 = require("../../../../math/polynomials/polynomial");
+const rationalFrac_1 = require("../../../../math/polynomials/rationalFrac");
+const trinom_1 = require("../../../../math/polynomials/trinom");
+const randint_1 = require("../../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const doWhile_1 = require("../../../../utils/doWhile");
+const probaFlip_1 = require("../../../../utils/probaFlip");
+const probaLawFlip_1 = require("../../../../utils/probaLawFlip");
+const getParityFromAlgebraQuestion = () => {
+    //paires : ax^2 + b   , frac ratio trinom/tirnom
+    //impaires : linéaires, ax^3, linéaire/trinom
+    // ni l'un ni l'autre : affines, trinomes avec ax, x^3 + b
+    const type = (0, probaLawFlip_1.probaLawFlip)([
+        ["even", 0.33],
+        ["uneven", 0.33],
+        ["neither", 0.33],
+    ]);
+    let fct;
+    let answer = "";
+    switch (type) {
+        case "even":
+            if ((0, coinFlip_1.coinFlip)()) {
+                fct = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10))
+                    .toTree()
+                    .toTex();
+            }
+            else {
+                let num = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10));
+                let denum = (0, doWhile_1.doWhile)(() => new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10)), (P) => (num.c === 0 ? P.c !== 0 : P.a / num.a === P.c / num.c));
+                fct = new rationalFrac_1.RationalFrac(num, denum).toTree().toTex();
+            }
+            answer = "Paire";
+            break;
+        case "uneven":
+            if ((0, probaFlip_1.probaFlip)(0.33)) {
+                fct = new affine_1.Affine((0, randint_1.randint)(-10, 11, [0]), 0).toTree().toTex();
+            }
+            else {
+                if ((0, coinFlip_1.coinFlip)()) {
+                    fct = new polynomial_1.Polynomial([0, (0, randint_1.randint)(-10, 11), 0, (0, randint_1.randint)(-10, 11, [0])])
+                        .toTree()
+                        .toTex();
+                }
+                else {
+                    let num = new affine_1.Affine((0, randint_1.randint)(-9, 10, [0]), 0);
+                    let denum = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), 0, (0, randint_1.randint)(-9, 10, [0]));
+                    fct = new rationalFrac_1.RationalFrac(num, denum).toTree().toTex();
+                }
+            }
+            answer = "Impaire";
+            break;
+        case "neither":
+            if ((0, probaFlip_1.probaFlip)(0.33)) {
+                fct = new affine_1.Affine((0, randint_1.randint)(-9, 10, [0]), (0, randint_1.randint)(-9, 10, [0]))
+                    .toTree()
+                    .toTex();
+            }
+            else {
+                if ((0, coinFlip_1.coinFlip)()) {
+                    fct = new trinom_1.Trinom((0, randint_1.randint)(-9, 10, [0]), (0, randint_1.randint)(-9, 10, [0]), (0, randint_1.randint)(-9, 10))
+                        .toTree()
+                        .toTex();
+                }
+                else {
+                    fct = new polynomial_1.Polynomial([
+                        (0, randint_1.randint)(-9, 10),
+                        (0, randint_1.randint)(-9, 10),
+                        (0, randint_1.randint)(-9, 10, [0]),
+                        (0, randint_1.randint)(-9, 10, [0]),
+                    ])
+                        .toTree()
+                        .toTex();
+                }
+            }
+            answer = "Ni paire, ni impaire";
+            break;
+    }
+    const question = {
+        answer,
+        instruction: `Soit $f(x) = ${fct}$. La fonction $f$ est-elle paire, impaire, ou ni paire ni impaire ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { type, fctTex: fct },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Paire", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Impaire", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Ni paire ni impaire", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.parityFromAlgebra = {
+    id: "parityFromAlgebra",
+    label: "Déterminer algébriquement la parité d'une fonction",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Fonctions"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getParityFromAlgebraQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCM",
+    subject: "Mathématiques",
+};

package/lib/exercises/math/functions/parity/parityFromGraph.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    type: string;
+    fctCmd: string;
+};
+export declare const parityFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parityFromGraph.d.ts.map

package/lib/exercises/math/functions/parity/parityFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parityFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/parity/parityFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA4GF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}