math-exercises 3.0.13 → 3.0.15

package/lib/exercises/math/calcul/fractions/fractionsProduct.d.ts

@@ -1,7 +1,7 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
-    rationalNum: [number, number];
-    rationalDenum: [number, number];
+    rationalNum: number[];
+    rationalDenum: number[];
 };
 type Options = {
     allowNonIrreductible?: boolean;

package/lib/exercises/math/calcul/fractions/fractionsProduct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionsProduct.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAgGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB3D,CAAC"}
+{"version":3,"file":"fractionsProduct.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AA2HF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoB3D,CAAC"}

package/lib/exercises/math/calcul/fractions/fractionsProduct.js

@@ -2,49 +2,75 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { allowNonIrreductibleOption } from "../../../../exercises/options/allowNonIrreductibleFractions.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Rational, RationalConstructor, } from "../../../../math/numbers/rationals/rational.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { rationalParser } from "../../../../tree/parsers/rationalParser.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getFractionsProduct = (opts) => {
-    const rational = RationalConstructor.randomIrreductible();
-    const rational2 = RationalConstructor.randomIrreductible();
-    const statementTree = new MultiplyNode(rational.toTree(), rational2.toTree());
-    const answerTree = rational.multiply(rational2).toTree();
-    const answer = answerTree.toTex();
-    const beforeSimplification = new Rational(rational.num * rational2.num, rational.denum * rational2.denum);
-    const question = {
-        instruction: `Calculer ${opts?.allowNonIrreductible
-            ? ""
-            : "et donner le résultat sous la forme la plus simplifiée possible"} : 
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getStatementNode = (identifiers) => {
+    const { rationalNum, rationalDenum } = identifiers;
+    const rational = frac(rationalNum[0], rationalNum[1]);
+    const rational2 = frac(rationalDenum[0], rationalDenum[1]);
+    const statementTree = new MultiplyNode(rational, rational2);
+    return statementTree;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getInstruction = (identifiers, opts) => {
+    return `Calculer ${opts?.allowNonIrreductible
+        ? "et donner le résultat sous la forme d'une fraction"
+        : "et donner le résultat sous la forme d'une fraction la plus simplifiée possible"} : 
     
 $$
-${statementTree.toTex()}
-$$`,
-        startStatement: statementTree.toTex(),
-        answer,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: {
-            rationalNum: [rational.num, rational.denum],
-            rationalDenum: [rational2.num, rational2.denum],
-        },
-        hint: "Pour multiplier deux fractions, on multiplie les numérateurs entre eux et les dénominateurs entre eux, puis on simplifie la fraction obtenue si nécessaire.",
-        correction: `On multiplie les numérateurs entre eux et les dénominateurs entre eux :  
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { rationalNum, rationalDenum } = identifiers;
+    const rational = frac(rationalNum[0], rationalNum[1]);
+    const rational2 = frac(rationalDenum[0], rationalDenum[1]);
+    return multiply(rational, rational2).simplify().toTex();
+};
+const getHint = (identifiers) => {
+    return "Pour multiplier deux fractions, on multiplie les numérateurs entre eux et les dénominateurs entre eux, puis on simplifie la fraction obtenue si nécessaire.";
+};
+const getCorrection = (identifiers, opts) => {
+    const { rationalNum, rationalDenum } = identifiers;
+    const beforeSimplification = new Rational(rationalNum[0] * rationalDenum[0], rationalNum[1] * rationalDenum[1]);
+    const answer = getAnswer(identifiers, opts);
+    return `On multiplie les numérateurs entre eux et les dénominateurs entre eux :  
 
 $$
-\\frac{${rational.num}\\times${rational2.num}}{${rational.denum}\\times${rational2.denum}} = ${beforeSimplification.toTree().toTex()}
+\\frac{${rationalNum[0]}\\times${rationalDenum[0]}}{${rationalNum[1]}\\times${rationalDenum[1]}} = ${beforeSimplification.toTree().toTex()}
 $$
 
 ${!beforeSimplification.isIrreductible()
-            ? `On peut alors simplifier cette fraction : 
+        ? `On peut alors simplifier cette fraction : 
     
 $$
 ${beforeSimplification.toTree().toTex()} = ${answer}
 $$`
-            : "Cette fraction est déjà simplifiée."}
+        : "Cette fraction est déjà simplifiée."}
 
