math-exercises 3.0.2 → 3.0.4

package/lib/exercises/math/functions/basics/imageFunctionGeogebra.js

@@ -1,84 +1,225 @@
-import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randomColor } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { Lagrange } from "../../../../geogebra/lagrange.js";
 import { Spline } from "../../../../geogebra/spline.js";
+import { Line } from "../../../../math/geometry/line.js";
+import { Parabola } from "../../../../math/geometry/parabola.js";
 import { Point } from "../../../../math/geometry/point.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { round } from "../../../../math/utils/round.js";
 import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
 import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
-import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getImageFunctionGeogebra = () => {
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds.splinePoints?.length) {
+        const x = oldIds.x;
+        const wrongY = oldIds.splinePoints.find((p) => p[1] === x && Math.floor(p[0]) === p[0]);
+        if (!wrongY && wrongY !== 0)
+            throw new Error("no wrong y");
+        const otherPoints = oldIds.splinePoints.filter((p) => p[0] !== x && p[0] !== wrongY);
+        return {
+            functionType: oldIds.isSpline ? "Tracés" : "Polynômes",
+            x: oldIds.x,
+            y: oldIds.y,
+            wrongY,
+            otherPoints,
+        };
+    }
+    else if (oldIds.poly1?.length || oldIds.poly2?.length) {
+        const x = oldIds.xValue;
+        const polynome = new Polynomial(oldIds.rand ? oldIds.poly1 : oldIds.poly2);
+        const y = polynome.calculate(x);
+        const wrongY = oldIds.rand
+            ? Math.floor((x - oldIds.poly1[0]) / oldIds.poly1[1])
+            : polynome.calculate(x + 2);
+        return {
+            functionType: oldIds.rand ? "Droites" : "Paraboles",
+            x: oldIds.x,
+            y: oldIds.y,
+            wrongY,
+            otherPoints: oldIds.rand ? [] : [[x + 1, polynome.calculate(x + 1)]],
+        };
+    }
+    else
+        return oldIds;
+};
+const getInstruction = (identifiers) => {
+    const { x } = identifiers;
+    return `Quelle est l'image de $${x}$ par la fonction $f$ représentée ci dessous ?`;
+};
+const getAnswer = (identifiers) => {
+    const { y } = identifiers;
+    return y.frenchify();
+};
+const getGGBOptions = (identifiers) => {
+    const { functionType, otherPoints, wrongY, x, y } = identifiers;
+    const allPoints = [...otherPoints, [x, y], [wrongY, x]].sort((a, b) => a[0] - b[0]);
+    console.log(allPoints);
+    let commands = [];
+    switch (functionType) {
+        case "Droites":
+            const line = new Line(new Point("A", allPoints[0][0], allPoints[0][1]), new Point("B", allPoints[1][0], allPoints[1][1]));
+            commands = line.toGGBCommands(false);
+            break;
+        case "Tracés":
+            //! on devrait plutôt build a spline et renvoyer toGgbCommand
+            commands = [
+                `S = Spline(${allPoints
+                    .map((point) => `(${point[0]},${point[1]})`)
+                    .join(",")})`,
+                "SetFixed(S, true)",
+                `SetColor(S, "${randomColor()}")`,
+            ];
+            break;
+        case "Paraboles":
+            const parabola = new Parabola([
+                new Point("A", allPoints[0][0], allPoints[0][1]),
+                new Point("B", allPoints[1][0], allPoints[1][1]),
+                new Point("C", allPoints[2][0], allPoints[2][1]),
+            ]);
+            commands = parabola.toGGBCommands(false);
+            break;
+        case "Polynômes":
+        default:
+            //! on devrait plutôt build a lagrange et renvoyer toGgbCommand
+            commands = [
+                `P = Polynomial(${allPoints
+                    .map((point) => `(${point[0]},${point[1]})`)
+                    .join(",")})`,
+                "SetFixed(P, true)",
+                `SetColor(P, "${randomColor()}")`,
+            ];
+            break;
+    }
+    // const spline = new (isSpline ? Spline : Lagrange)(
+    //   new IntervalNode((-10).toTree(), (10).toTree(), ClosureType.FF),
+    //   splinePoints.map((e, i) => new Point(`A_${i}`, e[0], e[1])),
+    // );
+    const ggb = new GeogebraConstructor({
+        // commands: spline.getCommands()
+        commands,
+    });
+    const xMin = allPoints[0][0];
+    const xMax = allPoints[allPoints.length - 1][0];
+    const yMin = Math.min(...allPoints.map((p) => p[1])) - 1;
+    const yMax = Math.max(...allPoints.map((p) => p[1])) + 1;
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            forceShowAxes: true,
+            xMax,
+            xMin,
+            yMax,
+            yMin,
+        }),
+    });
+};
+const getStartStatement = (identifiers) => {
+    const { x } = identifiers;
+    return `f(${x})`;
+};
+const getImageFunctionGeogebra = (opts) => {
     const x = randint(-8, 9);
     const y = randint(-8, 9);
-    const isSpline = coinFlip();
-    const spline = new (isSpline ? Spline : Lagrange)(new IntervalNode((-10).toTree(), (10).toTree(), ClosureType.FF), [
-        new Point("A", x.toTree(), y.toTree()),
-        //distractor point with ordonnée = x
-        new Point("B", (y + randint(-3, 4, [0, x - y, 10 - y, -10 - y])).toTree(), x.toTree()),
-    ]);
-    const ggb = new GeogebraConstructor({ commands: spline.getCommands() });
-    const xMin = spline.points[0][0];
-    const xMax = spline.points[spline.points.length - 1][0];
-    const yMin = Math.min(...spline.points.map((p) => p[1])) - 1;
-    const yMax = Math.max(...spline.points.map((p) => p[1])) + 1;
-    const instruction = `Quelle est l'image de $${x}$ par la fonction $f$ représentée ci dessous ?`;
+    const wrongY = y + randint(-3, 4, [0, x - y, 10 - y, -10 - y]);
+    const functionType = random(opts?.curveTypes ?? ["Tracés", "Polynômes", "Droites", "Paraboles"]);
+    let otherPoints = [];
+    switch (functionType) {
+        case "Droites":
+            //nothing to add
+            break;
+        case "Tracés":
+            const spline = new Spline(new IntervalNode((-10).toTree(), (10).toTree(), ClosureType.FF), [
+                new Point("A", x.toTree(), y.toTree()),
+                //distractor point with ordonnée = x
+                new Point("B", wrongY.toTree(), x.toTree()),
+            ]);
+            otherPoints = spline.points.filter((p) => p[0] !== x && p[0] !== wrongY);
+            break;
+        case "Paraboles":
+            //3e point au milieu de AB
+            otherPoints.push([(x + wrongY) / 2, y + randint(-3, 4, [0])]);
+            break;
+        case "Polynômes":
+            const lagrange = new Lagrange(new IntervalNode((-10).toTree(), (10).toTree(), ClosureType.FF), [
+                new Point("A", x.toTree(), y.toTree()),
+                //distractor point with ordonnée = x
+                new Point("B", wrongY.toTree(), x.toTree()),
+            ]);
+            otherPoints = lagrange.points.filter((p) => p[0] !== x && p[0] !== wrongY);
+        default:
+            break;
+    }
+    // const spline = new (isSpline ? Spline : Lagrange)(
+    //   new IntervalNode((-10).toTree(), (10).toTree(), ClosureType.FF),
+    //   [
+    //     new Point("A", x.toTree(), y.toTree()),
+    //     //distractor point with ordonnée = x
+    //     new Point("B", wrongY.toTree(), x.toTree()),
+    //   ],
+    // );
+    const identifiers = {
+        // isSpline,
+        // splinePoints: spline.points,
+        x,
+        y,
+        functionType,
+        wrongY,
+        otherPoints,
+    };
     const question = {
-        instruction,
-        startStatement: `f(${x})`,
-        answer: y.frenchify(),
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: ggb.getAdaptedCoords({
-                forceShowAxes: true,
-                xMax,
-                xMin,
-                yMax,
-                yMin,
-            }),
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: {
-            splinePoints: spline.points,
-            x,
-            y,
-            isSpline,
-        },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, splinePoints, x, y }) => {
+const getPropositions = (n, { answer, x, y, wrongY }, opts) => {
     const propositions = [];
     addValidProp(propositions, answer);
     //old questions have spline POint undefined
-    (splinePoints ?? [])
-        .filter((p) => p[1] === x)
-        .map((e) => round(e[0], 0))
-        .forEach((y) => tryToAddWrongProp(propositions, y.frenchify()));
+    tryToAddWrongProp(propositions, wrongY + "");
     while (propositions.length < n) {
         const wrongAnswer = Number(answer) + randint(-10, 11, [0]);
         tryToAddWrongProp(propositions, wrongAnswer + "");
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer }, opts) => {
     return numberVEA(ans, answer);
 };
+const options = [
+    {
+        id: "curveTypes",
+        label: "Types de courbes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Tracés", "Polynômes", "Droites", "Paraboles"],
+        values: ["Tracés", "Polynômes", "Droites", "Paraboles"],
+    },
+];
 export const imageFunctionGeogebra = {
     id: "imageFunctionGeogebra",
     connector: "=",
     label: "Lecture d'une image",
-    levels: ["3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
-    sections: ["Fonctions"],
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getImageFunctionGeogebra, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getImageFunctionGeogebra(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    options,
+    getAnswer,
+    getInstruction,
+    getGGBOptions,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/functions/cube/cubicEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cubicEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/cubicEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyCF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAe/C,CAAC"}
+{"version":3,"file":"cubicEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/cubicEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4DF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}

package/lib/exercises/math/functions/cube/cubicEquation.js

@@ -1,21 +1,41 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { equationKeys } from "../../../../exercises/utils/keys/equationKeys.js";
+import { equationVEA } from "../../../../exercises/vea/equationVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
-import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
-import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const k = identifiers.k;
+    return `Résoudre l'équation suivante : 
+  
+$$
+x^3 = ${k}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const k = identifiers.k;
+    const x = Math.cbrt(k);
+    const answer = `S=\\left\\{${x}\\right\\}`;
+    return answer;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return "";
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return "";
+// };
 const getCubicEquationQuestion = () => {
     const x = randint(-10, 11);
     const k = x ** 3;
-    const answer = `S=\\left\\{${x}\\right\\}`;
+    const identifiers = { k };
     const question = {
-        answer: answer,
-        instruction: `Résoudre l'équation suivante : $x^3 = ${k}$`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: equationKeys,
         answerFormat: "tex",
-        identifiers: { k },
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -30,18 +50,13 @@ const getPropositions = (n, { answer, k }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { k }) => {
-    const sol = Math.cbrt(k);
-    const answerTree = new EquationSolutionNode(new DiscreteSetNode([new NumberNode(sol)]));
-    const texs = answerTree.toAllValidTexs();
-    return texs.includes(ans);
+    return equationVEA(ans, Math.cbrt(k).frenchify());
 };
 export const cubicEquation = {
     id: "cubicEquation",
     connector: "\\iff",
     label: "Résoudre une équation du type $x^3 = k$",
-    levels: ["2nde", "1reESM", "1reSpé", "1reTech"],
     isSingleStep: true,
-    sections: ["Fonctions de référence", "Fonction cube", "Équations"],
     generator: (nb) => getDistinctQuestions(getCubicEquationQuestion, nb, 20),
     isAnswerValid,
     qcmTimer: 60,
@@ -49,4 +64,9 @@ export const cubicEquation = {
     maxAllowedQuestions: 20,
     getPropositions,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    // getCorrection,
+    // getHint,
+    // hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.js

@@ -37,7 +37,7 @@ const getInstruction = (identifiers) => {
 };
 const getHint = (identifiers) => {
     const { type, k, nbEssais, caracType } = identifiers;
-    return `La fréquence est le nombre de fois qu'on a obtenu ${caracType} divisée par le nombre total d'essais.`;
+    return `La fréquence est le nombre de fois qu'on a obtenu ${caracType} divisé par le nombre total d'essais.`;
 };
 const getCorrection = (identifiers) => {
     const { type, k, nbEssais, caracType } = identifiers;

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAiIF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}
+{"version":3,"file":"arithmeticFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA8IF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.js

@@ -2,9 +2,9 @@ import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrong
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Polynomial } from "../../../../math/polynomials/polynomial.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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers, opts) => {
     const firstRank = opts?.firstTermRankOne ? 1 : 0;
     return `$(u_n)$ est une suite arithmétique de premier terme $u_{${firstRank}} = ${identifiers.firstValue}$ et de raison $r = ${identifiers.reason}$. 
@@ -74,15 +74,28 @@ const getPropositions = (n, { answer, firstValue, reason }) => {
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { reason, firstValue }, opts) => {
-    const formula = opts?.firstTermRankOne
-        ? new Polynomial([firstValue - reason, reason], "n")
-        : new Polynomial([firstValue, reason], "n");
-    const equal = new EqualNode(new VariableNode("u_n"), formula.toTree(), {
-        allowRawRightChildAsSolution: true,
-    });
-    const texs = equal.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, reason, firstValue }, opts) => {
+    try {
+        const formated = ans.replaceAll("u_n", "").replaceAll("=", "");
+        const parsed = parseAlgebraic(formated);
+        if (!parsed)
+            return false;
+        console.log(parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex());
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex() === answer.split("=")[1]);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const options = [
     {

package/lib/exercises/math/trigonometry/associatePoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"associatePoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/associatePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAItE,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,eAAe,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAyDF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"associatePoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/associatePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAItE,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,eAAe,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/geogebra/lagrange.d.ts

@@ -1,5 +1,7 @@
 import { Point } from "../math/geometry/point.js";
 import { IntervalNode } from "../tree/nodes/sets/intervalNode.js";
+export declare abstract class LagrangeConstructor {
+}
 export declare class Lagrange {
     points: number[][];
     constructor(interval: IntervalNode, points?: Point[]);

package/lib/geogebra/lagrange.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lagrange.d.ts","sourceRoot":"","sources":["../../src/geogebra/lagrange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAIrD,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAerE,qBAAa,QAAQ;IACnB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}
+{"version":3,"file":"lagrange.d.ts","sourceRoot":"","sources":["../../src/geogebra/lagrange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAIrD,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAKrE,8BAAsB,mBAAmB;CASxC;AACD,qBAAa,QAAQ;IACnB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}

package/lib/geogebra/lagrange.js

@@ -1,16 +1,8 @@
 import { randfloat } from "../math/utils/random/randfloat.js";
 import { randint } from "../math/utils/random/randint.js";
 import { randomColor } from "./colors.js";
-// export abstract class LagrangeConstructor {
-//   random() {
-//     const a = randint(-10, 0);
-//     const b = doWhile(
-//       () => randint(0, 10),
-//       (x) => Math.abs(x - a) < 5,
-//     );
-//     return new Spline(new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF));
-//   }
-// }
+export class LagrangeConstructor {
+}
 export class Lagrange {
     points;
     constructor(interval, points) {

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import { Exercise, Question } from "./exercises/exercise.js";
 import "./prototypesEnhancement.js";
+import { parseAlgebraic } from "./tree/parsers/latexParser.js";
 declare const mathExercises: (Exercise<{
     numbers: number[];
 }, {}> | Exercise<{
@@ -673,17 +674,22 @@ declare const mathExercises: (Exercise<{
     y: number;
     isOnLine: boolean;
 }, {}> | Exercise<{
-    rand: boolean;
-    poly1: number[];
-    poly2: number[];
-    xValue: number;
-    flip: boolean;
-}, {}> | Exercise<{
-    isSpline: boolean;
-    splinePoints: number[][];
+    xValue: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    polynomeCoeffs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    imageSyntaxText: boolean;
+}, {
+    functionType: string[];
+    coeffsType: string[];
+    xType: string[];
+}> | Exercise<{
+    functionType: string;
     x: number;
     y: number;
-}, {}> | Exercise<{
+    wrongY: number;
+    otherPoints: number[][];
+}, {
+    curveTypes: string[];
+}> | Exercise<{
     poly1: number[];
     xValue: number;
 }, {}> | Exercise<{
@@ -2269,5 +2275,5 @@ declare const pcExercises: (Exercise<{
     E: number;
     S: number;
 }, {}>)[];
-export { mathExercises, pcExercises, Exercise, Question };
+export { mathExercises, pcExercises, Exercise, Question, parseAlgebraic };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/index.js

@@ -1,6 +1,8 @@
 import * as MathExercises from "./exercises/math/index.js";
 import * as PCExercises from "./exercises/pc/index.js";
 import "./prototypesEnhancement.js";
+import { parseAlgebraic } from "./tree/parsers/latexParser.js";
+parseAlgebraic;
 const mathExercises = Object.values(MathExercises);
 const pcExercises = Object.values(PCExercises);
-export { mathExercises, pcExercises };
+export { mathExercises, pcExercises, parseAlgebraic };

package/lib/math/geometry/parabola.d.ts

@@ -0,0 +1,11 @@
+import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps.js";
+import { Point } from "./point.js";
+export declare class Parabola {
+    points: Point[];
+    name: string;
+    unformatedName: string;
+    ggbName: string;
+    constructor(points: Point[], name?: string);
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showUnderlyingPoints, }?: ToGGBCommandsProps): string[];
+}
+//# sourceMappingURL=parabola.d.ts.map

package/lib/math/geometry/parabola.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parabola.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/parabola.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM;IAS1C,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,GAC5B,GAAE,kBAAuB;CA+B7B"}

package/lib/math/geometry/parabola.js

@@ -0,0 +1,32 @@
+export class Parabola {
+    points;
+    name;
+    unformatedName;
+    ggbName;
+    constructor(points, name) {
+        if (points.length !== 3)
+            throw new Error(`Parabola needs 3 points but received ${points.length}`);
+        this.points = points;
+        this.unformatedName = name ?? `${points.map((p) => p.name)}`;
+        this.name = name ?? `\\mathcal{P}_${points.map((p) => p.name)}`;
+        this.ggbName = name ?? `parabola_{${points.map((p) => p.name)}}`;
+    }
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showUnderlyingPoints = true, } = {}) {
+        const commands = [];
+        if (shouldBuildPoints) {
+            const pointsCommands = this.points.map((p) => p.toGGBCommand({
+                isFixed,
+                showLabel: showUnderlyingPointsLabel,
+            }));
+            commands.push(...pointsCommands.flat(), `${this.ggbName}=Polynomial(${this.points[0].name},${this.points[1].name},${this.points[2].name})`);
+        }
+        else {
+            commands.push(`${this.ggbName}=Polynomial(${this.points[0].toMathString()},${this.points[1].toMathString()},${this.points[2].toMathString()})`);
+        }
+        commands.push(...[
+            `SetFixed(${this.ggbName},${isFixed ? "true" : "false"})`,
+            `ShowLabel(${this.ggbName},${showLabel ? "true" : "false"})`,
+        ]);
+        return commands;
+    }
+}

package/lib/math/polynomials/generalPolynomial.d.ts

@@ -0,0 +1,19 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
+import { AddNode } from "../../tree/nodes/operators/addNode.js";
+export declare abstract class GeneralPolynomialConstructor {
+    static fromIdentifiers(identifiers: GeneralPolynomialIdentifiers): GeneralPolynomial;
+}
+export type GeneralPolynomialIdentifiers = {
+    id: "polynomial";
+    coeffs: NodeIdentifiers[];
+    variable?: string;
+};
+export declare class GeneralPolynomial {
+    coeffs: AlgebraicNode[];
+    variable: string;
+    constructor(coeffs: (number | AlgebraicNode)[], variable?: string);
+    toIdentifiers(): GeneralPolynomialIdentifiers;
+    toTree(): AddNode;
+}
+//# sourceMappingURL=generalPolynomial.d.ts.map

package/lib/math/polynomials/generalPolynomial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generalPolynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalPolynomial.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAO,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAYrE,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,4BAA4B;CAMjE;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,EAAE,EAAE,YAAY,CAAC;IACjB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,qBAAa,iBAAiB;IAC5B,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;gBAEL,MAAM,EAAE,CAAC,MAAM,GAAG,aAAa,CAAC,EAAE,EAAE,QAAQ,GAAE,MAAY;IAUtE,aAAa,IAAI,4BAA4B;IAO7C,MAAM;CAWP"}

package/lib/math/polynomials/generalPolynomial.js

@@ -0,0 +1,44 @@
+import { reifyAlgebraic, } from "../../tree/nodes/nodeConstructor.js";
+import { AddNode } from "../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../tree/nodes/operators/powerNode.js";
+import { operatorComposition } from "../../tree/utilities/operatorComposition.js";
+export class GeneralPolynomialConstructor {
+    static fromIdentifiers(identifiers) {
+        return new GeneralPolynomial(identifiers.coeffs.map((c) => reifyAlgebraic(c)), identifiers.variable);
+    }
+}
+export class GeneralPolynomial {
+    coeffs;
+    variable;
+    constructor(coeffs, variable = "x") {
+        const nodedCoeffs = coeffs.map((c) => {
+            if (typeof c === "number")
+                return c.toTree();
+            return c;
+        });
+        this.coeffs = nodedCoeffs;
+        if (nodedCoeffs[coeffs.length - 1].evaluate() === 0)
+            throw new Error("n-th coeff is null");
+        this.variable = variable;
+    }
+    toIdentifiers() {
+        return {
+            id: "polynomial",
+            coeffs: this.coeffs.map((c) => c.toIdentifiers()),
+            variable: this.variable !== "x" ? this.variable : undefined,
+        };
+    }
+    toTree() {
+        const monoms = this.coeffs
+            .map((c, i) => {
+            if (i === 0)
+                return c;
+            if (i === 1)
+                return multiply(c, this.variable);
+            return multiply(c, power(this.variable, i));
+        })
+            .filter((n, i) => this.coeffs[i].evaluate() !== 0);
+        return operatorComposition(AddNode, monoms.reverse());
+    }
+}