math-exercises 3.0.38 → 3.0.39

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductViaCos.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAyDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"scalarProductViaCos.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA4EF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.js

@@ -7,26 +7,41 @@ import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.j
 import { randomLetter } from "../../../../../utils/strings/randomLetter.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
 import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 //|u| |v| cos(u,v)
+const getInstruction = (identifiers) => {
+    const { AB, AC, trigoPoint, letters } = identifiers;
+    const [letterA, letterB, letterC] = letters;
+    const trigo = mainTrigoValues.find((v) => v.point === trigoPoint);
+    return `Soient trois points $${letterA}$, $${letterB}$ et $${letterC}$ tels que $${letterA}${letterB} = ${AB}$, $${letterA}${letterC}= ${AC}$, et $\\widehat{${letterB}${letterA}${letterC}} = ${trigo.angle.toTex()}$. 
+  
+Calculer le produit scalaire $\\overrightarrow{${letterA}${letterB}}\\cdot \\overrightarrow{${letterA}${letterC}}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { AB, AC, trigoPoint } = identifiers;
+    const trigo = mainTrigoValues.find((v) => v.point === trigoPoint);
+    const answer = new MultiplyNode(new NumberNode(AB * AC), trigo.cos)
+        .simplify()
+        .toTex();
+    return answer;
+};
 const getScalarProductViaCosQuestion = () => {
     const AB = randint(1, 10);
     const AC = randint(1, 10);
     const trigo = random(mainTrigoValues);
-    const answer = new MultiplyNode(new NumberNode(AB * AC), trigo.cos)
-        .simplify()
-        .toTex();
     const letters = [];
     for (let i = 0; i < 3; i++) {
         letters.push(randomLetter(true, letters));
     }
     letters.sort((a, b) => a.localeCompare(b));
-    const [letterA, letterB, letterC] = letters;
+    const identifiers = { AB, AC, trigoPoint: trigo.point, letters };
     const question = {
-        answer,
-        instruction: `Soient trois points $${letterA}$, $${letterB}$ et $${letterC}$ tels que $${letterA}${letterB} = ${AB}$, $${letterA}${letterC}= ${AC}$, et $\\widehat{${letterB}${letterA}${letterC}} = ${trigo.angle.toTex()}$. Calculer $\\overrightarrow{${letterA}${letterB}}\\cdot \\overrightarrow{${letterA}${letterC}}$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["pi"],
         answerFormat: "tex",
-        identifiers: { AB, AC, trigoPoint: trigo.point },
+        identifiers,
     };
     return question;
 };
