math-exercises 3.0.172 → 3.0.174

package/lib/exercises/math/functions/trinoms/devForm/variationsFromAlgebricForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variationsFromAlgebricForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/devForm/variationsFromAlgebricForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;CACjC,CAAC;AAiIF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAWF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}
+{"version":3,"file":"variationsFromAlgebricForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/devForm/variationsFromAlgebricForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;CACjC,CAAC;AAiIF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAuBF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBrE,CAAC"}

package/lib/exercises/math/functions/trinoms/devForm/variationsFromAlgebricForm.js

@@ -115,6 +115,17 @@ const options = [
         defaultValue: ["Forme canonique", "Forme factorisée", "Forme développée"],
     },
 ];
+const validateOptions = (opts) => {
+    if (!opts?.form?.length)
+        return {
+            valid: false,
+            message: "Veuillez choisir au moins un type de forme algébrique.",
+        };
+    return {
+        valid: true,
+        message: "",
+    };
+};
 export const variationsFromAlgebricForm = {
     id: "variationsFromAlgebricForm",
     label: "Déterminer les variations d'une fonction du second degré via sa forme algébrique",
@@ -128,4 +139,5 @@ export const variationsFromAlgebricForm = {
     getQuestionFromIdentifiers,
     options,
     hasHintAndCorrection: true,
+    validateOptions,
 };

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

@@ -1,3 +1,5 @@
 export * from "./paraboleExpressionReading.js";
 export * from "./trinomSymetryAxisFromFacto.js";
+export * from "./parabolaVarTable.js";
+export * from "./paraboleSolveGraphEquation.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/parabole/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/parabole/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC"}

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

@@ -1,2 +1,4 @@
 export * from "./paraboleExpressionReading.js";
 export * from "./trinomSymetryAxisFromFacto.js";
+export * from "./parabolaVarTable.js";
+export * from "./paraboleSolveGraphEquation.js";

package/lib/exercises/math/functions/trinoms/parabole/parabolaVarTable.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    coeffs: number[];
+    initTable: string[][];
+};
+export declare const parabolaVarTable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parabolaVarTable.d.ts.map

package/lib/exercises/math/functions/trinoms/parabole/parabolaVarTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parabolaVarTable.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/parabole/parabolaVarTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AAsGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAmBlD,CAAC"}

package/lib/exercises/math/functions/trinoms/parabole/parabolaVarTable.js

@@ -0,0 +1,106 @@
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { varTableVEA } from "../../../../../exercises/vea/varTableVEA.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 `Dresser le tableau de variations de la fonction $f$ définie sur $\\mathbb{R}$ dont la parabole représentative est donnée ci-dessous :`;
+};
+const getAnswerTable = (identifiers) => {
+    const { coeffs } = identifiers;
+    const [c, b, a] = coeffs;
+    const poly = new Trinom(a, b, c);
+    const alpha = poly.getAlphaNode();
+    const beta = poly.getBetaNode();
+    const vars = coeffs[2] > 0 ? ["\\searrow", "\\nearrow"] : ["\\nearrow", "\\searrow"];
+    return [
+        ["$x$", "-\\infty", "\\ ", alpha.toTex(), "\\ ", "+\\infty"],
+        ["$\\ $", "\\ ", "\\ ", a < 0 ? beta.toTex() : "\\ ", "\\ ", "\\ "],
+        ["$f(x)$", "\\ ", vars[0], "\\ ", vars[1], "\\ "],
+        ["$\\ $", "\\ ", "\\ ", a < 0 ? "\\ " : beta.toTex(), "\\ ", "\\ "],
+    ];
+};
+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 auxquels le sens de variation change. Dans la première ligne du tableau, il faut mettre les abscisses de ces points, et dans la deuxième ligne, les ordonnées.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs } = identifiers;
+    const [c, b, a] = coeffs;
+    const poly = new Trinom(a, b, c);
+    const alpha = poly.getAlphaNode();
+    const beta = poly.getBetaNode();
+    const words = a > 0 ? ["décroissante", "croissante"] : ["croissante", "décroissante"];
+    return `D'après le graphique, la fonction $f$ est ${words[0]} sur $]-\\infty; ${alpha.toTex()}]$, puis ${words[1]} sur $[${alpha.toTex()}; +\\infty[$.
+
+De plus, on lit graphiquement que l'image de $${alpha.toTex()}$ est $${beta.toTex()}$.
+`;
+};
+const getKeys = () => {
+    return ["infty"];
+};
+const getGGBOptions = (identifiers) => {
+    const { coeffs } = identifiers;
+    const poly = TrinomConstructor.fromCoeffs(coeffs);
+    const commands = [`f(x) =${poly.toMathString()}`];
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+    });
+    return ggb.getOptions({
+        coords: poly.getCoords(),
+    });
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return varTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getParabolaVarTableQuestion = () => {
+    const trinom = TrinomConstructor.randomCanonical();
+    const identifiers = {
+        coeffs: trinom.coefficients,
+        initTable: [
+            ["$x$", "", "\\ ", "", "\\ ", ""],
+            ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+            ["$f(x)$", "\\ ", "", "", "", "\\ "],
+            ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+        ],
+    };
+    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: identifiers.initTable,
+    };
+};
+export const parabolaVarTable = {
+    id: "parabolaVarTable",
+    label: "Dresser le tableau de variations d'une parabole représentée graphiquement",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParabolaVarTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    isAnswerTableValid,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "varTable",
+    hasGeogebra: true,
+};

