math-exercises 3.0.10 → 3.0.11

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

@@ -0,0 +1,69 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } 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 { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+const getInstruction = (identifiers) => {
+    const { coeffs } = identifiers;
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    const statement = trinom.getCanonicalForm().toTex();
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${statement}
+$$
+
+Résoudre l'équation $f(x) = 0$.`;
+};
+const getAnswer = (identifiers) => {
+    const { coeffs } = identifiers;
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    const roots = trinom.getRootsNode();
+    const answer = new EquationSolutionNode(new DiscreteSetNode(roots)).toTex();
+    return answer;
+};
+const getSolveSecondDegreeEquationFromCanoQuestion = () => {
+    const trinom = TrinomConstructor.randomNiceRootsAndSummit();
+    const identifiers = { coeffs: trinom.coefficients };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [...equationKeys],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([randint(-9, 0), randint(1, 10)].map((e) => e.toTree()))).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, coeffs }) => {
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    const roots = trinom.getRootsNode();
+    const answerTree = new EquationSolutionNode(new DiscreteSetNode(roots), {
+        opts: { allowFractionToDecimal: true, allowRawRightChildAsSolution: true },
+    });
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const solveSecondDegreeEquationFromCano = {
+    id: "solveSecondDegreeEquationFromCano",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $a(x-b)^2 + c = 0$",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => getDistinctQuestions(getSolveSecondDegreeEquationFromCanoQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/functions/trinoms/factoForm/factorizedFormFromRoots.d.ts

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

package/lib/exercises/math/functions/trinoms/factoForm/factorizedFormFromRoots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factorizedFormFromRoots.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/factoForm/factorizedFormFromRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+EF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}

package/lib/exercises/math/functions/trinoms/factoForm/factorizedFormFromRoots.js

@@ -0,0 +1,72 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.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 { probaFlip } from "../../../../../utils/alea/probaFlip.js";
+const getAnswerNode = (roots, a) => {
+    const isSingleRoot = roots.length === 1;
+    return isSingleRoot
+        ? multiply(a, square(substract("x", roots[0]))).simplify({
+            keepPowers: true,
+        })
+        : multiply(multiply(a, substract("x", roots[0])), substract("x", roots[1])).simplify();
+};
+const getInstruction = (identifiers) => {
+    const { a, roots } = identifiers;
+    return `Soit $f(x) = ax^2 + bx + c$ un polynôme du second degré avec $a = ${a}$ et qui a ${roots.length === 1
+        ? `pour seule racine : $${roots[0]}$`
+        : `deux racines : $${roots[0]}$ et $${roots[1]}$`}. Déterminer la forme factorisée de $f$.`;
+};
+const getFactorizedFormFromRootsQuestion = () => {
+    const a = randint(-10, 10, [0]);
+    const firstRoot = randint(-10, 10);
+    const secondRoot = randint(-10, 10, [firstRoot]);
+    const isSingleRoot = probaFlip(0.3);
+    const roots = isSingleRoot
+        ? [firstRoot]
+        : [firstRoot, secondRoot].sort((a, b) => a - b);
+    const answer = getAnswerNode(roots, a);
+    const answerTex = answer.toTex();
+    const identifiers = { a, roots };
+    const question = {
+        answer: answerTex,
+        instruction: getInstruction(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, roots }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, getAnswerNode(roots.map((r) => -r), a).toTex());
+    while (propositions.length < n) {
+        const x1 = randint(-10, 10);
+        const x2 = randint(-10, 10, [x1]);
+        tryToAddWrongProp(propositions, getAnswerNode([x1, x2].sort((a, b) => a - b), randint(-10, 10, [0])).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, roots }) => {
+    const answerNode = getAnswerNode(roots, a);
+    const texs = answerNode.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const factorizedFormFromRoots = {
+    id: "factorizedFormFromRoots",
+    connector: "=",
+    label: "Déterminer la forme factorisée en connaissant les racines",
+    levels: ["1rePro", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => getDistinctQuestions(getFactorizedFormFromRootsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+};

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

@@ -0,0 +1,2 @@
+export * from "./factorizedFormFromRoots.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/factoForm/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./factorizedFormFromRoots.js";

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

@@ -1,25 +1,9 @@
-export * from "./alphaBetaFromDevForm.js";
-export * from "./alphaBetaInCanonicalForm.js";
-export * from "./canonicalFromDevForm.js";
-export * from "./deltaTrinom.js";
-export * from "./extremumFromCanonicalForm.js";
-export * from "./extremumTypeFromAlgebricForm.js";
-export * from "./niceRootsFromDevForm.js";
-export * from "./rootsFromDevForm.js";
-export * from "./rootsFromFactorizedForm.js";
-export * from "./variationsFromAlgebricForm.js";
-export * from "./secondDegreeInequation.js";
-export * from "./rootsReading.js";
-export * from "./factorizedFormFromRoots.js";
-export * from "./summitReading.js";
-export * from "./summitAbscissFromRoots.js";
-export * from "./summitAbscissFromDevForm.js";
 export * from "./trinomialMeanValue.js";
-export * from "./solveSecondDegreeEquationByFactorisation.js";
-export * from "./solveSecondDegreeEquationFromCano.js";
-export * from "./trinomSignFromRoots.js";
-export * from "./coefficientsIdentification.js";
-export * from "./rootsSum.js";
-export * from "./rootsProduct.js";
-export * from "./findSecondRoot.js";
+export * from "./devForm/index.js";
+export * from "./equation/index.js";
+export * from "./factoForm/index.js";
+export * from "./roots/index.js";
+export * from "./sign/index.js";
+export * from "./summitAndCanonical/index.js";
+export * from "./parabole/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,+CAA+C,CAAC;AAC9D,cAAc,wCAAwC,CAAC;AACvD,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC"}

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

@@ -1,24 +1,8 @@
-export * from "./alphaBetaFromDevForm.js";
-export * from "./alphaBetaInCanonicalForm.js";
-export * from "./canonicalFromDevForm.js";
-export * from "./deltaTrinom.js";
-export * from "./extremumFromCanonicalForm.js";
-export * from "./extremumTypeFromAlgebricForm.js";
-export * from "./niceRootsFromDevForm.js";
-export * from "./rootsFromDevForm.js";
-export * from "./rootsFromFactorizedForm.js";
-export * from "./variationsFromAlgebricForm.js";
-export * from "./secondDegreeInequation.js";
-export * from "./rootsReading.js";
-export * from "./factorizedFormFromRoots.js";
-export * from "./summitReading.js";
-export * from "./summitAbscissFromRoots.js";
-export * from "./summitAbscissFromDevForm.js";
 export * from "./trinomialMeanValue.js";
-export * from "./solveSecondDegreeEquationByFactorisation.js";
-export * from "./solveSecondDegreeEquationFromCano.js";
-export * from "./trinomSignFromRoots.js";
-export * from "./coefficientsIdentification.js";
-export * from "./rootsSum.js";
-export * from "./rootsProduct.js";
-export * from "./findSecondRoot.js";
+export * from "./devForm/index.js";
+export * from "./equation/index.js";
+export * from "./factoForm/index.js";
+export * from "./roots/index.js";
+export * from "./sign/index.js";
+export * from "./summitAndCanonical/index.js";
+export * from "./parabole/index.js";

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

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

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

@@ -0,0 +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"}

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"paraboleExpressionReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/parabole/paraboleExpressionReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CAIpB,CAAC;AAoSF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAmB3D,CAAC"}

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

@@ -0,0 +1,285 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Parabola } from "../../../../../math/geometry/parabola.js";
+import { Point } from "../../../../../math/geometry/point.js";
+import { randint } from "../../../../../math/utils/random/randint.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 { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { type, points } = identifiers;
+    while (propositions.length < n) {
+        switch (type) {
+            case 0:
+                tryToAddWrongProp(propositions, multiply(randint(-9, 10, [0]), square("x")).toTex());
+                break;
+            case 1:
+                tryToAddWrongProp(propositions, add(multiply(randint(-9, 10, [0]), square("x")), randint(-9, 10, [0])).toTex());
+                break;
+            case 2:
+            default:
+                let x1 = randint(-8, 9);
+                let x2 = randint(-8, 9, [0]);
+                if (x1 > x2)
+                    [x1, x2] = [x2, x1];
+                tryToAddWrongProp(propositions, multiply(randint(-5, 6, [0]), multiply(substract("x", x1), substract("x", x2))).toTex());
+                break;
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    //type 0 = ax^2, points = [[-1, a],[0,0],[1,a]]
+    //type 1 = ax^2 + b, points = [[-1, a+b], [0,b], [1, a+b]]
+    //type 2 = a(x-x1)(x-x2), points = [[x1,0],[x, y],[x2,0]], avec (x,y) random
+    const { type, points } = identifiers;
+    let a;
+    let b;
+    switch (type) {
+        case 0:
+            a = points[2][1];
+            return multiply(a, square("x"));
+        case 1:
+            b = points[1][1];
+            a = points[2][1] - b;
+            return add(multiply(a, square("x")), b).simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+            });
+        case 2:
+        default:
+            const roots = points.filter((e) => e[1] === 0);
+            const x1 = roots[0][0];
+            const x2 = roots[1][0];
+            const [x, y] = points.find((el) => el[1] !== 0);
+            a = frac(y, (x - x1) * (x - x2)).simplify();
+            // a = round(y / (x - x1) / (x - x2), 2);
+            return multiply(a, multiply(substract("x", x1), substract("x", x2))).simplify({ forceDistributeFractions: true });
+            break;
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Déterminer l'expression de la fonction représentée ci-dessous.`;
+};
+const getHint = (identifiers) => {
+    const { type, points } = identifiers;
+    switch (type) {
+        case 0:
+            return `Si la parabole a pour sommet l'origine du repère, alors l'expression de $f$ est de la forme : 
+    
+$$
+f(x) = ax^2
+$$
+    
+Pour déterminer $a$, on lit l'ordonnée du point d'abscisse $1$.`;
+        case 1:
+            return `Si la parabole a pour axe de symétrie l'axe des ordonnées, l'expression de $f$ est de la forme : 
+    
+$$
+f(x) = ax^2 + b
+$$
+
+Pour déterminer $b$, on lit l'ordonnée du sommet. 
+
+Pour déterminer $a$, on lit l'ordonnée du point d'abscisse $1$, puis on utilise le fait que $f(1) = a\\times 1^2 + b$.`;
+        case 2:
+        default:
+            return `Si la parabole possède deux racines $x_1$ et $x_2$, alors l'expression de $f$ est de la forme : 
+    
+$$
+f(x) = a(x-x_1)(x-x_2)
+$$
+
+On détermine $x_1$ et $x_2$ en lisant les racines de la parabole. 
+
+Pour déterminer $a$, on choisit un point $A(x_0;y_0)$ de la courbe tel que $x_0\\neq x_1$ et $x_0\\neq x_2$. On sait alors que $f(x_0) = y_0$. On remplace ces valeurs dans l'expression de $f$. On résout alors l'équation d'inconnue $a$.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { type, points } = identifiers;
+    let a;
+    let b;
+    const answer = getAnswer(identifiers);
+    switch (type) {
+        case 0:
+            a = points[2][1];
+            return `La parabole a pour sommet l'origine du repère, donc l'expression de $f$ est de la forme : 
+    
+$$
+f(x) = ax^2
+$$
+    
+La parabole passe par le point $A(1;${a})$, donc $a = ${a}$. 
+
+On a donc pour tout $x$ réel : 
+
+$$
+f(x) = ${answer}
+$$`;
+        case 1:
+            b = points[1][1];
+            a = points[2][1] - b;
+            return `La parabole a pour axe de symétrie l'axe des ordonnées, donc l'expression de $f$ est de la forme : 
+    
+$$
+f(x) = ax^2 + b
+$$
+
+L'ordonnée du sommet est $${b}$, donc $b = ${b}$. 
+
+La parabole passe par le point $A(1;${a + b})$, donc $f(1) = ${add("a", b).toTex()}= ${a + b}$. On en déduit que $a = ${a}$. 
+
+On a donc pour tout $x$ réel : 
+
+$$
+f(x) = ${answer}
+$$
+`;
+        case 2:
+        default:
+            const roots = points.filter((e) => e[1] === 0);
+            const x1 = roots[0][0];
+            const x2 = roots[1][0];
+            const [x, y] = points.find((el) => el[1] !== 0);
+            // a = round(y / (x - x1) / (x - x2), 2);
+            a = frac(y, (x - x1) * (x - x2)).simplify();
+            const f = multiply(substract("x", x1), substract("x", x2)).simplify();
+            return `La parabole possède deux racines $x_1=${x1}$ et $x_2=${x2}$, donc l'expression de $f$ est de la forme : 
+    
+$$
+f(x) = a${f.toTex()}
+$$
+
+De plus, la parabole passe par le point $A(${x},${y})$.
+
+On a donc $f(x) = a${f.toDetailedEvaluation({ x: x.toTree() }).toTex()} = ${y}$.
+
+En résolvant cette équation, on obtient $a=${a.toTex()}$.
+
+
+On a donc pour tout $x$ réel : 
+
+$$
+f(x) = ${answer}
+$$`;
+    }
+};
+const getGGBOptions = (identifiers) => {
+    const { type, points } = identifiers;
+    const sortedPoints = [...points].sort((a, b) => a[0] - b[0]);
+    const parabola = new Parabola(sortedPoints.map((p, i) => new Point(`A_${i}`, p[0], p[1])));
+    const ggb = new GeogebraConstructor({
+        commands: parabola.toGGBCommands(false),
+    });
+    const pointsXs = points.map((p) => p[0]);
+    const pointsYs = points.map((p) => p[1]);
+    let xMin = Math.min(Math.min(...pointsXs), -5) - 1;
+    let xMax = Math.max(Math.max(...pointsXs), 5) + 1;
+    let yMin = Math.min(Math.min(...pointsYs), -5) - 1;
+    let yMax = Math.max(Math.max(...pointsYs), 5) + 1;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getKeys = (identifiers) => {
+    return ["x"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+            decimalToFractions: true,
+        })
+            .toTex() ===
+            getAnswerNode(identifiers)
+                .simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+            })
+                .toTex());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getParaboleExpressionReadingQuestion = (opts) => {
+    const type = randint(0, 3);
+    const points = [];
+    let a;
+    let b;
+    switch (type) {
+        case 0:
+            //type 0 = ax^2, points = [[-1, a],[0,0],[1,a]]
+            a = randint(-5, 6, [0]);
+            points.push([-1, a], [0, 0], [1, a]);
+            break;
+        case 1:
+            //type 1 = ax^2 + b, points = [[-1, a+b], [0,b], [1, a+b]]
+            a = randint(-5, 6, [0]);
+            b = randint(-5, 6, [0]);
+            points.push([-1, a + b], [0, b], [1, a + b]);
+            break;
+        case 2:
+        default:
+            //type 2 = a(x-x1)(x-x2), points = [[x1,0],[x, y],[x2,0]], avec (x,y) random
+            let x1 = randint(-8, 9);
+            let x2 = randint(-8, 9, [x1]);
+            if (x1 > x2)
+                [x1, x2] = [x2, x1];
+            // a = randint(-3, 4, [0]);
+            const x = randint(-4, 4, [x1, x2]);
+            // const y = round(a * (x - x1) * (x - x2), 2);
+            const y = randint(-6, 7, [0]);
+            points.push([x1, 0], [x, y], [x2, 0]);
+            break;
+    }
+    const identifiers = {
+        type,
+        points,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const paraboleExpressionReading = {
+    id: "paraboleExpressionReading",
+    connector: "\\iff",
+    label: "Associer une expression algébrique à une parabole",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParaboleExpressionReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"trinomSymetryAxisFromFacto.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/parabole/trinomSymetryAxisFromFacto.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAgGF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}