@@ -42,23 +57,26 @@ const getPropositions = (n, { answer, AB, AC, trigoPoint }) => {
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { AB, AC, trigoPoint }) => {
-    const trigo = remarkableTrigoValues.find((v) => v.point === trigoPoint);
-    const tree = new MultiplyNode(new NumberNode(AB * AC), trigo.cos).simplify();
-    const texs = tree.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, AB, AC, trigoPoint }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const scalarProductViaCos = {
     id: "scalarProductViaCos",
     connector: "=",
     label: "Calculer un produit scalaire (formule avec $cos$)",
-    levels: ["1reSpé"],
     isSingleStep: true,
-    sections: ["Vecteurs", "Produit scalaire"],
     generator: (nb) => getDistinctQuestions(getScalarProductViaCosQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
 };

package/lib/exercises/math/probaStat/diceBasicProbas.js

@@ -36,7 +36,7 @@ Puisque le dé est équilibré, chaque face du dé a autant de chances d'appara
 Ainsi, la probabilité d'obtenir une face ${parity} est :
 
 $$
-${frac(count, nbFaces).toSimplificationString()}
+${frac(count, nbFaces).toSimplificationTex()}
 $$`;
     }
     else {

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

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindReason.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindReason.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAiCF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}
+{"version":3,"file":"arithmeticFindReason.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindReason.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAoEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAgBtD,CAAC"}

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

@@ -1,21 +1,53 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { rank1, value1, reason } = identifiers;
+    const rank2 = rank1 + 1;
+    const value2 = reason + value1;
+    return `Soit $u$ une suite arithmétique telle que $u_{${rank1}} = ${value1}$ et $u_{${rank2}} = ${value2}$. 
+  
+Quelle est la raison de la suite $(u_n)$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { rank1, value1, reason } = identifiers;
+    const answer = reason + "";
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `La raison d'une suite arithmétique est le nombre par lequel on additionne un terme pour obtenir le suivant.`;
+};
+const getCorrection = (identifiers) => {
+    const { rank1, value1, reason } = identifiers;
+    const rank2 = rank1 + 1;
+    const value2 = reason + value1;
+    return `La raison de $u$ est le nombre par lequel on a additionné $u_{${rank1}}$ pour obtenir $u_{${rank2}}$. 
+  
+Ainsi, la raison $r$ de la suite $u$ est : 
+
+${alignTex([
+        ["r", "=", `u_{${rank2}} - u_{${rank1}}`],
+        ["", "=", substract(value2, value1).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getArithmeticFindReason = () => {
     const rank1 = randint(0, 10);
-    const rank2 = rank1 + 1;
     const reason = randint(-10, 10, [0]);
     const value1 = randint(-10, 10);
-    const value2 = reason + value1;
-    const answer = reason + "";
+    const identifiers = { rank1, reason, value1 };
     const question = {
-        instruction: `$(u_n)$ est une suite arithmétique. On sait que $u_{${rank1}} = ${value1}$ et $u_{${rank2}} = ${value2}$. Quelle est la raison de la suite $(u_n)$ ?`,
+        instruction: getInstruction(identifiers),
         startStatement: "r",
-        answer,
+        answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { rank1, reason, value1 },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -34,8 +66,6 @@ export const arithmeticFindReason = {
     id: "arithmeticFindReason",
     connector: "=",
     label: "Déterminer la raison d'une suite arithmétique",
-    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
-    sections: ["Suites"],
     isSingleStep: false,
     getPropositions,
     isAnswerValid,
@@ -43,4 +73,9 @@ export const arithmeticFindReason = {
     freeTimer: 60,
     generator: (nb) => getDistinctQuestions(getArithmeticFindReason, nb),
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindReasonRandomRange.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindReasonRandomRange.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmCF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}
+{"version":3,"file":"arithmeticFindReasonRandomRange.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindReasonRandomRange.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmCF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAYjE,CAAC"}

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

@@ -34,8 +34,6 @@ export const arithmeticFindReasonRandomRange = {
     id: "arithmeticFindReasonRandomRange",
     connector: "=",
     label: "Déterminer la raison d'une suite arithmétique (écart aléatoire)",
-    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
-    sections: ["Suites"],
     isSingleStep: false,
     getPropositions,
     isAnswerValid,

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

@@ -1 +1 @@
-{"version":3,"file":"arithmeticReasonUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAoCF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}
+{"version":3,"file":"arithmeticReasonUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA2EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

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

@@ -1,20 +1,60 @@
 import { addValidProp, 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 { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getStartStatement = (identifiers) => {
+    const { reason, startRank, startValue } = identifiers;
+    const askedRank = startRank + 1;
+    return `u_{${askedRank}}`;
+};
+const getInstruction = (identifiers) => {
+    const { reason, startRank, startValue } = identifiers;
+    const askedRank = startRank + 1;
+    return `Soit $u$ une suite arithmétique de raison $r = ${reason}$ et telle que $u_{${startRank}} = ${startValue}$. 
+  
+Calculer $u_{${askedRank}}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { reason, startRank, startValue } = identifiers;
+    const answer = (startValue + reason).toString();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { reason, startRank, startValue } = identifiers;
+    return `Une suite arithmétique est une suite telle que, pour passer d'un terme de la suite au suivant, on additionne toujours par la raison de la suite.
+  
+En d'autres termes, si $u$ est une suite arithmétique de raison $r$, alors pour tout entier $n$, on a : 
+
+$$
+u_{n+1} = u_n + r
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { reason, startRank, startValue } = identifiers;
+    return `Puisque $u$ est une suite arithmétique, on a : 
+  
+${alignTex([
+        [getStartStatement(identifiers), "=", add(`u_{${startRank}}`, "r").toTex()],
+        ["", "=", add(startValue, reason).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getArithmeticReasonUsage = () => {
     const reason = randint(-10, 10, [0]);
     const startRank = randint(0, 20);
-    const askedRank = startRank + 1;
     const startValue = randint(-10, 10);
-    const answer = (startValue + reason).toString();
+    const identifiers = { reason, startRank, startValue };
     const question = {
-        instruction: `$(u_n)$ est une suite arithmétique de raison $r = ${reason}$ et on sait que $u_{${startRank}} = ${startValue}$. Calculer : $u_{${askedRank}}$`,
-        startStatement: `u_{${askedRank}}`,
-        answer,
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
         keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
-        identifiers: { reason, startRank, startValue },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -38,8 +78,6 @@ export const arithmeticReasonUsage = {
     id: "arithmeticReasonUsage",
     connector: "=",
     label: "Utiliser la raison d'une suite arithmétique",
-    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
-    sections: ["Suites"],
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getArithmeticReasonUsage, nb),
     qcmTimer: 60,
@@ -47,4 +85,9 @@ export const arithmeticReasonUsage = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

package/lib/geogebra/geogebraConstructor.d.ts

@@ -8,6 +8,8 @@ type GetAdaptedCoords = {
     zMin?: number;
     zMax?: number;
     forceShowAxes?: boolean;
+    minCoords?: number[];
+    ratio?: number;
 };
 type GetOptionsProps = {
     coords: number[];
@@ -33,7 +35,7 @@ export declare class GeogebraConstructor {
     hideFullScreenButton?: boolean;
     constructor(options: Omit<GeogebraOptions, "coords">);
     getCoordsForPoints(points: Point[]): number[];
-    getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }: GetAdaptedCoords): number[];
+    getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, minCoords, ratio, }: GetAdaptedCoords): number[];
     getOptions({ coords }: GetOptionsProps): GeogebraOptions;
 }
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;gBACnB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAoBpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAiDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAuBzD"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;gBACnB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAoBpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,EACb,SAAS,EACT,KAAK,GACN,EAAE,gBAAgB;IAsDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAuBzD"}

package/lib/geogebra/geogebraConstructor.js

@@ -45,11 +45,11 @@ export class GeogebraConstructor {
         const yMax = Math.max(...points.map((p) => p.y.evaluate()));
         return this.getAdaptedCoords({ xMin, xMax, yMin, yMax });
     }
-    getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }) {
+    getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, minCoords, ratio, }) {
         const showAxes = forceShowAxes ?? (this.hideAxes ? false : true);
         const xDelta = xMax - xMin;
         const yDelta = yMax - yMin;
-        const coeff = 0.1;
+        const coeff = ratio ?? 0.1;
         if (this.is3D && zMin !== undefined && zMax !== undefined) {
             const zDelta = zMax - zMin;
             const coords = [
@@ -91,6 +91,9 @@ export class GeogebraConstructor {
                 coords[2] = Math.min(-1, coords[2]);
                 coords[3] = Math.max(1, coords[3]);
             }
+            if (minCoords) {
+                return coords.map((coord, index) => (index % 2 === 0 ? Math.min : Math.max)(minCoords[index], coord));
+            }
             return coords;
         }
     }

package/lib/index.d.ts

@@ -178,7 +178,9 @@ declare const mathExercises: (Exercise<{
     precisionAsked: number;
     decimal: number;
     precision: number;
-}, {}> | Exercise<{
+}, {
+    precisionAsked: number;
+}> | Exercise<{
     nb: number;
     rankAsked: number;
 }, {}> | Exercise<{
@@ -1192,6 +1194,7 @@ declare const mathExercises: (Exercise<{
     AB: number;
     AC: number;
     trigoPoint: string;
+    letters: string[];
 }, {}> | Exercise<{
     c: number;
     vec1Name: string;
@@ -2023,6 +2026,7 @@ declare const pcExercises: (Exercise<{
     AB: number;
     AC: number;
     trigoPoint: string;
+    letters: string[];
 }, {}> | Exercise<{
     total: number;
     lefties: number;

package/lib/index.d.ts.map

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

package/lib/latexTester.js

@@ -225,4 +225,5 @@ const validCmds = [
     "\\frown",
     "\\varepsilon",
     "\\ell",
+    "\\cancel",
 ];

package/lib/math/numbers/integer/integer.d.ts

@@ -15,7 +15,7 @@ export declare class Integer implements Nombre {
     constructor(value: number, tex?: string);
     equals(n: Nombre): boolean;
     toTree(): NumberNode;
-    times(n: number | Nombre): Decimal | Integer;
+    times(n: number | Nombre): Integer | Decimal;
     round(precision: number): Integer;
     divide(nb: Nombre): Nombre;
     multiply(nb: Nombre): Rational | Integer;

package/lib/math/numbers/rationals/rational.d.ts

@@ -22,6 +22,7 @@ export declare class Rational implements Nombre {
     isSimplified: boolean;
     type: NumberType;
     constructor(numerator: number, denumerator: number);
+    toArray(): number[];
     equals(n: Nombre): boolean;
     toTex(): string;
     add(nb: Nombre): Nombre;

package/lib/math/numbers/rationals/rational.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAQ,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAQ7D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAElD,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CACvB,GAAG,GAAE,MAAW,EAChB,EAAE,UAAkB,EAAE,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO;IASvD,MAAM,CAAC,uBAAuB,CAAC,QAAQ,GAAE,MAAW;IAKpD,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;IAQlD,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;CAO3C;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,OAAO,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM;IAIxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa;IAgBzC,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAqB/B"}
+{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAQ,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAQ7D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAElD,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CACvB,GAAG,GAAE,MAAW,EAChB,EAAE,UAAkB,EAAE,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO;IASvD,MAAM,CAAC,uBAAuB,CAAC,QAAQ,GAAE,MAAW;IAKpD,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;IAQlD,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;CAO3C;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,OAAO;IAGP,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,OAAO,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM;IAIxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa;IAgBzC,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAqB/B"}

package/lib/math/numbers/rationals/rational.js

@@ -74,6 +74,9 @@ export class Rational {
         this.tex = `${this.num < 0 ? "-" : ""}\\frac{${this.num < 0 ? -this.num : this.num}}{${this.denum}}`;
         this.type = NumberType.Rational;
     }
+    toArray() {
+        return [this.num, this.denum];
+    }
     equals(n) {
         return this.value === n.value;
     }

package/lib/math/utils/stats/generateAffineCloud.js

@@ -12,7 +12,7 @@ export const generateAffineCloud = (n) => {
         }
         generatedXs.add(x);
         let noise = Math.random() * 100;
-        let y = round(slope * x + intercept + noise, 2);
+        let y = round(slope * x + intercept + noise, 0);
         data.push({ x, y });
     }
     return data;

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,UAAU,YAKtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,UAAU,YAMtB,CAAC"}

package/lib/playground.js

@@ -1,7 +1,9 @@
-import { RemarkableValueConstructor } from "./math/trigonometry/remarkableValue.js";
+import { multiply } from "./tree/nodes/operators/multiplyNode.js";
+import { substract } from "./tree/nodes/operators/substractNode.js";
 export const playground = () => {
     // const tex = "3\\%";
     // console.log(parseAlgebraic(tex).simplify({}).toTex());
-    const simp = RemarkableValueConstructor.simplifiable();
-    console.log(simp.angle.toTex());
+    const x = multiply(3, substract("x", 9));
+    console.log(x.simplify().toTex());
+    console.log(x.equals(x.simplify()));
 };

package/lib/tests/pdfExo.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pdfExo.test.d.ts","sourceRoot":"","sources":["../../src/tests/pdfExo.test.ts"],"names":[],"mappings":"AAeA,OAAO,6BAA6B,CAAC"}
+{"version":3,"file":"pdfExo.test.d.ts","sourceRoot":"","sources":["../../src/tests/pdfExo.test.ts"],"names":[],"mappings":"AAgBA,OAAO,6BAA6B,CAAC"}

package/lib/tests/pdfExo.test.js

@@ -1,8 +1,8 @@
-import { extractPointFromParametricLine, } from "../exercises/math/index.js";
+import { factorizedFormFromRoots, } from "../exercises/math/index.js";
 import { buildPdfForExercise } from "./pdfs/buildPDFForExercise.js";
 import "../prototypesEnhancement.js";
 try {
-    buildPdfForExercise(extractPointFromParametricLine);
+    buildPdfForExercise(factorizedFormFromRoots);
 }
 catch (err) {
     console.log(err);

package/lib/tree/nodes/functions/oppositeNode.d.ts

@@ -1,6 +1,5 @@
 import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
 import { FunctionNode, FunctionsIds } from "./functionNode.js";
-import { NumberNode } from "../numbers/numberNode.js";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 export declare function isOppositeNode(a: Node): a is OppositeNode;
 export declare const opposite: <T extends AlgebraicNode = AlgebraicNode>(a: T | number | string) => OppositeNode<T>;
@@ -27,7 +26,7 @@ export declare class OppositeNode<T extends AlgebraicNode = AlgebraicNode> imple
      */
     toAllValidTexs(opts?: NodeOptions): string[];
     evaluate(vars?: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): AlgebraicNode | NumberNode;
+    simplify(opts?: SimplifyOptions): AlgebraicNode;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): OppositeNode<AlgebraicNode>;
     derivative(varName?: string | undefined): AlgebraicNode;

package/lib/tree/nodes/functions/oppositeNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMlE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAgB,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAIrE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,aAAa,qBAC3C,CAAC,GAAG,MAAM,GAAG,MAAM,oBAKvB,CAAC;AAEF,qBAAa,YAAY,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,CAC/D,YAAW,YAAY,CAAC,CAAC,CAAC;IAE1B,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;IACT,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW;IAQxC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAK/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMlE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAE/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAIrE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,aAAa,qBAC3C,CAAC,GAAG,MAAM,GAAG,MAAM,oBAKvB,CAAC;AAEF,qBAAa,YAAY,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,CAC/D,YAAW,YAAY,CAAC,CAAC,CAAC;IAE1B,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;IACT,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW;IAQxC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAK/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

package/lib/tree/nodes/functions/sqrtNode.d.ts

@@ -21,9 +21,10 @@ export declare class SqrtNode implements FunctionNode {
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
     toAllValidTexs(opts?: NodeOptions): string[];
     evaluate(vars?: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): AlgebraicNode;
+    simplify(opts?: SimplifyOptions, steps?: AlgebraicNode[]): AlgebraicNode;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): SqrtNode;
     derivative(varName?: string | undefined): AlgebraicNode;
+    toSimplificationTex(opts?: SimplifyOptions): void;
 }
 //# sourceMappingURL=sqrtNode.d.ts.map

package/lib/tree/nodes/functions/sqrtNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAK/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKrE,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AAED,eAAO,MAAM,IAAI,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,aAItD,CAAC;AAEF,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAMtB,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAwBtD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAyC/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAK/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAMrE,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AAED,eAAO,MAAM,IAAI,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,aAItD,CAAC;AAEF,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAMtB,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAwBtD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE,aAAa,EAAE;IA2CxD,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAGvD,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;CAI3C"}

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

@@ -69,12 +69,13 @@ export class SqrtNode {
     evaluate(vars) {
         return Math.sqrt(this.child.evaluate(vars));
     }
-    simplify(opts) {
+    simplify(opts, steps) {
         const simplifiedChild = this.child.simplify(opts);
         const copy = new SqrtNode(simplifiedChild, this.opts);
+        if (steps && !this.child.equals(simplifiedChild))
+            steps.push(copy);
         const externals = [];
         //ex [3, x^2] pour sqrt(3x^2)
-        //TODO fractions
         const recursive = (node) => {
             if (isMultiplyNode(node)) {
                 recursive(node.leftChild);
@@ -120,4 +121,48 @@ export class SqrtNode {
     derivative(varName) {
         throw new Error("unimplemented derivative");
     }
+    toSimplificationTex(opts) {
+        const nodes = [this];
+        const simp = this.simplify(opts, nodes);
+    }
 }
+// const simplifyInteger = (a: number)=>{
+//     if (a === 0) return 0..toTree()
+//       if (a === 1) return 1..toTree();
+//       const [outsideSqrt, insideSqrt] = this.getSimplifiedCoeffs();
+//       const simplified =
+//         insideSqrt !== 1
+//           ? new Real(
+//               outsideSqrt * Math.sqrt(insideSqrt),
+//               `${outsideSqrt === 1 ? "" : `${outsideSqrt}`}\\sqrt{${insideSqrt}}`,
+//             )
+//           : new Real(outsideSqrt, outsideSqrt + "");
+//       simplified.toTree = (): AlgebraicNode => {
+//         return insideSqrt !== 1
+//           ? outsideSqrt === 1
+//             ? new SqrtNode(new NumberNode(insideSqrt))
+//             : new MultiplyNode(
+//                 new NumberNode(outsideSqrt),
+//                 new SqrtNode(new NumberNode(insideSqrt)),
+//               )
+//           : new NumberNode(outsideSqrt);
+//       };
+//       return simplified;
+// }
+// const getMaxSquareAndRest = (a: number)=> {
+//     if (a === 0) return [1, 0];
+//     const factors = primeFactors( a);
+//     // finds primes with even exponents
+//     const multiples = [1];
+//     for (let i = 0; i < factors.length - 1; i++) {
+//       if (factors[i] === factors[i + 1]) {
+//         multiples.push(factors[i]);
+//         factors.splice(i, 2);
+//         i--;
+//       }
+//     }
+//     const maxSquare = multiples.reduce((x, y) => x * y);
+//     const insideSqrt =
+//       factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
+//     return [maxSquare, insideSqrt];
+//   }

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

@@ -42,6 +42,7 @@ export type ToTexOptions = {
     color?: string;
     noPropagation?: boolean;
     unit?: string;
+    cancel?: boolean;
 };
 export declare enum NodeIds {
     add = 0,

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

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,UAAU,IAAA;IACV,KAAK,IAAA;IACL,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,OAAO,IAAA;IACP,MAAM,KAAA;IACN,GAAG,KAAA;IACH,MAAM,KAAA;IACN,KAAK,KAAA;IACL,OAAO,KAAA;CACR;AACD,MAAM,MAAM,WAAW,GAAG;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,oBAAY,OAAO;IACjB,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;IACL,KAAK,IAAA;IACL,MAAM,IAAA;IACN,OAAO,IAAA;IACP,QAAQ,IAAA;IACR,QAAQ,KAAA;IACR,OAAO,KAAA;IACP,WAAW,KAAA;IACX,QAAQ,KAAA;IACR,KAAK,KAAA;IACL,OAAO,KAAA;IACP,KAAK,KAAA;IACL,UAAU,KAAA;IACV,gBAAgB,KAAA;IAChB,GAAG,KAAA;IACH,MAAM,KAAA;IACN,MAAM,KAAA;IACN,MAAM,KAAA;IACN,GAAG,KAAA;IACH,GAAG,KAAA;IACH,GAAG,KAAA;IACH,GAAG,KAAA;IACH,KAAK,KAAA;IACL,GAAG,KAAA;IACH,IAAI,KAAA;IACJ,QAAQ,KAAA;IACR,QAAQ,KAAA;IACR,MAAM,KAAA;IACN,MAAM,KAAA;IACN,KAAK,KAAA;IACL,MAAM,KAAA;IACN,UAAU,KAAA;IACV,kBAAkB,KAAA;IAClB,mBAAmB,KAAA;IACnB,MAAM,KAAA;IACN,KAAK,KAAA;CACN;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,EAAE,CAAC;IAClD,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,MAAM,EAAE,CAAC;IACjD,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,YAAY,KAAK,MAAM,CAAC;IAEvC,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,aAAa,EAAE,MAAM;QAAE,EAAE,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5D"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"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"}

package/lib/tree/nodes/numbers/numberNode.d.ts

@@ -24,7 +24,7 @@ export declare class NumberNode implements AlgebraicNode {
     toAllValidTexs(): string[];
     toEquivalentNodes(): this[];
     evaluate(vars?: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): AlgebraicNode | NumberNode;
+    simplify(opts?: SimplifyOptions): AlgebraicNode;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): this;
     derivative(varName?: string | undefined): AlgebraicNode;