package/lib/exercises/math/functions/trinoms/parabole/paraboleSolveGraphEquation.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    k: number;
+};
+type Options = {
+    isAskingRoots: boolean;
+    nbSols: string[];
+};
+export declare const paraboleSolveGraphEquation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=paraboleSolveGraphEquation.d.ts.map

package/lib/exercises/math/functions/trinoms/parabole/paraboleSolveGraphEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paraboleSolveGraphEquation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/parabole/paraboleSolveGraphEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4JF,KAAK,OAAO,GAAG;IACb,aAAa,EAAE,OAAO,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA6BF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBrE,CAAC"}

package/lib/exercises/math/functions/trinoms/parabole/paraboleSolveGraphEquation.js

@@ -0,0 +1,186 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { discreteSetParser } from "../../../../../tree/parsers/discreteSetParser.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, trinom.getRootsEquationSolutionTex());
+    propWhile(propositions, n, () => {
+        const randomTrinom = TrinomConstructor.randomNiceRoots(randint(0, 3));
+        tryToAddWrongProp(propositions, randomTrinom.getRootsEquationSolutionTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, k } = identifiers;
+    const trinom = new Trinom(a, b, c - k);
+    return trinom.getRootsEquationSolutionTex();
+};
+const getInstruction = (identifiers) => {
+    return `Ci-dessous est tracée la parabole représentative d'une fonction polynôme du second degré $f$.
+  
+Résoudre graphiquement l'équation $f(x) = ${identifiers.k}$.`;
+};
+const getHint = (identifiers) => {
+    return `Détermine les abscisses des points de la courbe qui ont pour ordonnée $${identifiers.k}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c, k } = identifiers;
+    const trinom = new Trinom(a, b, c - k);
+    const roots = trinom.getRootsNode();
+    return `On cherche graphiquement les abscisses des points de la parabole dont l'ordonnée est $${k.frenchify()}$.
+  
+${!roots.length
+        ? `Il n'y en a pas. 
+  
+L'équation $f(x) = ${k.frenchify()}$ n'a donc pas de solution :
+
+$$
+${getAnswer(identifiers)}
+$$`
+        : ""}
+
+${roots.length === 1
+        ? `Il n'y en a qu'un : c'est le sommet de la parabole, et son abscisse vaut $${roots[0].toTex()}$. 
+
+L'équation $f(x) = ${k.frenchify()}$ a donc une seule solution :
+
+$$
+${getAnswer(identifiers)}
+$$
+`
+        : ""}
+
+
+${roots.length === 2
+        ? `On en trouve deux : les points de coordonnées $(${roots[0].toTex()};${k.frenchify()})$ et $(${roots[1].toTex()};${k.frenchify()})$. 
+
+L'équation $f(x) = ${k.frenchify()}$ a donc deux solutions :
+
+$$
+${getAnswer(identifiers)}
+$$`
+        : ""}
+
+
+  `;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, b, c, k } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const ggb = new GeogebraConstructor({
+        commands: [`f(x) = ${trinom.toMathString()}`],
+        lockedAxesRatio: false,
+    });
+    const baseTrinom = new Trinom(a, b, c - k);
+    const roots = baseTrinom.getRootsNode();
+    const coords = trinom.getCoords();
+    return ggb.getOptions({
+        coords: roots.length === 0
+            ? coords
+            : ggb.getAdaptedCoords({
+                xMin: coords[0],
+                xMax: coords[1],
+                yMin: k - 3,
+                yMax: k + 3,
+            }),
+    });
+};
+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().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getParaboleSolveGraphEquationQuestion = (opts) => {
+    const nbSolsTex = opts?.nbSols?.length
+        ? random(opts.nbSols)
+        : random(["$0$", "$1$", "$2$"]);
+    const nbSols = nbSolsTex === "$1$" ? 1 : nbSolsTex === "$2$" ? 2 : 0;
+    const k = opts?.isAskingRoots ? 0 : randint(-8, 9);
+    const baseTrinom = TrinomConstructor.randomNiceRoots(nbSols);
+    const trinom = new Trinom(baseTrinom.a, baseTrinom.b, baseTrinom.c + k);
+    const identifiers = {
+        a: trinom.a,
+        b: trinom.b,
+        c: trinom.c,
+        k,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+const options = [
+    {
+        id: "isAskingRoots",
+        label: "Demander de ne résoudre que $f(x)=0$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+    {
+        id: "nbSols",
+        label: "Nombre de solutions",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["$0$", "$1$", "$2$"],
+        defaultValue: ["$0$", "$1$", "$2$"],
+    },
+];
+const validateOptions = (opts) => {
+    if (!opts?.nbSols?.length)
+        return {
+            valid: false,
+            message: "Veuillez choisir au moins un nombre de solutions.",
+        };
+    return {
+        valid: true,
+        message: "",
+    };
+};
+export const paraboleSolveGraphEquation = {
+    id: "paraboleSolveGraphEquation",
+    label: "Résoudre graphiquement une équation du type $f(x)=k$ pour une parabole",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParaboleSolveGraphEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    options,
+    validateOptions,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/trinoms/roots/rootsFromDevForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsFromDevForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqMF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"rootsFromDevForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoMF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/rootsFromDevForm.js

@@ -157,7 +157,6 @@ const isAnswerValid = (ans, { a, b, c }) => {
     }
 };
 const isArrayOfNodesValid = (arrAns, arrAnswer) => {
-    //tried with toAllValidTexs() but there is always an unhandled case
     function isNodesEqual(node1, node2) {
         return [1, 1_000, 1_000_000].every((factor) => substract(multiply(factor, node1), multiply(factor, node2)).evaluate() === 0);
     }

package/lib/exercises/math/functions/trinoms/summitAndCanonical/extremumTypeFromAlgebricForm.d.ts

@@ -3,8 +3,12 @@ type Identifiers = {
     a: number;
     b: number;
     c: number;
-    isDevForm: boolean;
+    isDevForm?: boolean;
+    form: "cano" | "dev" | "facto";
 };
-export declare const extremumTypeFromAlgebricForm: Exercise<Identifiers>;
+type Options = {
+    form: string[];
+};
+export declare const extremumTypeFromAlgebricForm: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=extremumTypeFromAlgebricForm.d.ts.map

package/lib/exercises/math/functions/trinoms/summitAndCanonical/extremumTypeFromAlgebricForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extremumTypeFromAlgebricForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/extremumTypeFromAlgebricForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAsDF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}
+{"version":3,"file":"extremumTypeFromAlgebricForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/extremumTypeFromAlgebricForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;CAChC,CAAC;AAyIF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAaF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBvE,CAAC"}

package/lib/exercises/math/functions/trinoms/summitAndCanonical/extremumTypeFromAlgebricForm.js

@@ -1,15 +1,29 @@
-import { addValidProp, addWrongProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, addWrongProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
-import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
-    const { isDevForm, a, b, c } = identifiers;
+    const { form, isDevForm, a, b, c } = identifiers;
     const trinom = new Trinom(a, b, c);
-    return `La fonction $f$ définie par 
+    let trinomTex;
+    if (isDevForm !== undefined) {
+        trinomTex = isDevForm
+            ? trinom.toTree().toTex()
+            : trinom.getCanonicalForm().toTex();
+    }
+    else {
+        trinomTex =
+            form === "dev"
+                ? trinom.toTree().toTex()
+                : form === "cano"
+                    ? trinom.getCanonicalForm().toTex()
+                    : trinom.toFactorized().toTex();
+    }
+    return `La fonction $f$ définie sur $\\mathbb{R}$ par :
   
 $$
-f(x) = ${isDevForm ? trinom.toTree().toTex() : trinom.getCanonicalForm().toTex()}
+f(x) = ${trinomTex}
 $$ 
 
 admet-elle un maximum ou un minimum ?`;
@@ -18,22 +32,69 @@ const getAnswer = (identifiers) => {
     const answer = identifiers.a > 0 ? "Un minimum" : "Un maximum";
     return answer;
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        instruction: getInstruction(identifiers, opts),
         answerFormat: "raw",
         keys: [],
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
-const getExtremumTypeFromAlgebricFormQuestion = () => {
-    const isDevForm = coinFlip();
-    const trinom = isDevForm
+const getHint = () => {
+    return `La fonction $f$ est un polynôme du second degré. Sa courbe représentative est donc une parabole. Cette parabole est tournée vers le bas si le coefficient $a$ est positif. Dans ce cas, elle admet un minmum. Si $a$ est négatif, alors la parabole est tournée vers le haut, et elle admet donc un maximum.`;
+};
+const getCorrection = (identifiers) => {
+    const { form, a } = identifiers;
+    return `La fonction $f$ est un polynôme du second degré donnée sous sa forme ${form === "dev"
+        ? "développée"
+        : form === "facto"
+            ? "factorisée"
+            : "canonique"} :
+  
+$$
+f(x) = ${form === "dev"
+        ? "ax^2+bx+c"
+        : form === "facto"
+            ? "a(x-x_1)(x-x_2)"
+            : "a(x-\\alpha)^2+\\beta)"}
+$$
+
+Son coefficient $a$ vaut donc $${a.frenchify()}$.
+
+Puisque $${a
+        .toTree()
+        .toSignInequationTex()}$, la parabole représentative de $f$ est tournée vers ${a > 0 ? "le bas" : "le haut"} : cela signifie que $f$ est admet un ${a > 0 ? "minimum" : "maximum"} sur $\\mathbb{R}$.`;
+};
+const getExtremumTypeFromAlgebricFormQuestion = (opts) => {
+    const formalForm = opts?.form
+        ? random(opts.form)
+        : random(["Forme canonique", "Forme factorisée", "Forme développée"]);
+    const form = (() => {
+        switch (formalForm) {
+            case "Forme canonique":
+                return "cano";
+            case "Forme factorisée":
+                return "facto";
+            case "Forme développée":
+            default:
+                return "dev";
+        }
+    })();
+    const trinom = form === "dev"
         ? TrinomConstructor.random()
-        : TrinomConstructor.randomCanonical();
-    const identifiers = { isDevForm, a: trinom.a, b: trinom.b, c: trinom.c };
+        : form === "cano"
+            ? TrinomConstructor.randomCanonical()
+            : TrinomConstructor.randomNiceRoots(2);
+    const identifiers = {
+        form,
+        a: trinom.a,
+        b: trinom.b,
+        c: trinom.c,
+    };
     return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (_n, { answer, a }) => {
@@ -45,15 +106,39 @@ const getPropositions = (_n, { answer, a }) => {
     addWrongProp(propositions, "Ni l'un ni l'autre", "raw");
     return propositions;
 };
+const options = [
+    {
+        id: "form",
+        label: "Forme donnée",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Forme canonique", "Forme factorisée", "Forme développée"],
+        defaultValue: ["Forme canonique", "Forme factorisée", "Forme développée"],
+    },
+];
+const validateOptions = (opts) => {
+    if (!opts?.form?.length)
+        return {
+            valid: false,
+            message: "Veuillez choisir au moins un type de forme algébrique.",
+        };
+    return {
+        valid: true,
+        message: "",
+    };
+};
 export const extremumTypeFromAlgebricForm = {
     id: "extremumTypeFromAlgebricForm",
     label: "Déterminer le type d'extremum d'une fonction du second degré via sa forme algébrique",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getExtremumTypeFromAlgebricFormQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getExtremumTypeFromAlgebricFormQuestion(opts), nb),
     answerType: "QCU",
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    validateOptions,
+    options,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/lines/index.d.ts

@@ -16,4 +16,5 @@ export * from "./drawLineFromPointAndVector.js";
 export * from "./cartesianEquationsIntersection.js";
 export * from "./directorVectorFromAnother.js";
 export * from "./cartesianEquationOfTriangleHeight.js";
+export * from "./readLineNormalVectorOnGraph.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/lines/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,iCAAiC,CAAC;AAChD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wCAAwC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,iCAAiC,CAAC;AAChD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wCAAwC,CAAC;AACvD,cAAc,kCAAkC,CAAC"}

package/lib/exercises/math/geometry/lines/index.js

@@ -16,3 +16,4 @@ export * from "./drawLineFromPointAndVector.js";
 export * from "./cartesianEquationsIntersection.js";
 export * from "./directorVectorFromAnother.js";
 export * from "./cartesianEquationOfTriangleHeight.js";
+export * from "./readLineNormalVectorOnGraph.js";

package/lib/exercises/math/geometry/lines/readLineNormalVectorOnGraph.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    point1Ids: PointIdentifiers;
+    point2Ids: PointIdentifiers;
+    point3Ids?: PointIdentifiers;
+};
+type Options = {
+    withoutPerp: boolean;
+};
+export declare const readLineNormalVectorOnGraph: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=readLineNormalVectorOnGraph.d.ts.map

package/lib/exercises/math/geometry/lines/readLineNormalVectorOnGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readLineNormalVectorOnGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/readLineNormalVectorOnGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAQtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AA8KF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAaF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBtE,CAAC"}