-Ainsi, le résultat attendu est $${answer}$.
-    `,
+Ainsi, le résultat attendu est $${answer}$.`;
+};
+const getFractionsProduct = (opts) => {
+    const rational = RationalConstructor.randomIrreductible();
+    const rational2 = RationalConstructor.randomIrreductible();
+    const identifiers = {
+        rationalNum: [rational.num, rational.denum],
+        rationalDenum: [rational2.num, rational2.denum],
+    };
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -59,21 +85,19 @@ const getPropositions = (n, { answer, rationalNum, rationalDenum }) => {
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { rationalDenum, rationalNum }, opts) => {
-    const rational = new Rational(rationalNum[0], rationalNum[1]);
-    const rational2 = new Rational(rationalDenum[0], rationalDenum[1]);
-    const answerTree = rational
-        .multiply(rational2)
-        .toTree({ allowFractionToDecimal: true });
-    const texs = answerTree.toAllValidTexs();
-    if (opts?.allowNonIrreductible) {
+const isAnswerValid = (ans, { answer, rationalDenum, rationalNum }, opts) => {
+    try {
         const parsed = rationalParser(ans);
         if (!parsed)
             return false;
-        return texs.includes(parsed.simplify().toTex());
+        if (opts?.allowNonIrreductible) {
+            return parsed.simplify().toTex() === answer;
+        }
+        else
+            return parsed.toTex() === answer;
     }
-    else {
-        return texs.includes(ans);
+    catch (err) {
+        return handleVEAError(err);
     }
 };
 const options = [allowNonIrreductibleOption];
@@ -92,4 +116,8 @@ export const fractionsProduct = {
     subject: "Mathématiques",
     hasHintAndCorrection: true,
     options,
+    getInstruction,
+    getAnswer,
+    getHint,
+    getCorrection,
 };

package/lib/exercises/math/calcul/index.d.ts

@@ -12,4 +12,5 @@ export * from "./digitRankNumber.js";
 export * from "./digitDecimalRankNumber.js";
 export * from "./ordering/index.js";
 export * from "./decimals/index.js";
+export * from "./sign/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,iBAAiB,CAAC"}

package/lib/exercises/math/calcul/index.js

@@ -13,4 +13,4 @@ export * from "./digitDecimalRankNumber.js";
 export * from "./ordering/index.js";
 export * from "./decimals/index.js";
 // export * from "./writing";
-// export * from "./sign";
+export * from "./sign/index.js";

package/lib/exercises/math/calcul/sign/index.d.ts

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

package/lib/exercises/math/calcul/sign/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/sign/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/sign/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/lib/exercises/math/calcul/sign/index.js

@@ -1 +1 @@
-export {};
+export * from "./signFromAx.js";

package/lib/exercises/math/calcul/sign/signFromAx.d.ts

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

package/lib/exercises/math/calcul/sign/signFromAx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signFromAx.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/sign/signFromAx.ts"],"names":[],"mappings":""}
+{"version":3,"file":"signFromAx.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/sign/signFromAx.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAwGF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAiB5C,CAAC"}

package/lib/exercises/math/calcul/sign/signFromAx.js

@@ -1,80 +1,110 @@
-// import {
-//   Exercise,
-//   Proposition,
-//   QCMGenerator,
-//   Question,
-//   QuestionGenerator,
-//   VEA,
-//   addValidProp,
-//   shuffleProps,
-//   GetAnswer,
-//   GetHint,
-//   GetCorrection,
-//   GetInstruction,
-//   GetKeys,
-//   tryToAddWrongProp,
-// } from '../../../../exercises/exercise.js';
-// import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions.js';
-// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-export {};
-// type Identifiers = {
-//   coeff:number;
-//   sign: number;
-// };
-// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
-//   const propositions: Proposition[] = [];
-//   addValidProp(propositions, answer);
-//   tryToAddWrongProp(propositions, `$x$ est négatif`)
-//   while (propositions.length < n) {
-//     throw Error("QCM not implemented")
-//   }
-//   return shuffleProps(propositions, n);
-// };
-// const getAnswer : GetAnswer<Identifiers> = (identifiers)=>{
-// }
-// const getInstruction : GetInstruction<Identifiers> = (identifiers)=>{
-//   return `On considère un nombre relatif $x$ tel que $${}$ est strictement $${sign}$. Quel est le signe de $x$ ?`
-// }
-// const getHint : GetHint<Identifiers> = (identifiers)=>{
-// }
-// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
-// }
-// const getKeys : GetKeys<Identifiers> = (identifiers)=>{
-//   return []
-// }
-// const isAnswerValid: VEA<Identifiers> = (ans, {answer})=>{
-//   try {
-//     throw Error("VEA not implemented")
-//   } catch(err){
-//     return handleVEAError(err)
-//   }
-// }
-// const getSignFromAxQuestion: QuestionGenerator<Identifiers>  = (ops)=>{
-//   const identifiers: Identifiers = {}
-//   const question: Question<Identifiers> = {
-//     answer: getAnswer(identifiers),
-//     instruction: getInstruction(identifiers),
-//     keys: getKeys(identifiers),
-//     answerFormat: 'tex',
-//     identifiers,
-//     hint: getHint(identifiers),
-//     correction: getCorrection(identifiers)
-//   };
-//   return question;
-// }
-// export const signFromAx: Exercise<Identifiers> = {
-//   id: 'signFromAx',
-//   connector: "",
-//   label: undefined,
-//   isSingleStep: true,
-//   generator: (nb, opts) => getDistinctQuestions(()=>getSignFromAxQuestion(opts), nb),
-//   qcmTimer: 60,
-//   freeTimer: 60,
-//   getPropositions,
-//   isAnswerValid,
-//   subject: "Mathématiques",
-//   getInstruction,
-//   getHint,
-//   getCorrection,
-//   getAnswer,
-// };
+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 { monom } from "../../../../tree/nodes/polynomials/monomNode.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+//-x pos/nég/nul
+//ax pos/nég/nul avec a>0 donné ou <0
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, `$x$ est négatif.`, "raw");
+    tryToAddWrongProp(propositions, `$x$ est positif.`, "raw");
+    tryToAddWrongProp(propositions, `$x$ est égal à $0$.`, "raw");
+    tryToAddWrongProp(propositions, `On ne peut rien dire sur le signe de $x$.`, "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, sign } = identifiers;
+    if (sign === 0)
+        return `$x$ est égal à $0$.`;
+    if (a > 0 === sign > 0) {
+        return `$x$ est positif.`;
+    }
+    else {
+        return `$x$ est négatif.`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { a, sign } = identifiers;
+    const signString = sign === 0
+        ? "égal à $0$"
+        : sign === 1
+            ? "strictement positif"
+            : "strictement négatif";
+    return `On considère un nombre relatif $x$ tel que $${multiply(a, "x").toTex()}$ est ${signString}. 
+  
+Quel est le signe de $x$ ?`;
+};
+const getHint = (identifiers) => {
+    return `On rappelle que : 
+    
+- le produit de deux nombres positifs est positif ;
+- le produit de deux nombres négatifs est positif ;
+- le produit de deux nombres de signes différents est négatif.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, sign } = identifiers;
+    const monomTex = monom(a, 1).toTex();
+    if (sign === 0) {
+        return `Puisque $${monomTex}$ est égal à $0$, alors $x$ est égal à $0$.`;
+    }
+    else {
+        if (a > 0) {
+            return `Puisque $${a}$ est positif, et que $${monomTex}$ est ${sign > 0 ? "positif" : "négatif"}, alors $x$ est ${sign > 0 ? "positif" : "négatif"}.`;
+        }
+        else {
+            return `Puisque $${a}$ est négatif, et que $${monomTex}$ est ${sign > 0 ? "positif" : "négatif"}, alors $x$ est ${sign > 0 ? "négatif" : "positif"}.`;
+        }
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSignFromAxQuestion = (ops) => {
+    const identifiers = {
+        a: randint(-9, 10, [0, 1]),
+        sign: probaLawFlip([
+            [-1, 0.45],
+            [0, 0.1],
+            [1, 0.45],
+        ]),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const signFromAx = {
+    id: "signFromAx",
+    label: "Déterminer le signe de $x$ en fonction du signe de $ax$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSignFromAxQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getAnswer,
+    answerType: "QCU",
+};

package/lib/exercises/math/calculLitteral/simplifying/evaluateExpression.js

@@ -83,7 +83,7 @@ const isAnswerValid = (ans, { answer }) => {
 export const evaluateExpression = {
     id: "evaluateExpression",
     connector: "=",
-    label: "Evaluer une expression",
+    label: "Évaluer une expression",
     levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro"],
     sections: ["Calcul littéral"],
     isSingleStep: true,

package/lib/exercises/math/calculLitteral/simplifying/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./evaluateExpression.js";
 export * from "./reduceExpression.js";
 export * from "./distributeAndSimplify.js";
+export * from "./valuateExpression.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calculLitteral/simplifying/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/index.js

@@ -1,3 +1,4 @@
 export * from "./evaluateExpression.js";
 export * from "./reduceExpression.js";
 export * from "./distributeAndSimplify.js";
+export * from "./valuateExpression.js";

package/lib/exercises/math/calculLitteral/simplifying/valuateExpression.d.ts

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

package/lib/exercises/math/calculLitteral/simplifying/valuateExpression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valuateExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/valuateExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AA2GF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAiBnD,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/valuateExpression.js

@@ -0,0 +1,101 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { monom } from "../../../../tree/nodes/polynomials/monomNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getExpression = (identifiers) => {
+    const { xValue, a, b, monomFirst } = identifiers;
+    return add(monomFirst ? monom(a, 1) : b, monomFirst ? b : monom(a, 1));
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { xValue, a, b, monomFirst } = identifiers;
+    const expressionSquare = add(monomFirst ? power(xValue, a) : b, monomFirst ? b : power(xValue, a));
+    const expressionAdd = add(monomFirst ? add(a, xValue) : b, monomFirst ? b : add(a, xValue));
+    const wrongOp = (a > 0 ? 1 : -1) * (Math.abs(a) * 10 + Math.abs(xValue));
+    const expressionNoOp = add(monomFirst ? wrongOp : b, monomFirst ? b : wrongOp);
+    tryToAddWrongProp(propositions, expressionSquare.toDetailedEvaluation({ x: xValue.toTree() }).toTex());
+    tryToAddWrongProp(propositions, expressionAdd.toDetailedEvaluation({ x: xValue.toTree() }).toTex());
+    tryToAddWrongProp(propositions, expressionNoOp.toDetailedEvaluation({ x: xValue.toTree() }).toTex());
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { xValue, a, b, monomFirst } = identifiers;
+    const expression = getExpression(identifiers);
+    return expression.toDetailedEvaluation({ x: xValue.toTree() }).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { xValue, a, b, monomFirst } = identifiers;
+    return `Voici une expression algébrique : 
+  
+$$
+${getExpression(identifiers).toTex()}
+$$
+
+Quelle est la valeur de cette expression pour $x=${xValue}$ ?`;
+};
+const getHint = (identifiers) => {
+    return `L'écriture $ax$ signifie : $a\\times x$.`;
+};
+const getCorrection = (identifiers) => {
+    return `Quand on écrit $ax$, on parle d'une multiplication de $a$ par $x$ : c'est à dire que $ax = a\\times x$.
+  
+Ici, le bon calcul est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getValuateExpressionQuestion = (ops) => {
+    const a = randint(-9, 10, [0, 1, -1]);
+    const b = randint(-9, 10, [0]);
+    const monomFirst = coinFlip();
+    const identifiers = {
+        xValue: randint(-9, 10),
+        a,
+        b,
+        monomFirst,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const valuateExpression = {
+    id: "valuateExpression",
+    label: "Trouver le bon calcul pour évaluer une expression algébrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getValuateExpressionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/basics/imageFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"imageFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IAOjB,MAAM,EAAE,eAAe,CAAC;IACxB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA2LF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AA4BF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBxD,CAAC"}
+{"version":3,"file":"imageFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IAOjB,MAAM,EAAE,eAAe,CAAC;IACxB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA+LF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AA4BF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBxD,CAAC"}

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

@@ -35,7 +35,11 @@ const getInstruction = (identifiers, opts) => {
     const xValueTex = reifyAlgebraic(xValue).toTex();
     const coeffsNode = polynomeCoeffs.map((coeff) => reifyAlgebraic(coeff));
     const polynome = new GeneralPolynomial(coeffsNode);
-    const statement = `Soit $f(x) = ${polynome.toTree().toTex()}$. 
+    const statement = `Soit $f$ la fonction définie par : 
+  
+$$
+f(x) = ${polynome.toTree().toTex()}
+$$
     
 Calculer ${imageSyntaxText
         ? `l'image de $${xValueTex}$ par $f$.`

package/lib/exercises/math/squareRoots/squareRootsSum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootsSum.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AA8EF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"squareRootsSum.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AA6FF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

package/lib/exercises/math/squareRoots/squareRootsSum.js

@@ -1,5 +1,6 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { sqrtVEA } from "../../../exercises/vea/sqrtVEA.js";
 import { SquareRootConstructor } from "../../../math/numbers/reals/real.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { SqrtNode } from "../../../tree/nodes/functions/sqrtNode.js";
@@ -7,20 +8,42 @@ import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { AddNode } from "../../../tree/nodes/operators/addNode.js";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 //a sqrt(x*b) + c sqrt(y*b) (+ d sqrt(z*b))
 //avec x,y,z carrés parfait
+const getStatementNode = (identifiers) => {
+    const { a, b, c, d, x, y, z } = identifiers;
+    const aNode = new NumberNode(a);
+    const cNode = new NumberNode(c);
+    const xbNode = new NumberNode(b * x);
+    const ybNode = new NumberNode(b * y);
+    let statement = new AddNode(new MultiplyNode(aNode, new SqrtNode(xbNode)), new MultiplyNode(cNode, new SqrtNode(ybNode)));
+    if (!!d && !!z) {
+        const dNode = new NumberNode(d);
+        const zbNode = new NumberNode(z * b);
+        statement = new AddNode(statement, new MultiplyNode(dNode, new SqrtNode(zbNode)));
+    }
+    return statement;
+};
+const getInstruction = (identifiers) => {
+    return `Simplifier sous la forme $a\\sqrt{b}$ avec $b$ le plus petit possible : 
+  
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const answer = getStatementNode(identifiers).simplify().toTex();
+    return answer;
+};
 const getSquareRootsSumQuestion = () => {
     const a = randint(-9, 10, [0]);
-    const aNode = new NumberNode(a);
     const c = randint(-9, 10, [0]);
-    const cNode = new NumberNode(c);
     const b = SquareRootConstructor.randomIrreductible(10).operand;
     let x = randint(1, 6);
     x *= x;
-    const xbNode = new NumberNode(b * x);
     let y = randint(1, 6);
     y *= y;
-    const ybNode = new NumberNode(b * y);
     let d;
     let z;
     if (coinFlip()) {
@@ -28,19 +51,13 @@ const getSquareRootsSumQuestion = () => {
         z = randint(1, 6);
         z *= z;
     }
-    let statement = new AddNode(new MultiplyNode(aNode, new SqrtNode(xbNode)), new MultiplyNode(cNode, new SqrtNode(ybNode)));
-    if (!!d && !!z) {
-        const dNode = new NumberNode(d);
-        const zbNode = new NumberNode(z * b);
-        statement = new AddNode(statement, new MultiplyNode(dNode, new SqrtNode(zbNode)));
-    }
-    const answer = statement.simplify().toTex();
+    const identifiers = { a, b, c, d, x, y, z };
     const question = {
-        answer,
-        instruction: `Simplifier sous la forme $a\\sqrt{b}$ avec $b$ le plus petit possible : $${statement.toTex()}$`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { a, b, c, d, x, y, z },
+        identifiers,
     };
     return question;
 };
@@ -53,25 +70,24 @@ const getPropositions = (n, { answer, b }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer, a, b, c, d, y, x, z }) => {
-    let coeff = a * Math.sqrt(x) + c * Math.sqrt(y);
-    if (!!d && !!z) {
-        coeff += d * Math.sqrt(z);
+    try {
+        return sqrtVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
     }
-    const tree = new MultiplyNode(new NumberNode(coeff), new SqrtNode(new NumberNode(b))).simplify();
-    const texs = tree.toAllValidTexs();
-    return texs.includes(ans);
 };
 export const squareRootsSum = {
     id: "squareRootsSum",
     connector: "=",
     label: "Simplifier une somme de racines carrées",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Racines carrées"],
     generator: (nb) => getDistinctQuestions(getSquareRootsSumQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
 };

package/lib/exercises/pc/dosage/beerLambertRandomValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"beerLambertRandomValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/beerLambertRandomValue.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAmNF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAchE,CAAC"}
+{"version":3,"file":"beerLambertRandomValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/beerLambertRandomValue.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA0NF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAchE,CAAC"}

package/lib/exercises/pc/dosage/beerLambertRandomValue.js

@@ -63,39 +63,46 @@ const getBeerLambertRandomValueQuestion = () => {
   
 Réorganisez cette formule pour isoler la variable à trouver.`;
     const correction = `La loi de Beer-Lambert est donnée par :
-  $$A = \\varepsilon \\cdot \\ell \\cdot C$$ 
+
+$$
+A = \\varepsilon \\cdot \\ell \\cdot C
+$$
 
   Pour résoudre le problème, nous devons réorganiser la formule pour isoler la variable inconnue. En utilisant les valeurs fournies pour $\\varepsilon$, $C$, et $\\ell$, nous pouvons résoudre pour trouver la variable manquante.
 
   Si $A$ est l'absorbance, $\\varepsilon$ est le coefficient d'absorption molaire, $C$ est la concentration et $\\ell$ est la longueur du trajet optique, alors:
 
-  ${targetVariable.name === "concentration"
-        ? "$$C = \\frac{A}{\\varepsilon \\cdot \\ell}$$"
+$$
+${targetVariable.name === "concentration"
+        ? "C = \\frac{A}{\\varepsilon \\cdot \\ell}"
         : ""}
-  ${targetVariable.name === "molarAbsorptivity"
-        ? "$$\\varepsilon = \\frac{A}{C \\cdot \\ell}$$"
+${targetVariable.name === "molarAbsorptivity"
+        ? "\\varepsilon = \\frac{A}{C \\cdot \\ell}"
         : ""}
-  ${targetVariable.name === "pathLength"
-        ? "$$\\ell = \\frac{A}{\\varepsilon \\cdot C}$$"
+${targetVariable.name === "pathLength"
+        ? "\\ell = \\frac{A}{\\varepsilon \\cdot C}"
         : ""}
-  ${targetVariable.name === "absorbance"
-        ? "$$A = \\varepsilon \\cdot C \\cdot \\ell$$"
+${targetVariable.name === "absorbance"
+        ? "A = \\varepsilon \\cdot C \\cdot \\ell"
         : ""}
+$$
 
   En appliquant les valeurs:
 
-  ${targetVariable.name === "concentration"
-        ? `$$C = \\frac{${frenchify(absorbance)}}{${frenchify(molarAbsorptivity)} \\cdot ${frenchify(pathLength)}} = ${frenchify(round(absorbance / (molarAbsorptivity * pathLength), 2))}\\ \\text{mol} \\cdot \\text{L}^{-1}$$`
+$$
+${targetVariable.name === "concentration"
+        ? `C = \\frac{${frenchify(absorbance)}}{${frenchify(molarAbsorptivity)} \\cdot ${frenchify(pathLength)}} = ${frenchify(round(absorbance / (molarAbsorptivity * pathLength), 2))}\\ \\text{mol} \\cdot \\text{L}^{-1}`
+        : ""}
+${targetVariable.name === "molarAbsorptivity"
+        ? `\\varepsilon = \\frac{${frenchify(absorbance)}}{${frenchify(concentration)} \\cdot ${frenchify(pathLength)}} = ${frenchify(round(absorbance / (concentration * pathLength), 1))}\\ \\text{L} \\cdot \\text{mol}^{-1} \\cdot \\text{cm}^{-1}`
         : ""}
-  ${targetVariable.name === "molarAbsorptivity"
-        ? `$$\\varepsilon = \\frac{${frenchify(absorbance)}}{${frenchify(concentration)} \\cdot ${frenchify(pathLength)}} = ${frenchify(round(absorbance / (concentration * pathLength), 1))}\\ \\text{L} \\cdot \\text{mol}^{-1} \\cdot \\text{cm}^{-1}$$`
+${targetVariable.name === "pathLength"
+        ? `\\ell = \\frac{${frenchify(absorbance)}}{${frenchify(molarAbsorptivity)} \\cdot ${frenchify(concentration)}} = ${frenchify(round(absorbance / (molarAbsorptivity * concentration), 1))}\\ \\text{cm}`
         : ""}
-  ${targetVariable.name === "pathLength"
-        ? `$$\\ell = \\frac{${frenchify(absorbance)}}{${frenchify(molarAbsorptivity)} \\cdot ${frenchify(concentration)}} = ${frenchify(round(absorbance / (molarAbsorptivity * concentration), 1))}\\ \\text{cm}$$`
+${targetVariable.name === "absorbance"
+        ? `A = ${frenchify(molarAbsorptivity)} \\cdot ${frenchify(concentration)} \\cdot ${frenchify(pathLength)} = ${frenchify(absorbance)}`
         : ""}
-  ${targetVariable.name === "absorbance"
-        ? `$$A = ${frenchify(molarAbsorptivity)} \\cdot ${frenchify(concentration)} \\cdot ${frenchify(pathLength)} = ${frenchify(absorbance)}$$`
-        : ""}`;
+$$`;
     const question = {
         answer: targetVariable.value.toTree().toTex(),
         instruction,

package/lib/index.d.ts

@@ -49,8 +49,8 @@ declare const mathExercises: (Exercise<{
     rationalNum: [number, number];
     rationalDenum: [number, number];
 }, {}> | Exercise<{
-    rationalNum: [number, number];
-    rationalDenum: [number, number];
+    rationalNum: number[];
+    rationalDenum: number[];
 }, {
     allowNonIrreductible?: boolean;
 }> | Exercise<{
@@ -202,6 +202,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     dec: number;
     pow: number;
+}, {}> | Exercise<{
+    a: number;
+    sign: number;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -396,6 +399,11 @@ declare const mathExercises: (Exercise<{
     e: number;
     f: number;
     g: number;
+}, {}> | Exercise<{
+    xValue: number;
+    a: number;
+    b: number;
+    monomFirst: boolean;
 }, {}> | Exercise<{
     coeffs: number[][];
     isXAsked: boolean;

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":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/latexTester.js

@@ -216,4 +216,6 @@ const validCmds = [
     "\\Large",
     "\\hspace",
     "\\frown",
+    "\\varepsilon",
+    "\\ell",
 ];

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

@@ -32,7 +32,6 @@ export declare class Affine extends Polynomial {
     solve(y: AlgebraicNode | number): AlgebraicNode;
     square(): Trinom;
     times(n: number): Affine;
-    toString(): string;
     toReducedEquation(): string;
     toGGBCommands(): string[];
 }

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

@@ -1 +1 @@
-{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAG3C,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM;IAcT,MAAM,CAAC,gBAAgB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM,EAAE;CAWZ;AAED,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAOxD,OAAO,IAAI,MAAM;IAGjB,KAAK,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM;IAG/B,MAAM,IAAI,MAAM;IAMhB,KAAK,CAAC,CAAC,EAAE,MAAM;IAIf,QAAQ,IAAI,MAAM;IAIlB,iBAAiB,IAAI,MAAM;IAI3B,aAAa;CAGd"}
+{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAG3C,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM;IAcT,MAAM,CAAC,gBAAgB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM,EAAE;CAWZ;AAED,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAOxD,OAAO,IAAI,MAAM;IAGjB,KAAK,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM;IAG/B,MAAM,IAAI,MAAM;IAMhB,KAAK,CAAC,CAAC,EAAE,MAAM;IAIf,iBAAiB,IAAI,MAAM;IAI3B,aAAa;CAGd"}

package/lib/math/polynomials/affine.js

@@ -50,13 +50,10 @@ export class Affine extends Polynomial {
     times(n) {
         return new Affine(this.a * n, this.b * n);
     }
-    toString() {
-        return super.toTex();
-    }
     toReducedEquation() {
         return `y=${this.toTex()}`;
     }
     toGGBCommands() {
-        return [`f(x) = ${this.toString()}`, `SetColor(f, "${randomColor()}")`];
+        return [`f(x) = ${this.toMathString()}`, `SetColor(f, "${randomColor()}")`];
     }
 }

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

@@ -43,6 +43,6 @@ export declare class Polynomial {
     getLimitNode(to: "+\\infty" | "-\\infty"): import("../../tree/nodes/numbers/constantNode.js").ConstantNode | NumberNode;
     toTree(opts?: NodeOptions): AlgebraicNode;
     toTex(): string;
-    toString(): string;
+    toMathString(): string;
 }
 //# sourceMappingURL=polynomial.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"polynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAcpE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAa5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IActD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAoBxB,MAAM,CAAC,4BAA4B,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAqBxB,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,UAAU,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY;CAmCzB;AAED,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY;IAY1D,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAM9B,QAAQ,IAAI,MAAM,EAAE;IAkCpB,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,UAAU;IAyBvC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAQ7B,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAuBnC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU;IAqBnC,QAAQ,IAAI,UAAU;IAOtB,QAAQ,IAAI,UAAU;IAWtB,cAAc,IAAI,UAAU;IAiB5B,eAAe,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BlC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM;IAiB7C,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU;IAiBxC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAuCzB,KAAK,IAAI,MAAM;IAyBf,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"polynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAcpE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAa5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IActD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAoBxB,MAAM,CAAC,4BAA4B,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAqBxB,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,UAAU,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY;CAmCzB;AAED,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY;IAa1D,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAM9B,QAAQ,IAAI,MAAM,EAAE;IAkCpB,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,UAAU;IAyBvC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAQ7B,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAuBnC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU;IAqBnC,QAAQ,IAAI,UAAU;IAOtB,QAAQ,IAAI,UAAU;IAWtB,cAAc,IAAI,UAAU;IAiB5B,eAAe,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BlC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM;IAiB7C,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU;IAiBxC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAuCzB,KAAK,IAAI,MAAM;IA0Bf,YAAY,IAAI,MAAM;CAGvB"}

package/lib/math/polynomials/polynomial.js

@@ -393,7 +393,7 @@ export class Polynomial {
         }
         return s;
     }
-    toString() {
+    toMathString() {
         return this.toTex().replace(/\{/g, "(").replace(/\}/g, ")");
     }
 }

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,UAAU,YAEtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,UAAU,YAGtB,CAAC"}

package/lib/playground.js

@@ -1,3 +1,5 @@
+import { parseAlgebraic } from "./tree/parsers/latexParser.js";
 export const playground = () => {
-    // logIdentifiers();
+    const tex = "\\cos\\left(\\frac{\\pi}{2}\\right)";
+    console.log(parseAlgebraic(tex).simplify().toTex());
 };

package/lib/tree/nodes/algebraicNode.d.ts

@@ -21,5 +21,9 @@ export interface AlgebraicNode extends Node {
     isNumeric: boolean;
     derivative: (varName?: string) => AlgebraicNode;
 }
+export declare abstract class CAlgebraicNode {
+    constructor();
+    private static toString;
+}
 export declare const isAlgebraicNode: (node: Node) => node is AlgebraicNode;
 //# sourceMappingURL=algebraicNode.d.ts.map

package/lib/tree/nodes/algebraicNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AAED,eAAO,MAAM,eAAe,SAAU,IAAI,KAAG,IAAI,IAAI,aACX,CAAC"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AACD,8BAAsB,cAAc;;IAElC,OAAO,CAAC,MAAM,CAAC,QAAQ;CAGxB;AACD,eAAO,MAAM,eAAe,SAAU,IAAI,KAAG,IAAI,IAAI,aACX,CAAC"}

package/lib/tree/nodes/algebraicNode.js

@@ -1 +1,7 @@
+export class CAlgebraicNode {
+    constructor() { }
+    static toString() {
+        throw new Error("Use toTex() instead");
+    }
+}
 export const isAlgebraicNode = (node) => Object(node).hasOwnProperty("isNumeric");

package/lib/tree/nodes/functions/cosNode.js

@@ -58,7 +58,7 @@ export class CosNode {
             if (!trigoPoint)
                 return new CosNode(simplifiedChild);
             else
-                return trigoPoint.sin;
+                return trigoPoint.cos;
         }
         else {
             // Écrire les règles algébriques spécifiques à sin ici

package/lib/tree/nodes/operators/addNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,WAAW,EAIZ,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAerE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MACX,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IACF,WAAW,UAAW,eAAe,aAUnC;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAsJ/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,WAAW,EAIZ,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAerE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MACX,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IACF,WAAW,UAAW,eAAe,aAUnC;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAsJ/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}

package/lib/tree/nodes/operators/limitNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"limitNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/limitNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAG9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAErE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,SAAS,CAAC;IAE5B;;;;;;OAMG;gBAED,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,EAChB,IAAI,CAAC,EAAE,WAAW;IAWpB,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAGhD,aAAa;;;;;;;;;;IAQb,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IAWlC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;IAI/C,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAG/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"limitNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/limitNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAG9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAErE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,SAAS,CAAC;IAE5B;;;;;;OAMG;gBAGD,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,EAChB,IAAI,CAAC,EAAE,WAAW;IAWpB,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAGhD,aAAa;;;;;;;;;;IAQb,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IAWlC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;IAI/C,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAG/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

package/lib/tree/nodes/operators/substractNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"substractNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/substractNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAG9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGrE,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AAED,eAAO,MAAM,SAAS,MACjB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,kBAOnC,CAAC;AAEF,qBAAa,aAAc,YAAW,YAAY;IAChD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB,IAAI,aAAa,EAAE;IAapC,cAAc,IAAI,MAAM,EAAE;IAG1B,kBAAkB;IAIlB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAoBrC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAM/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAMvD,OAAO,aAGL;CACH"}
+{"version":3,"file":"substractNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/substractNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAG9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGrE,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AAED,eAAO,MAAM,SAAS,MACjB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,kBAOnC,CAAC;AAEF,qBAAa,aAAc,YAAW,YAAY;IAChD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB,IAAI,aAAa,EAAE;IAapC,cAAc,IAAI,MAAM,EAAE;IAG1B,kBAAkB;IAIlB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAoBrC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAM/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAMvD,OAAO,aAGL;CACH"}

package/lib/tree/nodes/polynomials/monomNode.d.ts

@@ -1,4 +1,4 @@
-import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
+import { AlgebraicNode, CAlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
 export declare const monom: (a: AlgebraicNode | number | string, degree: number, opts?: MonomNodeOptions) => MonomNode;
 export declare function isMonomNode(a: Node): a is MonomNode;
@@ -10,7 +10,7 @@ type MonomNodeOptions = {
  * un monom est une expression du type ax^degree
  * avec a réel !==0 et degree > 0 (convention)
  */
-export declare class MonomNode implements AlgebraicNode {
+export declare class MonomNode extends CAlgebraicNode implements AlgebraicNode {
     a: AlgebraicNode;
     degree: number;
     isNumeric: boolean;

package/lib/tree/nodes/polynomials/monomNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"monomNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/polynomials/monomNode.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMlE,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,UAC1B,MAAM,SACP,gBAAgB,cAMxB,CAAC;AACF,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,qBAGvC;AACD,KAAK,gBAAgB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAO7C;;;GAGG;AACH,qBAAa,SAAU,YAAW,aAAa;IAC7C,CAAC,EAAE,aAAa,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAkB;gBAG9B,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,gBAAgB;IAUzB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS;IAMvC,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAG/B,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAG7C,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAGhD,YAAY;IAIZ,MAAM;IAMN,KAAK;IAIL,aAAa;;;;;;;;;;CAQd;AAED,eAAO,MAAM,YAAY,SAAU,aAAa,sBAsJ/C,CAAC;AAEF,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,OAAO,SACZ,aAAa,uCACiB,IAAI,YAkJzC,CAAC"}
+{"version":3,"file":"monomNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/polynomials/monomNode.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EACb,cAAc,EACd,eAAe,EAEhB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMlE,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,UAC1B,MAAM,SACP,gBAAgB,cAMxB,CAAC;AACF,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,qBAGvC;AACD,KAAK,gBAAgB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAO7C;;;GAGG;AACH,qBAAa,SAAU,SAAQ,cAAe,YAAW,aAAa;IACpE,CAAC,EAAE,aAAa,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAkB;gBAG9B,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,gBAAgB;IAWzB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS;IAMvC,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAG/B,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAG7C,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAGhD,YAAY;IAIZ,MAAM;IAMN,KAAK;IAIL,aAAa;;;;;;;;;;CAQd;AAED,eAAO,MAAM,YAAY,SAAU,aAAa,sBAsJ/C,CAAC;AAEF,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,OAAO,SACZ,aAAa,uCACiB,IAAI,YAkJzC,CAAC"}

package/lib/tree/nodes/polynomials/monomNode.js

@@ -1,4 +1,4 @@
-import { isAlgebraicNode, } from "../algebraicNode.js";
+import { CAlgebraicNode, isAlgebraicNode, } from "../algebraicNode.js";
 import { isOppositeNode, opposite } from "../functions/oppositeNode.js";
 import { NodeIds, NodeType } from "../node.js";
 import { isMultiplyNode, multiply } from "../operators/multiplyNode.js";
@@ -20,7 +20,7 @@ export function parseToMonomNode(a) {
  * un monom est une expression du type ax^degree
  * avec a réel !==0 et degree > 0 (convention)
  */
-export class MonomNode {
+export class MonomNode extends CAlgebraicNode {
     a;
     degree;
     isNumeric;
@@ -28,6 +28,7 @@ export class MonomNode {
     type = NodeType.monom;
     // roots: AlgebraicNode[];
     constructor(a, degree, opts) {
+        super();
         // super([c, b, a], opts?.variable ?? "x");
         this.a = typeof a === "number" ? a.toTree() : a;
         if (this.a.evaluate() === 0)

package/lib/tree/nodes/polynomials/trinomNode.d.ts

@@ -1,4 +1,4 @@
-import { AlgebraicNode, SimplifyOptions } from "../../../tree/nodes/algebraicNode.js";
+import { AlgebraicNode, CAlgebraicNode, SimplifyOptions } from "../../../tree/nodes/algebraicNode.js";
 import { NodeIds, NodeOptions, NodeType } from "../../../tree/nodes/node.js";
 import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
 export declare abstract class TrinomNodeConstructor {
@@ -43,7 +43,7 @@ export type TrinomNodeIdentifiers = {
 type TrinomNodeOptions = {
     variable: string;
 };
-export declare class TrinomNode implements AlgebraicNode {
+export declare class TrinomNode extends CAlgebraicNode implements AlgebraicNode {
     a: AlgebraicNode;
     b: AlgebraicNode;
     c: AlgebraicNode;

package/lib/tree/nodes/polynomials/trinomNode.d.ts.map

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

package/lib/tree/nodes/polynomials/trinomNode.js

@@ -5,6 +5,7 @@ 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 { opposite } from "../../../tree/nodes/functions/oppositeNode.js";
+import { CAlgebraicNode, } from "../../../tree/nodes/algebraicNode.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { random } from "../../../utils/alea/random.js";
 import { NodeIds, NodeType } from "../../../tree/nodes/node.js";
@@ -61,7 +62,7 @@ export class TrinomNodeConstructor {
             : NodeConstructor.fromIdentifiers(identifiers.c), identifiers.opts);
     }
 }
-export class TrinomNode {
+export class TrinomNode extends CAlgebraicNode {
     a;
     b;
     c;
@@ -70,6 +71,7 @@ export class TrinomNode {
     type = NodeType.trinom;
     // roots: AlgebraicNode[];
     constructor(a, b, c, opts) {
+        super();
         // super([c, b, a], opts?.variable ?? "x");
         this.a = typeof a === "number" ? a.toTree() : a;
         this.b = typeof b === "number" ? b.toTree() : b;

package/lib/tree/nodes/variables/variableNode.d.ts

@@ -1,7 +1,7 @@
-import { AlgebraicNode } from "../algebraicNode.js";
+import { AlgebraicNode, CAlgebraicNode } from "../algebraicNode.js";
 import { Node, NodeIds, NodeType } from "../node.js";
 export declare function isVariableNode(a: Node): a is VariableNode;
-export declare class VariableNode implements AlgebraicNode {
+export declare class VariableNode extends CAlgebraicNode implements AlgebraicNode {
     name: string;
     type: NodeType;
     isNumeric: boolean;

package/lib/tree/nodes/variables/variableNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variableNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/variables/variableNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAErD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,WAAqB;IACzB,SAAS,EAAE,OAAO,CAAC;gBACP,IAAI,EAAE,MAAM;IAIxB,aAAa;;;;IAMb,KAAK,IAAI,MAAM;IAGf,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,cAAc;IAGd,iBAAiB;IAIjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQtC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAKxD"}
+{"version":3,"file":"variableNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/variables/variableNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAErD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,SAAQ,cAAe,YAAW,aAAa;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,WAAqB;IACzB,SAAS,EAAE,OAAO,CAAC;gBACP,IAAI,EAAE,MAAM;IAMxB,aAAa;;;;IAMb,KAAK,IAAI,MAAM;IAGf,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,cAAc;IAGd,iBAAiB;IAIjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQtC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAKxD"}

package/lib/tree/nodes/variables/variableNode.js

@@ -1,12 +1,14 @@
+import { CAlgebraicNode } from "../algebraicNode.js";
 import { NodeIds, NodeType } from "../node.js";
 export function isVariableNode(a) {
     return a.type === NodeType.variable;
 }
-export class VariableNode {
+export class VariableNode extends CAlgebraicNode {
     name;
     type = NodeType.variable;
     isNumeric;
     constructor(name) {
+        super();
         this.name = name;
         this.isNumeric = false;
     }

package/lib/utils/alea/probaLawFlip.js

@@ -7,11 +7,11 @@ export const probaLawFlip = (arr) => {
     if (Math.abs(arr.reduce((acc, curr) => (acc += curr[1]), 0) - 1) > 0.1)
         throw Error("proba law does not add up t 1");
     const rand = Math.random();
-    const sorted = [...arr].sort((a, b) => b[1] - a[1]);
+    // const sorted = [...arr].sort((a, b) => b[1] - a[1]);
     let probaAcc = 0;
     let i = 0;
     while (i < arr.length - 1) {
-        probaAcc += sorted[i][1];
+        probaAcc += arr[i][1];
         if (rand < probaAcc)
             return arr[i][0];
         i++;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.13",
+  "version": "3.0.15",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [