math-exercises 3.0.156 → 3.0.158

package/lib/exercises/math/calculLitteral/equation/exp/expOfFEqualsExpOfGEquation.js

@@ -0,0 +1,444 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, 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 { EqualNode } from "../../../../../tree/nodes/equations/equalNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { Polynomial } from "../../../../../math/polynomials/polynomial.js";
+import { Trinom } from "../../../../../math/polynomials/trinom.js";
+import { EquationSolutionNode, isEquationSolutionNode, } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { DiscreteSetNode, EmptySet, } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { SetVEA } from "../../../../../exercises/vea/setVEA.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { discreteSetParser } from "../../../../../tree/parsers/discreteSetParser.js";
+import { zip } from "../../../../../utils/arrays/arrayZip.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../../tree/nodes/numbers/infiniteNode.js";
+import { IntervalNode } from "../../../../../tree/nodes/sets/intervalNode.js";
+import { ClosureType } from "../../../../../tree/nodes/sets/closure.js";
+import { InequationSolutionNode } from "../../../../../tree/nodes/inequations/inequationSolutionNode.js";
+import { AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { getCartesiansProducts } from "../../../../../utils/arrays/cartesianProducts.js";
+const texXDomain = `\\mathbb{R}`;
+const texNoSolution = (() => {
+    const trinom = new Trinom(1, 1, 1);
+    return trinom.getRootsEquationSolutionTex(true);
+})();
+const intervalbbR = new IntervalNode(MinusInfinityNode, PlusInfinityNode, ClosureType.OO);
+const texbbR = intervalbbR.toTex();
+const createNodeForCoeffs = (coeffs) => {
+    const [a, b, c] = coeffs.toReversed();
+    if (a !== 0) {
+        return new Polynomial(coeffs).toTree();
+    }
+    else if (b !== 0) {
+        return AffineConstructor.fromCoeffs(coeffs).toTree();
+    }
+    else {
+        return c.toTree();
+    }
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getStatementNode = (identifiers) => {
+    const { coeffsF, coeffsG } = identifiers;
+    const [nodeF, nodeG] = [coeffsF, coeffsG].map(createNodeForCoeffs);
+    const statementTree = new EqualNode(exp(nodeF), exp(nodeG));
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre dans $${texXDomain}$ : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { coeffsF, coeffsG } = identifiers;
+    const [a, b, c] = zip(coeffsF, coeffsG)
+        .map(([kF, kG]) => kF - kG)
+        .toReversed();
+    const isZero = [a, b, c].every((k) => k === 0);
+    if (isZero) {
+        const intervalbbR = new IntervalNode(MinusInfinityNode, PlusInfinityNode, ClosureType.OO);
+        return new InequationSolutionNode(intervalbbR);
+    }
+    else {
+        if (a !== 0) {
+            const trinom = new Trinom(a, b, c);
+            const sortedSols = trinom.getRootsNode();
+            return new EquationSolutionNode(new DiscreteSetNode(sortedSols));
+        }
+        else if (b !== 0) {
+            const nodeSolution = new Rational(-c, b).simplify().toTree();
+            const sortedSols = [nodeSolution];
+            return new EquationSolutionNode(new DiscreteSetNode(sortedSols));
+        }
+        else {
+            //a==0,b==0,c!==0
+            return new EquationSolutionNode(EmptySet);
+        }
+    }
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { coeffsF, coeffsG } = identifiers;
+    const [a, b, c] = zip(coeffsF, coeffsG)
+        .map(([kF, kG]) => kF - kG)
+        .toReversed();
+    const isCoeffsZero = [a, b, c].every((k) => k === 0);
+    if (isCoeffsZero) {
+        if (opts.solutionFormat === "$x=\\ldots$") {
+            return `x\\in${texbbR}`;
+        }
+        else {
+            return `S=${texbbR}`;
+        }
+    }
+    else {
+        const answerNode = getAnswerNode(identifiers);
+        const arrNode = answerNode.solutionsSet.elements;
+        if (arrNode.length > 0) {
+            if (opts.solutionFormat === "$x=\\ldots$") {
+                return answerNode.solutionsSet.elements
+                    .map((node) => `x=${node.toTex()}`)
+                    .join("\\text{ ou }");
+            }
+            else {
+                return `S=\\left\\{${answerNode.solutionsSet.elements
+                    .map((node) => `${node.toTex()}`)
+                    .join(";")}\\right\\}`;
+            }
+        }
+        else {
+            if (opts.solutionFormat === "$x=\\ldots$") {
+                return `x\\in\\varnothing`;
+            }
+            else {
+                return `S=\\varnothing`;
+            }
+        }
+    }
+};
+const getHint = () => {
+    return `Essaye de transformer l'équation originale en une équation du type $e^{h(x)}=1$, puis résous cette équation.`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { coeffsF, coeffsG } = identifiers;
+    const [nodeF, nodeG] = [coeffsF, coeffsG].map(createNodeForCoeffs);
+    //that would be nice, but:
+    //Error: should-throw Too many iterations in simplify
+    // const nodeFMinusGSimplified = substract(nodeF, nodeG).simplify({
+    //   towardsDistribute: true,
+    // });
+    //workaround:
+    const coeffsFMinusG = zip(coeffsF, coeffsG).map(([kF, kG]) => kF - kG);
+    const nodeFMinusGSimplified = createNodeForCoeffs(coeffsFMinusG);
+    return `On va transformer l'équation originale pour se ramener à quelque chose que l'on connaît mieux.
+
+L'ensemble image de la fonction exponentielle est $\\mathbb{R}^{+*}$ donc on peut tout diviser par le membre de droite.
+  
+${alignTex([
+        ["", "", getStatementNode(identifiers).toTex()],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new EqualNode(frac(exp(nodeF), exp(nodeG)), (1).toTree()).toTex(),
+        ],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new EqualNode(exp(substract(nodeF, nodeG)), (1).toTree()).toTex(),
+        ],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new EqualNode(exp(nodeFMinusGSimplified), (1).toTree()).toTex(),
+        ],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new EqualNode(nodeFMinusGSimplified, (0).toTree()).toTex(),
+        ],
+    ])}
+
+On résout l'équation : 
+
+$$
+${getAnswer(identifiers, opts)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { coeffsF, coeffsG } = identifiers;
+    const [a, b, _] = zip(coeffsF, coeffsG)
+        .map(([kF, kG]) => kF - kG)
+        .toReversed();
+    //random coeff signs for f and g
+    {
+        function getArrSign() {
+            return getCartesiansProducts([...Array(3).keys()].map(() => [-1, 1])).filter((arrS) => !arrS.every((s) => s === 1));
+        }
+        getCartesiansProducts([getArrSign(), getArrSign()]).forEach(([arrSignF, arrSignG]) => {
+            const coeffsFWrong = zip(arrSignF, coeffsF).map(([s, k]) => s * k);
+            const coeffsGWrong = zip(arrSignG, coeffsG).map(([s, k]) => s * k);
+            const identifiersWrong = {
+                coeffsF: coeffsFWrong,
+                coeffsG: coeffsGWrong,
+            };
+            const texWrong = getAnswer(identifiersWrong, opts);
+            tryToAddWrongProp(propositions, texWrong);
+        });
+    }
+    propWhile(propositions, n, () => {
+        const wrongAnswer = new Rational(-b + randint(-7, 8, [0, +b]), a + randint(-7, 8, [-a, 0])).simplify();
+        tryToAddWrongProp(propositions, new EqualNode(new VariableNode("x"), wrongAnswer.toTree()).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const answerInputTypes = getAnswerInputTypes(opts);
+    return [
+        ...answerInputTypes.reduce((acc, answerInputType) => {
+            const specialSet = new Set((() => {
+                switch (answerInputType) {
+                    case "x=... ou x=...":
+                        return [
+                            ...["x", "equal", "ou"],
+                            ...[
+                                {
+                                    id: "custom",
+                                    label: texNoSolution,
+                                    labelType: "tex",
+                                    mathfieldInstructions: {
+                                        method: "write",
+                                        content: texNoSolution,
+                                    },
+                                },
+                                {
+                                    id: "custom",
+                                    label: `x\\in${texbbR}`,
+                                    labelType: "tex",
+                                    mathfieldInstructions: {
+                                        method: "write",
+                                        content: `x\\in${texbbR}`,
+                                    },
+                                },
+                            ],
+                        ];
+                    case "S={...;...}":
+                        return [
+                            ...[
+                                "S",
+                                "equal",
+                                "lbrace",
+                                "semicolon",
+                                "rbrace",
+                                "varnothing",
+                            ],
+                            ...[
+                                {
+                                    id: "custom",
+                                    label: `${texbbR}`,
+                                    labelType: "tex",
+                                    mathfieldInstructions: {
+                                        method: "write",
+                                        content: `${texbbR}`,
+                                    },
+                                },
+                            ],
+                        ];
+                    default:
+                        throw new Error("Unsupported answerInputType: " + answerInputType);
+                }
+            })());
+            return new Set([...acc, ...specialSet]);
+        }, new Set()),
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const answerInputTypes = getAnswerInputTypes(opts);
+    const answerNode = getAnswerNode(identifiers);
+    if (isEquationSolutionNode(answerNode)) {
+        const arrNodeAnswer = answerNode.solutionsSet
+            .elements;
+        function getParsedNodesForAnswerInputType(ans, answerInputType) {
+            switch (answerInputType) {
+                case "x=... ou x=...":
+                    {
+                        const formated = ans
+                            .replaceAll("text{ ou }", ";")
+                            .replaceAll("x", "")
+                            .replaceAll("=", "");
+                        const elements = formated.split(";").map((e) => parseAlgebraic(e));
+                        return elements;
+                    }
+                    break;
+                case "S={...;...}":
+                    {
+                        const discreteSetNodeCandidate = discreteSetParser(ans);
+                        if (discreteSetNodeCandidate) {
+                            return discreteSetNodeCandidate.elements;
+                        }
+                        else {
+                            return [];
+                        }
+                    }
+                    break;
+                default:
+                    throw new Error("Unsupported answerInputType: " + answerInputType);
+            }
+        }
+        function isAnswerValidForAnswerInputType(answerInputType) {
+            try {
+                if (arrNodeAnswer.length === 0) {
+                    switch (answerInputType) {
+                        case "x=... ou x=...":
+                            return ans === texNoSolution;
+                        case "S={...;...}":
+                            return ans === `S=\\varnothing`;
+                        default:
+                            throw new Error("Unsupported answerInputType: " + answerInputType);
+                    }
+                }
+                else {
+                    const arrAns = getParsedNodesForAnswerInputType(ans, answerInputType);
+                    return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+                }
+            }
+            catch (_) {
+                return false;
+            }
+        }
+        return answerInputTypes.some((answerInputType) => isAnswerValidForAnswerInputType(answerInputType));
+    }
+    else {
+        const inequationSolutionNode = answerNode;
+        const texInterval = inequationSolutionNode.intervalSolution.toTex();
+        function isAnswerValidForAnswerInputType(answerInputType) {
+            switch (answerInputType) {
+                case "x=... ou x=...":
+                    return `x\\in${texInterval}`;
+                case "S={...;...}":
+                    return `S=${texInterval}`;
+                default:
+                    throw new Error("Unsupported answerInputType: " + answerInputType);
+            }
+        }
+        return answerInputTypes.some((answerInputType) => isAnswerValidForAnswerInputType(answerInputType));
+    }
+};
+const getExpOfFEqualsExpOfGEquationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { functionTypeF, functionTypeG } = opts;
+    function degreeForFunctionType(functionType) {
+        switch (functionType) {
+            case "constante":
+                return 0;
+            case "degré $1$":
+                return 1;
+            case "degré $2$":
+                return 2;
+            default:
+                throw new Error("Unsupported functionType: " + functionType);
+        }
+    }
+    const [degreeF, degreeG] = [functionTypeF, functionTypeG].map(degreeForFunctionType);
+    function createCoeffs(degree) {
+        const c = randint(-10, 11, [0]);
+        const b = degree >= 1 ? randint(-10, 11, [0]) : 0;
+        const a = degree >= 2 ? randint(-10, 11, [0]) : 0;
+        return [c, b, a];
+    }
+    const [coeffsF, coeffsG] = [degreeF, degreeG].map(createCoeffs);
+    const identifiers = { coeffsF, coeffsG };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getAnswerInputTypes = (opts) => {
+    const { solutionFormat } = opts;
+    switch (solutionFormat) {
+        case "$x=\\ldots$":
+            return ["x=... ou x=..."];
+        case "Ensemble":
+            return ["S={...;...}"];
+        case "Permettre les deux":
+            return ["x=... ou x=...", "S={...;...}"];
+        default:
+            throw new Error("Unsupported solutionFormat: " + solutionFormat);
+    }
+};
+const optsDefault = {
+    solutionFormat: "Permettre les deux",
+    functionTypeF: "degré $1$",
+    functionTypeG: "degré $1$",
+};
+const options = [
+    {
+        id: "solutionFormat",
+        label: "Donner la solution sous la forme :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Ensemble", "$x=\\ldots$", "Permettre les deux"],
+        defaultValue: optsDefault.solutionFormat,
+    },
+    {
+        id: "functionTypeF",
+        label: "Fonction $f$ :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["constante", "degré $1$", "degré $2$"],
+        defaultValue: optsDefault.functionTypeF,
+    },
+    {
+        id: "functionTypeG",
+        label: "Fonction $g$ :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["constante", "degré $1$", "degré $2$"],
+        defaultValue: optsDefault.functionTypeG,
+    },
+];
+export const expOfFEqualsExpOfGEquation = {
+    id: "expOfFEqualsExpOfGEquation",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $e^{f(x)}=e^{g(x)}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpOfFEqualsExpOfGEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/calculLitteral/equation/exp/expOfTrinomEquals1Equation.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+/**
+ *  e^{ax²+bx+c}=1
+ */
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+};
+type Options = {
+    solutionFormat: string;
+};
+export declare const expOfTrinomEquals1Equation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=expOfTrinomEquals1Equation.d.ts.map

package/lib/exercises/math/calculLitteral/equation/exp/expOfTrinomEquals1Equation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expOfTrinomEquals1Equation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/exp/expOfTrinomEquals1Equation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAyBrC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0TF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAgBF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBrE,CAAC"}