math-exercises 3.0.178 → 3.0.180

package/lib/exercises/math/sequences/explicitFormulaUsage.js

@@ -1,7 +1,9 @@
-import { shuffleProps, tryToAddWrongProp, addValidProp, propWhile, } from "../../../exercises/exercise.js";
+import { shuffleProps, tryToAddWrongProp, addValidProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../math/polynomials/affine.js";
 import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/polynomial.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { random } from "../../../utils/alea/random.js";
 const getInstruction = (identifiers) => {
     const { rank, coeffs } = identifiers;
     const u = new Polynomial(coeffs, "n");
@@ -19,18 +21,44 @@ const getAnswer = (identifiers) => {
     const answer = u.calculate(rank) + "";
     return answer;
 };
+const getHint = (identifiers) => {
+    return `La suite est donnée sous forme explicite. 
+  
+Remplace $n$ par $${identifiers.rank}$ dans la formule donnée.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs, rank } = identifiers;
+    const u = new Polynomial(coeffs, "n");
+    return `La suite étant donnée sous forme explicite, il suffit de remplacer $n$ par $${rank}$ dans la formule : 
+  
+$$
+u_{${rank}} = ${u.toTree().toDetailedEvaluation({ n: rank.toTree() }).toTex()}
+$$
+
+donc 
+
+$$
+u_{${rank}} = ${getAnswer(identifiers)}
+$$`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
+    return {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: ["u", "underscore", "equal"],
+        keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
-    return question;
 };
-const getExplicitFormulaUsageQuestion = () => {
-    const u = PolynomialConstructor.randomWithOrder(2, "n");
+const getExplicitFormulaUsageQuestion = (opts) => {
+    const type = opts?.functionType?.length
+        ? random(opts.functionType)
+        : random(["Affine", "Second degré"]);
+    const u = type === "Affine"
+        ? AffineConstructor.random()
+        : PolynomialConstructor.randomWithOrder(2, "n");
     const rank = randint(0, 4);
     const identifiers = { rank, coeffs: u.coefficients };
     return getQuestionFromIdentifiers(identifiers);
@@ -50,16 +78,28 @@ const getPropositions = (n, { answer, rank, coeffs }) => {
 const isAnswerValid = (ans, { answer, rank }) => {
     return [answer, `u_{${rank}}=${answer}`, `u_${rank}=${answer}`].includes(ans);
 };
+const options = [
+    {
+        id: "functionType",
+        label: "Type de fonction",
+        values: ["Affine", "Second degré"],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Affine", "Second degré"],
+    },
+];
 export const explicitFormulaUsage = {
     id: "explicitFormulaUsage",
     connector: "=",
     label: "Utiliser la formule explicite d'une suite",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getExplicitFormulaUsageQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getExplicitFormulaUsageQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
 };

package/lib/exercises/math/sequences/geometric/geometricFindRandomTermFromTwoTerms.js

@@ -246,7 +246,7 @@ const options = [generatorOptionFirstTermRankOne];
 export const geometricFindRandomTermFromTwoTerms = {
     id: "geometricFindRandomTermFromTwoTerms",
     connector: "=",
-    label: "Connaissant deux termes d'une suite géométrique, en donner une formule générale",
+    label: "Connaissant deux termes d'une suite géométrique, en calculer un troisième",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindRandomTermFromTwoTermsQuestion(opts), nb),
     options,

package/lib/exercises/math/sequences/recurrenceFormulaUsage.d.ts

@@ -4,6 +4,10 @@ type Identifiers = {
     u0: number;
     coeffs: number[];
 };
-export declare const recurrenceFormulaUsage: Exercise<Identifiers>;
+type Options = {
+    functionType: string[];
+    askedRank: string[];
+};
+export declare const recurrenceFormulaUsage: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=recurrenceFormulaUsage.d.ts.map

package/lib/exercises/math/sequences/recurrenceFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/recurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAwEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}
+{"version":3,"file":"recurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/recurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAwIF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAmBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAejE,CAAC"}

package/lib/exercises/math/sequences/recurrenceFormulaUsage.js

@@ -1,7 +1,8 @@
-import { shuffleProps, tryToAddWrongProp, addValidProp, propWhile, } from "../../../exercises/exercise.js";
+import { shuffleProps, tryToAddWrongProp, addValidProp, propWhile, GeneratorOptionType, GeneratorOptionTarget, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Polynomial } from "../../../math/polynomials/polynomial.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { random } from "../../../utils/alea/random.js";
 const getInstruction = (identifiers) => {
     const { rank, u0, coeffs } = identifiers;
     const u = new Polynomial(coeffs, "u_n");
@@ -27,21 +28,80 @@ const getAnswer = (identifiers) => {
     return answer;
 };
 const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
+    return {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: ["u", "underscore", "equal"],
+        keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
-    return question;
 };
-const getRecurrenceFormulaUsageQuestion = () => {
-    const coeffs = [randint(-5, 6), randint(-5, 6), randint(-3, 4, [0])];
+const getHint = (identifiers) => {
+    const { rank } = identifiers;
+    let corr = `La formule qui est donnée est une formule de récurrence. Pour calculer $u_1$, tu peux remplacer $n$ par $0$ dans la formule.`;
+    if (rank > 1) {
+        corr += `
+    
+Tu peux ensuite répéter cette méthode : remplace $n$ par $1$ et utilise la valeur de $u_1$ que tu as trouvée pour déterminer $u_2$.`;
+    }
+    return corr;
+};
+const getCorrection = (identifiers) => {
+    const { rank, u0, coeffs } = identifiers;
+    const u = new Polynomial(coeffs, "u_n");
+    let currentValue = u0;
+    const values = [u0];
+    for (let i = 0; i < rank; i++) {
+        currentValue = u.calculate(currentValue);
+        values.push(currentValue);
+    }
+    let corr = `On remplace $n$ par $0$ : 
+  
+$$
+u_1 = ${u.toTree().toDetailedEvaluation({ u_n: u0.toTree() }).toTex()}
+$$
+
+donc $u_1 = ${values[1].frenchify()}$.
+
+`;
+    if (rank > 1) {
+        corr += `Puis, on se sert de ce résultat pour trouver $u_2$ : on remplace $n$ par $1$ dans la formule de récurrence :
+
+$$
+u_2 = ${u.toTree().toDetailedEvaluation({ u_n: values[1].toTree() }).toTex()}
+$$
+
+donc $u_2 = ${values[2].frenchify()}$.
+
+`;
+    }
+    if (rank > 2) {
+        corr += `De même pour trouver $u_3$ : 
+    
+$$
+u_2 = ${u.toTree().toDetailedEvaluation({ u_n: values[2].toTree() }).toTex()}
+$$
+
+donc $u_2 = ${values[3].frenchify()}$.`;
+    }
+    return corr;
+};
+const getRecurrenceFormulaUsageQuestion = (opts) => {
+    const type = opts?.functionType?.length
+        ? random(opts.functionType)
+        : random(["Affine", "Second degré"]);
+    const coeffs = type === "Affine"
+        ? [randint(-5, 6), randint(-5, 6, [0])]
+        : [randint(-5, 6), randint(-5, 6), randint(-3, 4, [0])];
     const u0 = randint(-2, 3, [0]);
-    const rank = randint(1, 4);
+    const texRank = opts?.askedRank?.length
+        ? random(opts.askedRank)
+        : random(["$1$", "$2$", "$3$"]);
+    const rank = Number(texRank[1]);
     const identifiers = { rank, u0, coeffs };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getPropositions = (n, { answer, rank, coeffs }) => {
     const propositions = [];
@@ -57,16 +117,36 @@ const getPropositions = (n, { answer, rank, coeffs }) => {
 const isAnswerValid = (ans, { answer, rank }) => {
     return [answer, `u_{${rank}}=${answer}`, `u_${rank}=${answer}`].includes(ans);
 };
+const options = [
+    {
+        id: "functionType",
+        label: "Type de fonction",
+        values: ["Affine", "Second degré"],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Affine", "Second degré"],
+    },
+    {
+        id: "askedRank",
+        label: "Rang demandé",
+        values: ["$1$", "$2$", "$3$"],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["$1$", "$2$", "$3$"],
+    },
+];
 export const recurrenceFormulaUsage = {
     id: "recurrenceFormulaUsage",
     connector: "=",
     label: "Utiliser la formule de récurrence d'une suite",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getRecurrenceFormulaUsageQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getRecurrenceFormulaUsageQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    options,
+    hasHintAndCorrection: true,
 };

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

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

package/lib/exercises/math/trigonometry/circle/associatePoint.js

@@ -2,6 +2,9 @@ import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../..
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { RemarkableValueConstructor } from "../../../../math/trigonometry/remarkableValue.js";
 import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 const points = [
@@ -32,12 +35,55 @@ const getAnswer = (identifiers) => {
     const { point } = identifiers;
     return point;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return ``;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   return ``;
-// };
+const getHint = (identifiers) => {
+    const { angleIdentifiers } = identifiers;
+    const angle = reifyAlgebraic(angleIdentifiers);
+    const isSimplifiable = angle.evaluate() > Math.PI || angle.evaluate() <= -Math.PI;
+    let hint = "";
+    if (isSimplifiable) {
+        hint += `Commence par te ramener à l'intervalle $]-\\pi; \\pi]$, en ajoutant ou en retirant un multiple de $2\\pi$ à $${angle.toTex()}$.
+    
+`;
+    }
+    return hint + `Le cercle trigonométrique a un périmètre de $2\\pi$.`;
+};
+const getCorrection = (identifiers) => {
+    const { angleIdentifiers } = identifiers;
+    const angle = reifyAlgebraic(angleIdentifiers);
+    const isSimplifiable = angle.evaluate() > Math.PI || angle.evaluate() <= -Math.PI;
+    let corr = "";
+    if (isSimplifiable) {
+        let toAdd = 0;
+        let newAngle = angle;
+        let counter = 0;
+        while (newAngle.evaluate() > Math.PI || newAngle.evaluate() <= -Math.PI) {
+            counter++;
+            if (counter > 1000)
+                throw new Error("too many iterations in remarkable values");
+            if (newAngle.evaluate() > 0)
+                toAdd--;
+            else
+                toAdd++;
+            console.log(newAngle.evaluate(), toAdd);
+            newAngle = add(newAngle, multiply(toAdd > 0 ? 2 : -2, PiNode)).simplify();
+        }
+        // const raw = frac(angle, PiNode).simplify();
+        corr += `On se ramène à l'intervalle $]-\\pi; \\pi]$ :
+
+$$
+${add(angle, multiply(2 * toAdd, PiNode)).toTex()} = ${newAngle.toTex()}
+$$`;
+    }
+    return (corr +
+        `
+  
+On se sert du cercle trigonométrique ci-dessous : 
+
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/piCercle_nombres.jpg)
+
+Le point cherché est donc $${getAnswer(identifiers)}$.
+`);
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -45,6 +91,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: points,
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -83,4 +131,5 @@ export const associatePoint = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/trigonometry/circle/selectQuadrantOnTrigoCircle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selectQuadrantOnTrigoCircle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/selectQuadrantOnTrigoCircle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2FF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAuB7D,CAAC"}
+{"version":3,"file":"selectQuadrantOnTrigoCircle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/selectQuadrantOnTrigoCircle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA8FF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAuB7D,CAAC"}

package/lib/exercises/math/trigonometry/circle/selectQuadrantOnTrigoCircle.js

@@ -1,13 +1,12 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-const getPropositions = (n, { answer }) => {
+const getPropositions = (_n, { answer }) => {
     const propositions = [];
-    addValidProp(propositions, answer, "raw");
-    ["Bleu", "Rouge", "Vert", "Jaune"].forEach((color) => {
-        tryToAddWrongProp(propositions, color, "raw");
+    ["Bleu", "Jaune", "Rouge", "Vert"].forEach((color) => {
+        (color === answer ? addValidProp : tryToAddWrongProp)(propositions, color, "raw");
     });
-    return shuffleProps(propositions, n);
+    return propositions;
 };
 const getAnswer = (identifiers) => {
     return ["Bleu", "Rouge", "Vert", "Jaune"][identifiers.quartant];

package/lib/exercises/math/trigonometry/functions/associateAngleSimplification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"associateAngleSimplification.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/associateAngleSimplification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgKF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAsB9D,CAAC"}
+{"version":3,"file":"associateAngleSimplification.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/associateAngleSimplification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8JF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAsB9D,CAAC"}

package/lib/exercises/math/trigonometry/functions/associateAngleSimplification.js

@@ -95,9 +95,7 @@ $$`;
         corr += `
 
 $$
-${multiply(d, fct(substract(PiNode, "x"))).toTex()} =  ${isCos
-            ? multiply(-d, cos(substract(PiNode, "x"))).toTex()
-            : multiply(d, sin(substract(PiNode, "x"))).toTex()}
+${multiply(d, fct(substract(PiNode, "x"))).toTex()} =  ${isCos ? multiply(-d, cos("x")).toTex() : multiply(d, sin("x")).toTex()}
 $$`;
     }
     corr += `

package/lib/exercises/vea/polynomialVEA.d.ts

@@ -0,0 +1,2 @@
+export declare const polynomialVEA: (ans: string, answer: string) => boolean;
+//# sourceMappingURL=polynomialVEA.d.ts.map

package/lib/exercises/vea/polynomialVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomialVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/polynomialVEA.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,YAmBxD,CAAC"}

package/lib/exercises/vea/polynomialVEA.js

@@ -0,0 +1,17 @@
+import { getArrNodeCoeffOfPolynomialNode } from "../../math/utils/polynomial/polynomialUtils.js";
+import { substract } from "../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../tree/parsers/latexParser.js";
+import { zip } from "../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../utils/errors/handleVEAError.js";
+export const polynomialVEA = (ans, answer) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        const [arrNodeCoeffAns, arrNodeCoeffAnswer] = [nodeAns, nodeAnswer].map((node) => getArrNodeCoeffOfPolynomialNode(node));
+        return (arrNodeCoeffAns.length === arrNodeCoeffAnswer.length &&
+            zip(arrNodeCoeffAns, arrNodeCoeffAnswer).every(([nodeCoeffAns, nodeCoeffAnswer]) => substract(nodeCoeffAns, nodeCoeffAnswer).evaluate() === 0));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};

package/lib/exercises/vea/valueTableVEA.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param ans tableau du student
+ * @param answerTable tableau réponse
+ * TODO passer en argument le VEA check qui est ajd fixé à rationalVEA
+ */
+export declare const valueTableVEA: (ans: string[][], answerTable: string[][]) => boolean;
+//# sourceMappingURL=valueTableVEA.d.ts.map

package/lib/exercises/vea/valueTableVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/valueTableVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAOrE,CAAC"}

package/lib/exercises/vea/valueTableVEA.js

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param ans tableau du student
+ * @param answerTable tableau réponse
+ * TODO passer en argument le VEA check qui est ajd fixé à rationalVEA
+ */
+import { rationalVEA } from "./rationalVEA.js";
+export const valueTableVEA = (ans, answerTable) => {
+    return ans.every((row, i) => {
+        return row.every((cell, j) => cell === answerTable[i][j] || rationalVEA(cell, answerTable[i][j]));
+    });
+};

package/lib/index.d.ts

@@ -2861,15 +2861,6 @@ declare const mathExercises: (Exercise<{
     kIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     uCoeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    flip: number;
-    pA?: number;
-    pB?: number;
-    pAB?: number;
-    pA_B?: number;
-    pB_A?: number;
-}, {
-    probaType: string[];
-}> | Exercise<{
     randomValues: number[];
     randomEffectives: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -3014,6 +3005,7 @@ declare const mathExercises: (Exercise<{
     allowedAnsType: string[];
 }, {
     allowedAnsType: string[];
+    probaTypes: string[];
 }> | Exercise<{
     exerciseVars: {
         n: number;
@@ -3205,6 +3197,25 @@ declare const mathExercises: (Exercise<{
     situationIndex: number;
     dictShuffle: Record<string, string>;
     pType: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    flip: number;
+    pA?: number;
+    pB?: number;
+    pAB?: number;
+    pA_B?: number;
+    pB_A?: number;
+}, {
+    probaType: string[];
+}> | Exercise<{
+    params: import("./exercises/math/probaStat/trees/probaTreeSituations.js").ProbaTreeSituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationIndex: number;
+    aCapB: number;
+    aCapBBarre: number;
+    aBarreCapB: number;
+    aBarreCapBBarre: number;
+    knowing: "A" | "\\overline{A}" | "B" | "\\overline{B}";
+    asked: "A" | "\\overline{A}" | "B" | "\\overline{B}";
 }, Record<string, string | boolean | string[]>> | Exercise<{
     situationIndex: number;
     values: number[];
@@ -3457,13 +3468,18 @@ declare const mathExercises: (Exercise<{
 }, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
     rank: number;
     coeffs: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    functionType: string[];
+}> | Exercise<{
     coeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     rank: number;
     u0: number;
     coeffs: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    functionType: string[];
+    askedRank: string[];
+}> | Exercise<{
     termeid: number;
     affine: number[];
     termeAdd: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/latexTester.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,6BAA2B,YA+LrE,CAAC"}
+{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,6BAA2B,YAgMrE,CAAC"}

package/lib/latexTester.js

@@ -19,7 +19,7 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
         }
         if (char === "$") {
             if (isDefaultInMathMode)
-                throw new Error("Dollar in default math mode");
+                throw new Error(`Dollar in default math mode, ${latex}`);
             if (inPython || inInlinePython)
                 throw new Error("Dollar in python mode");
             if (nextChar === "$") {

package/lib/math/utils/polynomial/polynomialInterpolationUtils.d.ts

@@ -0,0 +1,19 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+export declare class PointOfFunction {
+    nodeAbscissa: AlgebraicNode;
+    nodeValue: AlgebraicNode;
+    nodeDerivative: AlgebraicNode;
+    constructor(nodeAbscissa: AlgebraicNode, nodeValue: AlgebraicNode, nodeDerivative: AlgebraicNode);
+    toIdentifiers(): PointOfFunctionIdentifiers;
+}
+export type PointOfFunctionIdentifiers = {
+    nodeIdsAbscissa: NodeIdentifiers;
+    nodeIdsValue: NodeIdentifiers;
+    nodeIdsDerivative: NodeIdentifiers;
+};
+export declare abstract class PointOfFunctionConstructor {
+    static fromIdentifiers(pofIds: PointOfFunctionIdentifiers): PointOfFunction;
+}
+export declare function createArrNodeCoeffCubic(pof1: PointOfFunction, pof2: PointOfFunction): import("../../../tree/nodes/operators/fractionNode.js").FractionNode[];
+//# sourceMappingURL=polynomialInterpolationUtils.d.ts.map

package/lib/math/utils/polynomial/polynomialInterpolationUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomialInterpolationUtils.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/polynomial/polynomialInterpolationUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,qBAAa,eAAe;IAEjB,YAAY,EAAE,aAAa;IAC3B,SAAS,EAAE,aAAa;IACxB,cAAc,EAAE,aAAa;gBAF7B,YAAY,EAAE,aAAa,EAC3B,SAAS,EAAE,aAAa,EACxB,cAAc,EAAE,aAAa;IAEtC,aAAa,IAKN,0BAA0B;CAElC;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,EAAE,eAAe,CAAC;IAC9B,iBAAiB,EAAE,eAAe,CAAC;CACpC,CAAC;AAEF,8BAAsB,0BAA0B;IAC9C,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,0BAA0B;CAY1D;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,eAAe,uEA0FtB"}

package/lib/math/utils/polynomial/polynomialInterpolationUtils.js

@@ -0,0 +1,53 @@
+import { opposite } from "../../../tree/nodes/functions/oppositeNode.js";
+import { NodeConstructor, } 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 { power } from "../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+export class PointOfFunction {
+    nodeAbscissa;
+    nodeValue;
+    nodeDerivative;
+    constructor(nodeAbscissa, nodeValue, nodeDerivative) {
+        this.nodeAbscissa = nodeAbscissa;
+        this.nodeValue = nodeValue;
+        this.nodeDerivative = nodeDerivative;
+    }
+    toIdentifiers() {
+        return {
+            nodeIdsAbscissa: this.nodeAbscissa.toIdentifiers(),
+            nodeIdsValue: this.nodeValue.toIdentifiers(),
+            nodeIdsDerivative: this.nodeDerivative.toIdentifiers(),
+        };
+    }
+}
+export class PointOfFunctionConstructor {
+    static fromIdentifiers(pofIds) {
+        const nodeAbscissa = NodeConstructor.fromIdentifiers(pofIds.nodeIdsAbscissa);
+        const nodeValue = NodeConstructor.fromIdentifiers(pofIds.nodeIdsValue);
+        const nodeDerivative = NodeConstructor.fromIdentifiers(pofIds.nodeIdsDerivative);
+        return new PointOfFunction(nodeAbscissa, nodeValue, nodeDerivative);
+    }
+}
+export function createArrNodeCoeffCubic(pof1, pof2) {
+    //
+    //pof1 = {x1,u1,v1}
+    //pof2 = {x2,u2,v2}
+    //
+    //f(x)  = ax^3+bx^2+cx+d
+    //f'(x) = 2ax+b
+    //
+    //f(x1) = u1 <=> a(x1)^3+b(x1)^2+c(x1)+d = u1
+    //f(x2) = u2 <=> a(x2)^3+b(x2)^2+c(x2)+d = u2
+    //f'(x1) = v1 <=> 3a(x1)^2+2b(x1)+c = v1
+    //f'(x2) = v2 <=> 3a(x2)^2+2b(x2)+c = v2
+    //
+    const { nodeAbscissa: x1, nodeValue: u1, nodeDerivative: v1 } = pof1;
+    const { nodeAbscissa: x2, nodeValue: u2, nodeDerivative: v2 } = pof2;
+    const nodeA = frac(add(multiply(add(v1, v2), substract(x1, x2)), multiply(2, substract(u2, u1))), power(substract(x1, x2), 3));
+    const nodeB = frac(add(multiply(opposite(add(v1, multiply(2, v2))), power(x1, 2)), add(multiply(add(multiply(substract(v2, v1), x2), multiply(3, substract(u1, u2))), x1), multiply(2, multiply(x2, add(multiply(add(v1, frac(v2, 2)), x2), multiply(frac(3, 2), substract(u1, u2))))))), power(substract(x1, x2), 3));
+    const nodeC = frac(substract(add(multiply(v2, power(x1, 3)), multiply(2, multiply(add(v1, frac(v2, 2)), multiply(x2, power(x1, 2))))), add(multiply(x2, multiply(x1, add(multiply(add(v1, multiply(2, v2)), x2), multiply(6, substract(u1, u2))))), multiply(v1, power(x2, 3)))), power(substract(x1, x2), 3));
+    const nodeD = frac(substract(add(multiply(substract(u2, multiply(v2, x2)), power(x1, 3)), multiply(power(x2, 2), multiply(x1, add(multiply(v1, x2), multiply(3, u1))))), add(multiply(power(x1, 2), multiply(x2, add(multiply(substract(v1, v2), x2), multiply(3, u2)))), multiply(u1, power(x2, 3)))), power(substract(x1, x2), 3));
+    return [nodeD, nodeC, nodeB, nodeA];
+}