math-exercises 3.0.157 → 3.0.158

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

@@ -0,0 +1,292 @@
+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 { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { Polynomial } from "../../../../../math/polynomials/polynomial.js";
+import { Trinom } from "../../../../../math/polynomials/trinom.js";
+import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { DiscreteSetNode } 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 { getCartesiansProducts } from "../../../../../utils/arrays/cartesianProducts.js";
+const texXDomain = `\\mathbb{R}`;
+const texNoSolution = (() => {
+    const trinom = new Trinom(1, 1, 1);
+    return trinom.getRootsEquationSolutionTex(true);
+})();
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getChildOfExpNode = (identifiers) => {
+    const { a, b, c } = identifiers;
+    return new Polynomial([c, b, a]).toTree();
+};
+const getStatementNode = (identifiers) => {
+    const nodeChildOfExp = getChildOfExpNode(identifiers);
+    const statementTree = new EqualNode(exp(nodeChildOfExp), (1).toTree());
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre dans $${texXDomain}$ : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const sortedSols = trinom.getRootsNode();
+    return new EquationSolutionNode(new DiscreteSetNode(sortedSols));
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const answer = trinom.getRootsEquationSolutionTex(opts.solutionFormat === "$x=\\ldots$");
+    return answer;
+};
+const getHint = () => {
+    return `Pour quelle valeur de $t$ a-t-on $e^t=1$ ? 
+  
+Quelle équation faut-il donc résoudre ?`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const nodeChildOfExp = getChildOfExpNode(identifiers);
+    return `L'équation est de la forme $e^{u(x)}=1$ avec $u(x)=${nodeChildOfExp.toTex()}$.
+
+La fonction exponentielle est strictement croissante de $\\mathbb{R}$ dans $\\mathbb{R}^{+*}$.
+
+Pour $t$ dans $\\mathbb{R}$, on a :
+
+$$
+e^t=1 \\Leftrightarrow t=0
+$$
+
+Ici, on a donc :
+
+$$
+e^{u(x)}=1 \\Leftrightarrow u(x)=0
+$$
+
+Conclusion :
+
+${alignTex([
+        ["", "", `e^{${nodeChildOfExp.toTex()}}=1`],
+        ["", `\\Leftrightarrow`, `${nodeChildOfExp.toTex()}=0`],
+        ["", `\\Leftrightarrow`, `${getAnswer(identifiers, opts)}`],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { a, b, c } = identifiers;
+    //random coeff signs
+    {
+        const arrIdentifiersWrong = getCartesiansProducts([...Array(3).keys()].map(() => [-1, 1]))
+            .filter((arrS) => !arrS.every((s) => s === 1))
+            .map(([sA, sB, sC]) => {
+            const identifiersWrong = {
+                a: sA * a,
+                b: sB * b,
+                c: sC * c,
+            };
+            return identifiersWrong;
+        });
+        arrIdentifiersWrong.forEach((identifiersWrong) => {
+            const texWrong = getAnswer(identifiersWrong, opts);
+            tryToAddWrongProp(propositions, texWrong);
+        });
+    }
+    //student makes as if exp was not there
+    {
+        const trinom = new Trinom(a, b, c - 1);
+        const texWrong = trinom.getRootsEquationSolutionTex(opts.solutionFormat === "$x=\\ldots$");
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //student divides both sides by e
+    // {
+    //   const trinom = new Trinom(a, b, c - frac(1, exp(1)));
+    //   const texWrong = trinom.getRootsEquationSolutionTex(
+    //     opts.solutionFormat === "$x=\\ldots$",
+    //   );
+    //   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"],
+                            ...[
+                                (() => {
+                                    return {
+                                        id: "custom",
+                                        label: texNoSolution,
+                                        labelType: "tex",
+                                        mathfieldInstructions: {
+                                            method: "write",
+                                            content: texNoSolution,
+                                        },
+                                    };
+                                })(),
+                            ],
+                        ];
+                    case "S={...;...}":
+                        return [
+                            "S",
+                            "equal",
+                            "lbrace",
+                            "semicolon",
+                            "rbrace",
+                            "varnothing",
+                        ];
+                    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);
+    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));
+};
+const getExpOfTrinomEquals1EquationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const c = randint(-10, 11, [0]);
+    const b = randint(-10, 11, [0]);
+    const a = randint(-10, 11, [0, 1]);
+    const identifiers = { a, b, c };
+    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",
+};
+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,
+    },
+];
+export const expOfTrinomEquals1Equation = {
+    id: "expOfTrinomEquals1Equation",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $e^{ax^2+bx+c}=1$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpOfTrinomEquals1EquationQuestion(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/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./expOfAffineEquals1Equation.js";
+export * from "./expOfTrinomEquals1Equation.js";
+export * from "./expOfFEqualsExpOfGEquation.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/exp/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./expOfAffineEquals1Equation.js";
+export * from "./expOfTrinomEquals1Equation.js";
+export * from "./expOfFEqualsExpOfGEquation.js";

package/lib/exercises/math/calculLitteral/inequations/exp/expOfFEqualsExpOfGInequation.d.ts

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { InegalitySymbols } from "../../../../../math/inequations/inequation.js";
+/**
+ *  e^{f(x)}<e^{g(x)}
+ */
+type Identifiers = {
+    coeffsF: number[];
+    coeffsG: number[];
+    ineqType: InegalitySymbols;
+};
+type Options = {
+    inequationSolutionFormat: string;
+    functionTypeF: string;
+    functionTypeG: string;
+};
+export declare const expOfFEqualsExpOfGInequation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=expOfFEqualsExpOfGInequation.d.ts.map

package/lib/exercises/math/calculLitteral/inequations/exp/expOfFEqualsExpOfGInequation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expOfFEqualsExpOfGInequation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/inequations/exp/expOfFEqualsExpOfGInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAqBrC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAiH9C;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAgYF,KAAK,OAAO,GAAG;IACb,wBAAwB,EAAE,MAAM,CAAC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AA2BF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBvE,CAAC"}