math-exercises 3.0.164 → 3.0.165

package/lib/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationEqualsC.js

@@ -0,0 +1,146 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../../tree/parsers/discreteSetParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([randint(-9, 0), randint(1, 10)].map((e) => e.toTree()))).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const root = frac(opposite(b), a).simplify();
+    return new EquationSolutionNode(new DiscreteSetNode([(0).toTree(), root].sort((a, b) => a.evaluate() - b.evaluate()))).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    return `Résoudre : 
+  
+$$
+${add(add(multiply(a, square("x")), multiply(b, "x")), c)
+        .simplify({ forbidFactorize: true })
+        .toTex()} = ${c.toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Fais en sorte que le membre de droite soit nul.
+  
+Puis, factorise le membre de gauche pour te ramener à une équation produit nul.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    return `On a : 
+  
+${alignTex([
+        [
+            add(add(multiply(a, square("x")), multiply(b, "x")), c)
+                .simplify({ forbidFactorize: true })
+                .toTex(),
+            "=",
+            c.toTex(),
+        ],
+        [
+            add(multiply(a, square("x")), multiply(b, "x"))
+                .simplify({ forbidFactorize: true })
+                .toTex(),
+            "=",
+            "0",
+        ],
+        [multiply("x", add(multiply(a, "x"), b)).toTex(), "=", "0"],
+    ])}
+
+On résout alors cette équation produit nul. Cela donne : 
+
+$$
+x = 0
+$$
+
+ou 
+
+$$
+${add(multiply(a, "x"), b).toTex()} = 0 \\iff x = ${frac(opposite(b), a)
+        .simplify()
+        .toTex()}
+$$
+
+Les solutions sont donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = discreteSetParser(ans);
+        if (!parsed)
+            return false;
+        return ("S=" + parsed.simplify({ decimalToFractions: true }).toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSolveSecondDegreeEquationEqualsCQuestion = () => {
+    const a = randint(-9, 10, [0]);
+    const b = randint(-9, 10, [0]);
+    const c = randint(-9, 10, [0]);
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        bIds: b.toTree().toIdentifiers(),
+        cIds: c.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const solveSecondDegreeEquationEqualsC = {
+    id: "solveSecondDegreeEquationEqualsC",
+    connector: "\\iff",
+    label: "Résoudre par factorisation une équation du second degré du type $ax^2+bx+c=c$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSolveSecondDegreeEquationEqualsCQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationFromCano.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solveSecondDegreeEquationFromCano.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationFromCano.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAyEF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAanE,CAAC"}
+{"version":3,"file":"solveSecondDegreeEquationFromCano.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationFromCano.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA4IF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAcnE,CAAC"}

package/lib/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationFromCano.js

@@ -1,10 +1,16 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
-import { equationKeys } from "../../../../../exercises/utils/keys/equationKeys.js";
 import { TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
 import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
 import { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const { coeffs } = identifiers;
     const trinom = TrinomConstructor.fromCoeffs(coeffs);
@@ -25,17 +31,80 @@ const getAnswer = (identifiers) => {
     return answer;
 };
 const getSolveSecondDegreeEquationFromCanoQuestion = () => {
-    const trinom = TrinomConstructor.randomNiceRootsAndSummit();
+    const trinom = TrinomConstructor.randomNiceRootsAndSummit(2);
     const identifiers = { coeffs: trinom.coefficients };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = () => {
+    return `Ramène toi à une équation du type $X^2 = k$. 
+  
+On sait alors que ce type d'équation : 
+- n'a pas de solution réelle si $k<0$;
+- a pour unique solution réelle $0$ si $k=0$;
+- a deux solutions $\\sqrt{k}$ et $-\\sqrt{k}$ si $k>0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs } = identifiers;
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    const a = trinom.a;
+    const alpha = trinom.getAlphaNode();
+    const beta = trinom.getBetaNode();
+    const cano = trinom.getCanonicalForm();
+    const k = frac(opposite(beta), a).simplify();
+    const roots = trinom.getRootsNode();
+    return `On a : 
+  
+${alignTex([
+        [cano.toTex(), "=", "0"],
+        [
+            substract(cano, beta).simplify({ forbidFactorize: true }).toTex(),
+            "=",
+            opposite(beta).simplify().toTex(),
+        ],
+        [square(substract("x", alpha).simplify()).toTex(), "=", k.toTex()],
+    ])}
+
+${alpha.evaluate() === 0
+        ? `Cela donne donc deux solutions : $${roots[0].toTex()}$ et $${roots[1].toTex()}$.`
+        : `
+On résout alors deux équations : 
+
+${alignTex([
+            [substract("x", alpha).simplify().toTex(), "=", sqrt(k).simplify().toTex()],
+            ["x", "=", add(alpha, sqrt(k)).simplify().toTex()],
+        ])}
+
+ou 
+
+${alignTex([
+            [
+                substract("x", alpha).simplify().toTex(),
+                "=",
+                opposite(sqrt(k)).simplify().toTex(),
+            ],
+            ["x", "=", substract(alpha, sqrt(k)).simplify().toTex()],
+        ])}
+  `}
+  
+L'ensemble des solutions est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$
+  `;
+};
+const getKeys = () => {
+    return ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"];
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: [...equationKeys],
+        keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -68,4 +137,5 @@ export const solveSecondDegreeEquationFromCano = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/trinoms/equation/trinomSelectEquationWithoutDeltaNeeded.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type EquationIds = {
+    a: number;
+    b: number;
+    c: number;
+    form: "dev" | "cano" | "facto";
+};
+type Identifiers = {
+    equations: EquationIds[];
+};
+export declare const trinomSelectEquationWithoutDeltaNeeded: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=trinomSelectEquationWithoutDeltaNeeded.d.ts.map

package/lib/exercises/math/functions/trinoms/equation/trinomSelectEquationWithoutDeltaNeeded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trinomSelectEquationWithoutDeltaNeeded.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/equation/trinomSelectEquationWithoutDeltaNeeded.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AACF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,WAAW,EAAE,CAAC;CAC1B,CAAC;AA6MF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAqBxE,CAAC"}

package/lib/exercises/math/functions/trinoms/equation/trinomSelectEquationWithoutDeltaNeeded.js

@@ -0,0 +1,204 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { doWhile } from "../../../../../utils/doWhile.js";
+const buildEquation = (equationIds) => {
+    const { a, b, c, form } = equationIds;
+    const trinom = new Trinom(a, b, c);
+    if (form === "dev")
+        return trinom.toTree();
+    if (form === "cano")
+        return trinom.getCanonicalForm();
+    return trinom.toFactorized();
+};
+const isEqWithoutDelta = (equationIds) => {
+    const { b, c, form } = equationIds;
+    return form === "cano" || form === "facto" || b === 0 || c === 0;
+};
+const getPropositions = (n, { answer: _answer, equations }) => {
+    const propositions = [];
+    equations.forEach((eq) => {
+        (isEqWithoutDelta(eq) ? addValidProp : tryToAddWrongProp)(propositions, buildEquation(eq).toTex() + "=0");
+    });
+    return shuffleProps(propositions, n);
+};
+const getInstruction = () => {
+    return `Parmi les équations suivantes, laquelle ou lesquelles sont plus rapides à résoudre sans utiliser le discriminant ?`;
+};
+const getHint = () => {
+    return `Il n'est pas toujours nécessaire de calculer $\\Delta$ pour résoudre une équation du second degré. 
+  
+En particulier, on sait résoudre :
+
+- une équation du type : $x^2 = k$. Les solutions sont $\\pm \\sqrt{k}$ si $k$ est positif.
+- une équation produit nul : 
+
+$$
+a(x-x_1)(x-x_2) = 0
+$$
+
+Les solutions sont $x_1$ et $x_2$ si $a$ est non nul.`;
+};
+const getCorrection = (identifiers) => {
+    const getCorrForEq = (eq) => {
+        const eqNode = buildEquation(eq);
+        const isNoDelta = isEqWithoutDelta(eq);
+        const trinom = new Trinom(eq.a, eq.b, eq.c);
+        if (isNoDelta) {
+            const roots = trinom.getRootsNode();
+            const rootsSolTex = !roots.length
+                ? `il n'y a pas de solution réelle`
+                : roots.length === 1
+                    ? `la solution est $${roots[0].toTex()}$`
+                    : `les solutions sont  
+    $${roots[0].toTex()}$ et $${roots[1].toTex()}$`;
+            if (eq.form === "facto") {
+                return `- L'équation $${eqNode.toTex()}=0$ est une équation produit nul, car le membre de gauche est sous forme factorisée. On peut facilement la résoudre sans utiliser le discriminant : ${rootsSolTex}.`;
+            }
+            if (eq.c === 0) {
+                return `- L'équation $${eqNode.toTex()}=0$ peut se factoriser par $x$ : 
+        
+$$
+${multiply("x", add(multiply(eq.a, "x"), eq.b)).toTex()} = 0
+$$
+
+On peut alors facilement la résoudre sans utiliser le discriminant : ${rootsSolTex}.
+        `;
+            }
+            if (eq.b === 0) {
+                return `- L'équation $${eqNode.toTex()}=0$ peut se réécrire : 
+
+$$
+${multiply(eq.a, square("x")).toTex()} = ${opposite(eq.c).simplify().toTex()}
+$$
+
+C'est donc une équation du type $x^2 = k$, on peut la résoudre sans discriminant : ${rootsSolTex}.
+`;
+            }
+            if (eq.form === "cano") {
+                const alpha = trinom.getAlphaNode();
+                const beta = trinom.getBetaNode();
+                return `- L'équation $${eqNode.toTex()}$ peut se réécrire : 
+
+$$
+${square(substract("x", alpha).simplify()).toTex()} = ${frac(opposite(beta), eq.a).toTex()}
+$$
+
+C'est donc une équation du type $X^2 = k$, avec $X = ${substract("x", alpha)
+                    .simplify()
+                    .toTex()}$. On peut la résoudre sans utiliser le discriminant : ${rootsSolTex}.`;
+            }
+        }
+        return `- L'équation $${eqNode.toTex()}=0$ ne peut pas facilement se factoriser, et on ne peut pas la ramener à une équation du type $x^2 = k$. Pour cette équation, il est donc pertinent d'utiliser le discriminant.`;
+    };
+    return `Essayons de résoudre chacune des équations : 
+  
+${identifiers.equations.map((e) => getCorrForEq(e)).join("\n")}
+
+`;
+};
+const getTrinomSelectEquationWithoutDeltaNeededQuestion = () => {
+    let equations = [];
+    const getEqNoDelta = () => {
+        const type = randint(0, 4);
+        const a = randint(-9, 10, [0]);
+        if (type === 0) {
+            const c = randint(-9, 10, [0]);
+            return {
+                a,
+                b: 0,
+                c,
+                form: "dev",
+            };
+        }
+        if (type === 1) {
+            const b = randint(-9, 10, [0]);
+            return {
+                a,
+                b,
+                c: 0,
+                form: "dev",
+            };
+        }
+        if (type === 2) {
+            const trinom = TrinomConstructor.randomNiceRoots();
+            return {
+                a: trinom.a,
+                b: trinom.b,
+                c: trinom.c,
+                form: "facto",
+            };
+        }
+        else {
+            const trinom = TrinomConstructor.randomCanonical();
+            return {
+                a: trinom.a,
+                b: trinom.b,
+                c: trinom.c,
+                form: "cano",
+            };
+        }
+    };
+    const getEqDelta = () => {
+        let a, b, c;
+        do {
+            a = randint(-9, 10, [0]);
+            b = randint(-9, 10, [0]);
+            c = randint(-9, 10, [0]);
+            //delta = 0 => factorisation par idRmq trop simple
+            //! il reste le cas "une racine est évidente" et je trouve facilement la deuxième grâce à c...
+        } while (b ** 2 - 4 * a * c === 0);
+        return {
+            a,
+            b,
+            c,
+            form: "dev",
+        };
+    };
+    equations = [getEqDelta(), getEqNoDelta()];
+    for (let i = 0; i < 2; i++) {
+        const eq = doWhile(() => (coinFlip() ? getEqDelta() : getEqNoDelta()), (eq) => equations.some((e) => e.a === eq.a && e.b === eq.b && e.c === eq.c && e.form === eq.form));
+        equations.push(eq);
+    }
+    const shuffled = shuffle(equations);
+    const identifiers = {
+        equations: shuffled,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const trinomSelectEquationWithoutDeltaNeeded = {
+    id: "trinomSelectEquationWithoutDeltaNeeded",
+    label: "Repérer les équations du second degré qui ne nécessitent pas le calcul du discriminant",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrinomSelectEquationWithoutDeltaNeededQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    isQCM: true,
+    answerType: "QCM",
+};

package/lib/exercises/math/functions/trinoms/sign/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./trinomSignFromRoots.js";
 export * from "./trinomSignFromFacto.js";
+export * from "./trinomSignTableFromAlgebraicForm.js";
+export * from "./parabolaSignTable.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/trinoms/sign/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uCAAuC,CAAC;AACtD,cAAc,wBAAwB,CAAC"}

package/lib/exercises/math/functions/trinoms/sign/index.js

@@ -1,2 +1,4 @@
 export * from "./trinomSignFromRoots.js";
 export * from "./trinomSignFromFacto.js";
+export * from "./trinomSignTableFromAlgebraicForm.js";
+export * from "./parabolaSignTable.js";

package/lib/exercises/math/functions/trinoms/sign/parabolaSignTable.d.ts

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

package/lib/exercises/math/functions/trinoms/sign/parabolaSignTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parabolaSignTable.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/parabolaSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuHF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAoBnD,CAAC"}

package/lib/exercises/math/functions/trinoms/sign/parabolaSignTable.js

@@ -0,0 +1,123 @@
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getInstruction = () => {
+    return `Ci-dessous est tracée la parabole qui représente graphiquement une fonction polynôme du second degré $f$ définie sur $\\mathbb{R}$.
+  
+Dresser le tableau de signes de $f$.`;
+};
+const getHint = () => {
+    return `La fonction est définie sur $\\mathbb{R}$, donc les valeurs de $x$ vont de $-\\infty$ à $+\\infty$.
+  
+Repère ensuite les points de la courbe à l'intersection de l'axe des abscisses. Dans la première ligne du tableau, il faut mettre les abscisses de ces points, et dans la deuxième ligne, le signe de $f(x)$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const sign = a > 0 ? "positive" : "négative";
+    const oppSign = a > 0 ? "négative" : "positive";
+    return `On lit graphiquement que les racines de $f$ sont $${roots[0].toTex()}$ et $${roots[1].toTex()}$.
+
+Entre ces racines, c'est à dire sur l'intervalle $\\left[${roots[0].toTex()};${roots[1].toTex()}\\right]$, $f(x)$ est ${oppSign}.
+
+Pour les valeurs de l'intervalle $\\left]-\\infty;${roots[0].toTex()}\\right]$ et de l'intervalle $\\left[${roots[1].toTex()};+\\infty \\right[$, $f(x)$ est ${sign}.
+  `;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRoots();
+    const beta = trinom.getBeta();
+    const ggb = new GeogebraConstructor({
+        commands: [`f(x) = ${a}*x^2 + ${b}*x + ${c}`],
+        lockedAxesRatio: false,
+        gridDistance: false,
+        xAxis: {
+            steps: 1,
+        },
+    });
+    const xMin = roots[0] - 2;
+    const xMax = roots[1] + 2;
+    const yMin = a > 0 ? beta : -5;
+    const yMax = a < 0 ? beta : 5;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getKeys = () => {
+    return ["infty"];
+};
+const getAnswerTable = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const opp = a > 0 ? "-" : "+";
+    const sign = a > 0 ? "+" : "-";
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            roots[0].toTex(),
+            "\\ ",
+            roots[1].toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        ["$f(x)$", "\\ ", sign, "0", opp, "0", sign, "\\ "],
+    ];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return ans.every((row, i) => row.every((cell, j) => cell === answerTable[i][j]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSignTableFromGraphQuestion = () => {
+    const trinom = TrinomConstructor.randomNiceRoots(2);
+    const identifiers = {
+        a: trinom.a,
+        b: trinom.b,
+        c: trinom.c,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        initTable: [
+            ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+            ["$f(x)$", "\\ ", "", "", "", "", "", "\\ "],
+        ],
+    };
+};
+export const parabolaSignTable = {
+    id: "parabolaSignTable",
+    label: "Dresser le tableau de signes d'une parabole représentée graphiquement",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSignTableFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswerTable,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    answerType: "signTable",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/trinoms/sign/trinomSignTableFromAlgebraicForm.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    form: "dev" | "cano" | "facto";
+};
+type Options = {
+    givenForm: string;
+};
+export declare const trinomSignTableFromAlgebraicForm: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=trinomSignTableFromAlgebraicForm.d.ts.map

package/lib/exercises/math/functions/trinoms/sign/trinomSignTableFromAlgebraicForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trinomSignTableFromAlgebraicForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/trinomSignTableFromAlgebraicForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AAwMF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAWF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBzE,CAAC"}