math-exercises 3.0.50 → 3.0.52

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

@@ -47,12 +47,12 @@ const getFractionsOperationsQuestion = (ops) => {
         RationalConstructor.randomIrreductible().toTree(),
         RationalConstructor.randomIrreductible().toTree(),
     ];
-    const statement = firstOp(secondOp(rationals[0], rationals[1]), rationals[2]);
+    let statement = firstOp(secondOp(rationals[0], rationals[1]), rationals[2]);
     //éviter division par une soustraction qui donne 0
     if (firstOpIndex !== 3 ||
         secondOpIndex !== 1 ||
         rationals[0].evaluate() - rationals[1].evaluate() !== 0) {
-        statement.shuffle();
+        statement = statement.shuffle();
     }
     const ids = statement.toIdentifiers();
     const identifiers = {

package/lib/exercises/math/calcul/mentalCaluls/mentalAddAndSub.js

@@ -27,7 +27,7 @@ const getMentalAddAndSub = () => {
     let statementTree = new AddNode(allNumbersNodes[0], allNumbersNodes[1]);
     for (let i = 2; i < nbrOperations; i++)
         statementTree = new AddNode(statementTree, allNumbersNodes[i]);
-    statementTree.shuffle();
+    statementTree = statementTree.shuffle();
     const statement = statementTree.toTex();
     const answer = (round(sum, 2) + "").replace(".", ",");
     const question = {

package/lib/exercises/math/calcul/mentalCaluls/mentalMultiplications.js

@@ -36,7 +36,7 @@ const getMentalMultiplications = () => {
         statementTree = new MultiplyNode(allNumbersNodes[0], new MultiplyNode(allNumbersNodes[1], allNumbersNodes[2]));
         answer = numbers[0] * numbers[1] * numbers[2];
     }
-    statementTree.shuffle();
+    statementTree = statementTree.shuffle();
     const statementTex = statementTree.toTex();
     const answerTex = round(answer, 2).frenchify();
     const question = {

package/lib/exercises/math/calcul/operations/expressionNature.js

@@ -24,8 +24,7 @@ const getExpressionNatureQuestion = () => {
             switch (subType) {
                 case 1:
                     //ab+c
-                    node = new AddNode(new MultiplyNode(a, b), c);
-                    node.shuffle();
+                    node = new AddNode(new MultiplyNode(a, b), c).shuffle();
                     break;
                 case 2:
                     //ab + cd
@@ -33,13 +32,11 @@ const getExpressionNatureQuestion = () => {
                     break;
                 case 3:
                     //a/b + c
-                    node = new AddNode(new DivideNode(a, b), c);
-                    node.shuffle();
+                    node = new AddNode(new DivideNode(a, b), c).shuffle();
                     break;
                 case 4:
                     //ab + c/d
-                    node = new AddNode(new MultiplyNode(a, b), new DivideNode(c, d));
-                    node.shuffle();
+                    node = new AddNode(new MultiplyNode(a, b), new DivideNode(c, d)).shuffle();
                     break;
                 case 5:
                     //a/b + c/d
@@ -84,13 +81,11 @@ const getExpressionNatureQuestion = () => {
             switch (subType) {
                 case 1:
                     //(a+b)*c
-                    node = new MultiplyNode(new AddNode(a, b), c);
-                    node.shuffle();
+                    node = new MultiplyNode(new AddNode(a, b), c).shuffle();
                     break;
                 case 2:
                     //(a-b)*c
-                    node = new MultiplyNode(new SubstractNode(a, b), c);
-                    node.shuffle();
+                    node = new MultiplyNode(new SubstractNode(a, b), c).shuffle();
                     break;
                 case 3:
                     //(a+b)(c+d)
@@ -98,8 +93,7 @@ const getExpressionNatureQuestion = () => {
                     break;
                 case 4:
                     //(a+b)(c-d)
-                    node = new MultiplyNode(new AddNode(a, b), new SubstractNode(c, d));
-                    node.shuffle();
+                    node = new MultiplyNode(new AddNode(a, b), new SubstractNode(c, d)).shuffle();
                     break;
                 case 5:
                     //(a-b)(c-d)

package/lib/exercises/math/calcul/operations/operationsPriorities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operationsPriorities.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/operationsPriorities.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AAmJF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}
+{"version":3,"file":"operationsPriorities.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/operationsPriorities.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AAkJF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}

package/lib/exercises/math/calcul/operations/operationsPriorities.js

@@ -29,7 +29,7 @@ const getPriorityQuestions = () => {
                     new AddNode(new MultiplyNode(new NumberNode(a), new NumberNode(b)), new AddNode(new NumberNode(c), new NumberNode(d)))
                 : //a*b middle
                     new AddNode(new AddNode(new NumberNode(c), new MultiplyNode(new NumberNode(a), new NumberNode(b))), new NumberNode(d));
-            statement.shuffle();
+            statement = statement.shuffle();
             startStatement = statement.toTex();
             answer = (a * b + c + d).toString();
             break;
@@ -41,7 +41,7 @@ const getPriorityQuestions = () => {
                     new AddNode(new DivideNode(new NumberNode(a), new NumberNode(b)), new AddNode(new NumberNode(c), new NumberNode(d)))
                 : //a/b middle
                     new AddNode(new AddNode(new NumberNode(c), new DivideNode(new NumberNode(a), new NumberNode(b))), new NumberNode(d));
-            statement.shuffle();
+            statement = statement.shuffle();
             startStatement = statement.toTex();
             answer = (a / b + c + d).toString();
             break;
@@ -56,7 +56,7 @@ const getPriorityQuestions = () => {
             d = randint(-10, 11, [0]);
             c = d * randint(0, 11);
             statement = new AddNode(new MultiplyNode(new NumberNode(a), new NumberNode(b)), new DivideNode(new NumberNode(c), new NumberNode(d)));
-            statement.shuffle();
+            statement = statement.shuffle();
             startStatement = statement.toTex();
             answer = (a * b + c / d).toString();
             break;
@@ -71,7 +71,7 @@ const getPriorityQuestions = () => {
         case 6: // a*b*c ± d
             [a, b, c, d] = [1, 2, 3, 4].map((el) => randint(-10, 11, [0]));
             statement = new AddNode(new MultiplyNode(new MultiplyNode(new NumberNode(a), new NumberNode(b)), new NumberNode(c)), new NumberNode(d));
-            statement.shuffle();
+            statement = statement.shuffle();
             startStatement = statement.toTex();
             answer = (a * b * c + d).toString();
             break;
@@ -79,8 +79,7 @@ const getPriorityQuestions = () => {
             b = randint(2, 10);
             a = b * randint(2, 10);
             c = randint(2, 10);
-            statement = new MultiplyNode(new DivideNode(a.toTree(), b.toTree()), c.toTree());
-            statement.shuffle();
+            statement = new MultiplyNode(new DivideNode(a.toTree(), b.toTree()), c.toTree()).shuffle();
             answer = ((a / b) * c).frenchify();
             startStatement = statement.toTex();
             break;

package/lib/exercises/math/calcul/operations/operationsPrioritiesParenthesis.js

@@ -15,8 +15,7 @@ const getOperationsPrioritiesParenthesisQuestion = () => {
         case 1: //a*(b+-c)
             a = randint(-10, 11, [0, 1, -1]);
             [b, c] = [1, 2].map((el) => randint(-10, 11, [0]));
-            statement = new MultiplyNode(a.toTree(), new AddNode(b.toTree(), c.toTree()), { forceTimesSign: true });
-            statement.shuffle();
+            statement = new MultiplyNode(a.toTree(), new AddNode(b.toTree(), c.toTree()), { forceTimesSign: true }).shuffle();
             answer = (a * (b + c)).frenchify();
             break;
         case 2: //a/(b+-c) ou (b+-c)/a

package/lib/exercises/math/calcul/operations/operationsPrioritiesParenthesisNoRelatives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operationsPrioritiesParenthesisNoRelatives.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/operationsPrioritiesParenthesisNoRelatives.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,GAAG,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAoIF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAkB1E,CAAC"}
+{"version":3,"file":"operationsPrioritiesParenthesisNoRelatives.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/operationsPrioritiesParenthesisNoRelatives.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,GAAG,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAmIF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAkB1E,CAAC"}

package/lib/exercises/math/calcul/operations/operationsPrioritiesParenthesisNoRelatives.js

@@ -16,8 +16,7 @@ const getOperationsPrioritiesParenthesisNoRelativesQuestion = () => {
             a = randint(2, 11);
             b = randint(1, 11);
             c = randint(-b, 11, [0]);
-            statement = new MultiplyNode(a.toTree(), new AddNode(b.toTree(), c.toTree()));
-            statement.shuffle();
+            statement = new MultiplyNode(a.toTree(), new AddNode(b.toTree(), c.toTree())).shuffle();
             answer = (a * (b + c)).frenchify();
             break;
         case 2: //a/(b+-c) ou (b+-c)/a

package/lib/exercises/math/calcul/operations/operationsPrioritiesWithoutRelative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operationsPrioritiesWithoutRelative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/operationsPrioritiesWithoutRelative.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiSF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAcrE,CAAC"}
+{"version":3,"file":"operationsPrioritiesWithoutRelative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/operationsPrioritiesWithoutRelative.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgSF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAcrE,CAAC"}

package/lib/exercises/math/calcul/operations/operationsPrioritiesWithoutRelative.js

@@ -162,8 +162,7 @@ const getOperationsPrioritiesWithoutRelative = () => {
             b = randint(2, 10);
             a = b * randint(2, 10);
             c = randint(2, 10);
-            statement = new MultiplyNode(new DivideNode(a.toTree(), b.toTree()), c.toTree());
-            statement.shuffle();
+            statement = new MultiplyNode(new DivideNode(a.toTree(), b.toTree()), c.toTree()).shuffle();
             answer = ((a / b) * c).frenchify();
             startStatement = statement.toTex();
             break;

package/lib/exercises/math/calcul/proportionality/proportionalityTableCoefficient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proportionalityTableCoefficient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/proportionalityTableCoefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAiFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAgBjE,CAAC"}
+{"version":3,"file":"proportionalityTableCoefficient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/proportionalityTableCoefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAsFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAiBjE,CAAC"}

package/lib/exercises/math/calcul/proportionality/proportionalityTableCoefficient.js

@@ -35,7 +35,7 @@ const getCorrection = (identifiers) => {
 Pour l'obtenir, on divise une valeur de la deuxième ligne par la valeur correspondante dans la première ligne, par exemple :
 
 $$
-${frac(xValues[0], yValues[0]).toSimplificationTex()}
+${frac(yValues[0], xValues[0]).toSimplificationTex()}
 $$`;
 };
 const getProportionalityTableCoefficient = () => {
@@ -43,6 +43,9 @@ const getProportionalityTableCoefficient = () => {
     const xValues = IntegerConstructor.randomDifferents(1, 100 / factor, 3).sort((a, b) => a - b);
     const yValues = xValues.map((x) => x * factor);
     const identifiers = { xValues, yValues };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         answer: getAnswer(identifiers),
@@ -87,4 +90,5 @@ export const proportionalityTableCoefficient = {
     subject: "Mathématiques",
     getInstruction,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/calculLitteral/isolate/isolateVariable.js

@@ -13,71 +13,135 @@
 //   GetInstruction,
 //   GetKeys,
 //   GetQuestionFromIdentifiers,
-// } from '../../../../exercises/exercise.js';
-// import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions.js';
+// } from "../../../../exercises/exercise.js";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import { GeneralAffine } from "../../../../math/polynomials/generalAffine.js";
+// import { randint } from "../../../../math/utils/random/randint.js";
+// import { AlgebraicNode } from "../../../../tree/nodes/algebraicNode.js";
+// import {
+//   EqualNode,
+//   EqualNodeConstructor,
+//   EqualNodeIdentifiers,
+// } from "../../../../tree/nodes/equations/equalNode.js";
+// import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+// import { reifyAlgebraic } from "../../../../tree/nodes/nodeConstructor.js";
+// import { add } from "../../../../tree/nodes/operators/addNode.js";
+// import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+// import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 // import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 export {};
 // type Identifiers = {
+//   eqNodeIds: EqualNodeIdentifiers;
+//   type: number;
 // };
 // //1. x+a = b (plus ou moins, droite ou gauche)
 // //2. ax + b = c (plus ou moins, droite ou gauche)
-// //3. a/x = b
+// //3. a/x = b , a +b/x =c, x num ou denum
 // //4. ax / b = c
+// //5. x(a+b)=c
+// //6. x*a*b = c ou xa = bc
+// //7. x+a / b =c/ d  (x+a) place aléatire , pm
+// //8. (x+a)/b = c
 // const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
 //   const propositions: Proposition[] = [];
 //   addValidProp(propositions, answer);
 //   while (propositions.length < n) {
-//     throw Error("QCM not implemented")
+//     throw Error("QCM not implemented");
 //   }
 //   return shuffleProps(propositions, n);
 // };
-// const getAnswer : GetAnswer<Identifiers> = (identifiers)=>{
-// }
-// const getInstruction : GetInstruction<Identifiers> = (identifiers)=>{
-// }
-// const getHint : GetHint<Identifiers> = (identifiers)=>{
-// }
-// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
-// }
-// const getKeys : GetKeys<Identifiers> = (identifiers)=>{
-//   return []
-// }
-// const isAnswerValid: VEA<Identifiers> = (ans, {answer})=>{
+// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {
+//   const { type, eqNodeIds } = identifiers;
+//   const eq = EqualNodeConstructor.fromIdentifiers(eqNodeIds);
+//   //   return "";
+//   return eq.isolate("x").toTex();
+// };
+// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
+//   const { type, eqNodeIds } = identifiers;
+//   const eq = reifyAlgebraic(eqNodeIds);
+//   return `Isoler $x$ dans l'égalité suivante :
+// $$
+// ${eq.toTex()}
+// $$`;
+// };
+// // const getHint : GetHint<Identifiers> = (identifiers)=>{
+// // }
+// // const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
+// // }
+// const getKeys: GetKeys<Identifiers> = (identifiers) => {
+//   return ["x", "a", "b", "c", "d"];
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, { answer }) => {
 //   try {
-//     throw Error("VEA not implemented")
-//   } catch(err){
-//     return handleVEAError(err)
+//     throw Error("VEA not implemented");
+//   } catch (err) {
+//     return handleVEAError(err);
 //   }
-// }
-// const getIsolateVariableQuestion: QuestionGenerator<Identifiers>  = (ops)=>{
-//   const identifiers: Identifiers = {}
+// };
+// const getIsolateVariableQuestion: QuestionGenerator<Identifiers> = (ops) => {
+//   //1. x+a = b (plus ou moins, droite ou gauche)
+//   //2. ax + b = c (plus ou moins, droite ou gauche)
+//   //3. a/x = b , a +b/x =c, x num ou denum
+//   //4. ax / b = c
+//   //5. x(a+b)=c
+//   //6. x*a*b = c ou xa = bc
+//   //7. x+a / b =c/ d  (x+a) place aléatire , pm
+//   //8. (x+a)/b = c
+//   const type = randint(0, 8);
+//   const x = "x".toTree();
+//   const a = "a".toTree();
+//   const b = "b".toTree();
+//   const c = "c".toTree();
+//   const d = "d".toTree();
+//   const signify = (x: AlgebraicNode) => (coinFlip() ? x : opposite(x));
+//   let eqNode: EqualNode;
+//   switch (type) {
+//     case 1:
+//       let n = add(signify(x), signify(a)).shuffle();
+//       eqNode = new EqualNode(n, b).shuffle();
+//       break;
+//     case 2:
+//     default:
+//       eqNode = new EqualNode(
+//         add(multiply(signify(a), x), signify(b)).shuffle(),
+//         signify(c),
+//       ).shuffle();
+//       break;
+//   }
+//   const identifiers: Identifiers = {
+//     type,
+//     eqNodeIds: eqNode.toIdentifiers(),
+//   };
 //   return getQuestionFromIdentifiers(identifiers);
-// }
-// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (identifiers)=>{
+// };
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (
+//   identifiers,
+// ) => {
 //   return {
 //     answer: getAnswer(identifiers),
 //     instruction: getInstruction(identifiers),
 //     keys: getKeys(identifiers),
-//     answerFormat: 'tex',
+//     answerFormat: "tex",
 //     identifiers,
-//     hint: getHint(identifiers),
-//     correction: getCorrection(identifiers)
-//   }
-// }
+//     // hint: getHint(identifiers),
+//     // correction: getCorrection(identifiers)
+//   };
+// };
 // export const isolateVariable: Exercise<Identifiers> = {
-//   id: 'isolateVariable',
-//   connector: "",
-//   label: undefined,
+//   id: "isolateVariable",
+//   connector: "\\iff",
+//   label: "Isoler une variable",
 //   isSingleStep: true,
-//   generator: (nb, opts) => getDistinctQuestions(()=>getIsolateVariableQuestion(opts), nb),
+//   generator: (nb, opts) =>
+//     getDistinctQuestions(() => getIsolateVariableQuestion(opts), nb),
 //   qcmTimer: 60,
 //   freeTimer: 60,
 //   getPropositions,
 //   isAnswerValid,
 //   subject: "Mathématiques",
 //   getInstruction,
-//   getHint,
-//   getCorrection,
+//   //   getHint,
+//   //   getCorrection,
 //   getAnswer,
-//   getQuestionFromIdentifiers
+//   getQuestionFromIdentifiers,
 // };

package/lib/exercises/math/functions/exponential/expSimplifiying.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expSimplifiying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/expSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAmIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"expSimplifiying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/expSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAkIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/math/functions/exponential/expSimplifiying.js

@@ -26,8 +26,7 @@ const getExpSimplifiying = () => {
             //e^u * e^v
             u = new Polynomial([randint(-9, 10), randint(-9, 10, [0])]);
             v = new Polynomial([randint(-9, 10), randint(-9, 10, [0])]);
-            expression = new MultiplyNode(new ExpNode(u.toTree()), new ExpNode(v.toTree()));
-            expression.shuffle();
+            expression = new MultiplyNode(new ExpNode(u.toTree()), new ExpNode(v.toTree())).shuffle();
             answer = new ExpNode(u.add(v).toTree()).toTex();
             break;
         case 3:

package/lib/exercises/math/geometry/cartesian/cartesianEquationOfLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cartesianEquationOfLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianEquationOfLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAqOF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"cartesianEquationOfLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianEquationOfLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAqBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA0KF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}

package/lib/exercises/math/geometry/cartesian/cartesianEquationOfLine.js

@@ -8,43 +8,79 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
 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 { MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
-const zero = new NumberNode(0);
-const getCartesianEquationOfLineQuestion = () => {
-    const a = new Point("A", new NumberNode(randint(-5, 6)), new NumberNode(randint(-5, 6)));
-    const b = new Point("B", new NumberNode(randint(-5, 6, [a.getXnumber()])), new NumberNode(randint(-5, 6, [a.getXnumber()])));
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const instruction = `Déterminer une équation cartésienne de la droite $d$ représentée ci-dessous :`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { aX, aY, bX, bY } = identifiers;
+    const a = new Point("a", aX, aY);
+    const b = new Point("b", bX, bY);
     const line = new Line(a, b);
+    const correctAnswer = line.getCartesianEquation();
+    return correctAnswer.toTex();
+};
+const getGGBOptions = (identifiers) => {
+    const { aX, aY, bX, bY } = identifiers;
+    const a = new Point("a", aX, aY);
+    const b = new Point("b", bX, bY);
     const commands = [
-        `d = Line((${a.getXnumber()},${a.getYnumber()}),(${b.getXnumber()},${b.getYnumber()}))`,
+        `d = Line((${aX},${aY}),(${bX},${bY}))`,
         `SetCaption(d, "$d$")`,
         `ShowLabel(d,true)`,
         `SetFixed(d,true)`,
     ];
     const ggb = new GeogebraConstructor({ commands });
-    const correctAnswer = line.getCartesianEquation();
-    const instruction = `Déterminer une équation cartesienne de la droite $d$ représentée ci-dessous :`;
-    const aX = a.getXnumber();
-    const aY = a.getYnumber();
-    const bX = b.getXnumber();
-    const bY = b.getYnumber();
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([a, b]),
+    });
+};
+const getCartesianEquationOfLineQuestion = () => {
+    const aX = randint(-5, 6);
+    const aY = randint(-5, 6);
+    const bX = randint(-5, 6, [aX]);
+    const bY = randint(-5, 6, [aY]);
+    const identifiers = { aX, aY, bX, bY };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: correctAnswer.toTex(),
-        ggbOptions: ggb.getOptions({
-            coords: ggb.getAdaptedCoords({
-                xMin: Math.min(aX, bX) - 5,
-                xMax: Math.max(bX, aX) + 5,
-                yMin: Math.min(aY, bY) - 5,
-                yMax: Math.max(bY, aY) + 5,
-            }),
-        }),
-        instruction: instruction,
+        answer: getAnswer(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["x", "y", "equal"],
         answerFormat: "tex",
-        identifiers: { aX, aY, bX, bY },
+        identifiers,
     };
     return question;
 };
+const isAnswerValid = (ans, { aX, aY, bX, bY }) => {
+    try {
+        const splitted = ans.split("=");
+        if (splitted[1] !== "0" || splitted.length !== 2)
+            return false;
+        const parsed = parseAlgebraic(splitted[0]);
+        const validpoints = [
+            [aX.toTree(), aY.toTree()],
+            [bX.toTree(), bY.toTree()],
+        ];
+        return (parsed
+            .toDetailedEvaluation({ x: validpoints[0][0], y: validpoints[0][1] })
+            .simplify()
+            .toTex() === "0" &&
+            parsed
+                .toDetailedEvaluation({ x: validpoints[1][0], y: validpoints[1][1] })
+                .simplify()
+                .toTex() === "0");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
 const getPropositions = (n, { answer, aX, aY, bX, bY }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -69,7 +105,7 @@ const generateRandomWrongProp = (aX, aY, bX, bY, x, y) => {
         b = randint(-10, 11, [0]);
         c = randint(-10, 11);
     } while (a * aX + b * aY + c === 0 && a * bX + b * bY + c === 0);
-    return new EqualNode(new AddNode(new AddNode(new MultiplyNode(a.toTree(), x).simplify(), new MultiplyNode(b.toTree(), y).simplify()), c.toTree()), zero);
+    return new EqualNode(new AddNode(new AddNode(new MultiplyNode(a.toTree(), x).simplify(), new MultiplyNode(b.toTree(), y).simplify()), c.toTree()), (0).toTree());
 };
 const generateProposition = (aX, aY, bX, bY) => {
     const x = new VariableNode("x");
@@ -86,84 +122,12 @@ const getFirstProposition = (x, y, aX, aY, bX, bY) => {
     const b = -u.getXAsNumber();
     const a = u.getYAsNumber();
     const c = a * aX + b * aY;
-    return new EqualNode(new AddNode(new AddNode(new MultiplyNode(new NumberNode(b), x).simplify(), new MultiplyNode(new NumberNode(a), y).simplify()), new NumberNode(c)), zero);
-};
-const isAnswerValid = (ans, { aX, aY, bX, bY }) => {
-    let userAns = getEquationNodeFromString(ans);
-    if (userAns === undefined)
-        return false;
-    userAns = userAns;
-    if (userAns.evaluate({ x: aX, y: aY }) !== 0)
-        return false;
-    if (userAns.evaluate({ x: bX, y: bY }) !== 0)
-        return false;
-    return true;
-};
-const getEquationNodeFromString = (ans) => {
-    if (!isValidFormat(ans))
-        return undefined;
-    const leftSide = ans.split("=")[0];
-    let op = leftSide.charAt(0) === "-" ? leftSide.replace("-", "minus") : leftSide;
-    op = op.includes("+") ? op : op.replaceAll("-", "+minus");
-    return getNodeFromString(op.split("+"));
-};
-const isValidFormat = (ans) => {
-    if (!ans.includes("="))
-        return false;
-    const splitted = ans.split("=");
-    if (splitted.length !== 2 ||
-        splitted[1] !== "0" ||
-        (!splitted[0].includes("x") && !splitted[0].includes("y")))
-        return false;
-    return true;
-};
-const getNodeFromString = (tab) => {
-    if (tab.length === 1) {
-        let varStr = tab[0];
-        const operator = findOpInSimpleOpString(varStr);
-        if (operator !== undefined) {
-            const modified = operator === "-" ? varStr.replaceAll("-", "+minus") : varStr;
-            const separated = modified.split("+");
-            return getNodeFromString(separated).simplify();
-        }
-        varStr = varStr.replace("minus", "-");
-        if (varStr.includes("x")) {
-            return getNodeFromVariableString(varStr, "x");
-        }
-        if (varStr.includes("y")) {
-            return getNodeFromVariableString(varStr, "y");
-        }
-        return isNaN(+varStr) ? new NumberNode(0) : new NumberNode(+varStr);
-    }
-    else {
-        const middle = Math.floor(tab.length / 2);
-        const leftSide = tab.slice(0, middle);
-        const rightSide = tab.slice(middle);
-        return new AddNode(getNodeFromString(leftSide).simplify(), getNodeFromString(rightSide).simplify()).simplify();
-    }
-};
-const findOpInSimpleOpString = (str) => {
-    if (str.includes("+"))
-        return "+";
-    if (str.includes("-"))
-        return "-";
-    return undefined;
-};
-const getNodeFromVariableString = (str, splitter) => {
-    if (str === splitter)
-        return new VariableNode(splitter);
-    const splitted = str.split(splitter);
-    if (splitted[0] === "-") {
-        return new MultiplyNode(new NumberNode(-1), new VariableNode(splitter)).simplify();
-    }
-    return new MultiplyNode(new NumberNode(+splitted[0]), new VariableNode(splitter)).simplify();
+    return new EqualNode(new AddNode(new AddNode(new MultiplyNode(new NumberNode(b), x).simplify(), new MultiplyNode(new NumberNode(a), y).simplify()), new NumberNode(c)), (0).toTree());
 };
 export const cartesianEquationOfLine = {
     id: "cartesianEquationOfLine",
     label: "Déterminer une équation cartesienne de droite par lecture graphique",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Droites"],
     generator: (nb) => getDistinctQuestions(getCartesianEquationOfLineQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -171,4 +135,5 @@ export const cartesianEquationOfLine = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.d.ts

@@ -5,6 +5,9 @@ type Identifiers = {
     k: number;
     nbEssais: number;
 };
-export declare const calculateFrequency: Exercise<Identifiers>;
+type Options = {
+    useFractions?: boolean;
+};
+export declare const calculateFrequency: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=calculateFrequency.d.ts.map

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAyGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}
+{"version":3,"file":"calculateFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2IF,KAAK,OAAO,GAAG;IACb,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAUF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB7D,CAAC"}

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

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionType, GeneratorOptionTarget, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
@@ -8,22 +8,33 @@ import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { random } from "../../../../utils/alea/random.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
-const getPropositions = (n, { answer, ...identifiers }) => {
+const getPropositions = (n, { answer, ...identifiers }, opts) => {
     const propositions = [];
     const { k, nbEssais } = identifiers;
+    const useFrac = opts?.useFractions;
     addValidProp(propositions, answer);
     tryToAddWrongProp(propositions, k + "");
-    tryToAddWrongProp(propositions, round(k / 100, 2).frenchify());
+    if (useFrac)
+        tryToAddWrongProp(propositions, frac(k, 100).toTex());
+    else
+        tryToAddWrongProp(propositions, round(k / 100, 2).frenchify());
     while (propositions.length < n) {
-        tryToAddWrongProp(propositions, round(RationalConstructor.randomIrreductible().toTree().evaluate(), 2).frenchify());
+        if (useFrac)
+            tryToAddWrongProp(propositions, frac(randint(5, 100), randint(5, 100)).toTex());
+        else
+            tryToAddWrongProp(propositions, round(RationalConstructor.randomIrreductible().toTree().evaluate(), 2).frenchify());
     }
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
+const getAnswer = (identifiers, opts) => {
+    const useFrac = opts?.useFractions;
     const { k, nbEssais } = identifiers;
-    return round(k / nbEssais, 2).frenchify();
+    if (useFrac)
+        return frac(k, nbEssais).toTex();
+    else
+        return round(k / nbEssais, 2).frenchify();
 };
-const getInstruction = (identifiers) => {
+const getInstruction = (identifiers, opts) => {
     const { type, k, nbEssais, caracType } = identifiers;
     let instruction = ";";
     switch (type) {
@@ -42,22 +53,23 @@ const getInstruction = (identifiers) => {
 Quelle est la fréquence d'apparition de ${caracType} ? Arrondir au centième près.`;
     return instruction;
 };
-const getHint = (identifiers) => {
+const getHint = (identifiers, opts) => {
     const { type, k, nbEssais, caracType } = identifiers;
     return `La fréquence est le nombre de fois qu'on a obtenu ${caracType} divisé par le nombre total d'essais.`;
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, opts) => {
     const { type, k, nbEssais, caracType } = identifiers;
+    const useFrac = opts?.useFractions;
     return `On a obtenu $${k}$ fois ${caracType} sur les $${nbEssais}$ lancers. La fréquence d'apparition de ${caracType} est donc : 
   
 $$
-${frac(k, nbEssais).toTex()} ${approxOrEqual(k / nbEssais, 2).join("")}
+${frac(k, nbEssais).toTex()} ${useFrac ? "" : approxOrEqual(k / nbEssais, 2).join("")}
 $$`;
 };
-const getKeys = (identifiers) => {
+const getKeys = (identifiers, opts) => {
     return [];
 };
-const isAnswerValid = (ans, { answer, k, nbEssais }) => {
+const isAnswerValid = (ans, { answer, k, nbEssais }, opts) => {
     try {
         return rationalVEA(ans, frac(k, nbEssais).simplify().toTex(), {
             decimalPrecision: 2,
@@ -67,7 +79,7 @@ const isAnswerValid = (ans, { answer, k, nbEssais }) => {
         return handleVEAError(err);
     }
 };
-const getCalculateFrequencyQuestion = (ops) => {
+const getCalculateFrequencyQuestion = (opts) => {
     const type = randint(0, 4);
     const nbEssais = 5 * randint(10, 100);
     const k = randint(1, nbEssais);
@@ -79,17 +91,29 @@ const getCalculateFrequencyQuestion = (ops) => {
                 ? `la face $${randint(1, 13)}$`
                 : `la somme $${randint(1, 13)}$`;
     const identifiers = { type, k, nbEssais, caracType };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        keys: getKeys(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
+const options = [
+    {
+        id: "useFractions",
+        label: "Réponse sous forme de fraction",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
 export const calculateFrequency = {
     id: "calculateFrequency",
     connector: "=",
@@ -106,4 +130,5 @@ export const calculateFrequency = {
     getCorrection,
     getAnswer,
     hasHintAndCorrection: true,
+    options,
 };

package/lib/index.d.ts

@@ -1659,7 +1659,9 @@ declare const mathExercises: (Exercise<{
     caracType: string;
     k: number;
     nbEssais: number;
-}, {}> | Exercise<{
+}, {
+    useFractions?: boolean;
+}> | Exercise<{
     firstValue: number;
     askedRank: number;
     reason: 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/math/geometry/line.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAG1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,OAAO,EAAO,MAAM,uCAAuC,CAAC;AAMrE,OAAO,EACL,aAAa,EAEd,MAAM,6CAA6C,CAAC;AAKrD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAO3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7C,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAW7C,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,EAC3B,KAAiB,EACjB,KAAiB,GAClB,GAAE,kBAAuB;IA2C5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAG1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAS,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAG3E,OAAO,EAAE,OAAO,EAAO,MAAM,uCAAuC,CAAC;AAMrE,OAAO,EACL,aAAa,EAEd,MAAM,6CAA6C,CAAC;AAKrD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAO3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7C,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAW7C,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAgBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,EAC3B,KAAiB,EACjB,KAAiB,GAClB,GAAE,kBAAuB;IA2C5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}

package/lib/math/geometry/line.js

@@ -1,6 +1,6 @@
 import { randomSegmentName } from "../../exercises/utils/geometry/randomSegmentName.js";
 import { randomColor } from "../../geogebra/colors.js";
-import { EqualNode } from "../../tree/nodes/equations/equalNode.js";
+import { equal, EqualNode } from "../../tree/nodes/equations/equalNode.js";
 import { opposite } from "../../tree/nodes/functions/oppositeNode.js";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
 import { AddNode, add } from "../../tree/nodes/operators/addNode.js";
@@ -11,7 +11,7 @@ import { VariableNode } from "../../tree/nodes/variables/variableNode.js";
 import { GeneralSystem } from "../systems/generalSystem.js";
 import { randint } from "../utils/random/randint.js";
 import { Point, PointConstructor } from "./point.js";
-import { Vector, VectorConstructor } from "./vector.js";
+import { VectorConstructor } from "./vector.js";
 export class LineConstructor {
     static random(name) {
         const names = randomSegmentName();
@@ -148,13 +148,13 @@ export class Line {
         return equation;
     };
     getCartesianEquation() {
-        const u = new Vector("u", new NumberNode(this.pointB.getXnumber() - this.pointA.getXnumber()), new NumberNode(this.pointB.getYnumber() - this.pointA.getYnumber()));
-        const b = -u.getXAsNumber();
-        const a = u.getYAsNumber();
-        const c = -a * this.pointA.getXnumber() - b * this.pointA.getYnumber();
-        const x = new VariableNode("x");
-        const y = new VariableNode("y");
-        return new EqualNode(new AddNode(new AddNode(new MultiplyNode(new NumberNode(a), x).simplify(), new MultiplyNode(new NumberNode(b), y).simplify()), new NumberNode(c)).simplify({ forbidFactorize: true }), new NumberNode(0));
+        const u = VectorConstructor.fromPoints(this.pointA, this.pointB);
+        const b = opposite(u.x);
+        const a = u.y;
+        const c = add(opposite(multiply(a, this.pointA.x)), opposite(multiply(b, this.pointA.y)));
+        return equal(add(add(multiply(a, "x"), multiply(b, "y")), c).simplify({
+            forbidFactorize: true,
+        }), 0);
     }
     toCartesian() {
         const { a, b, c } = this.toCartesianCoeffs();

package/lib/playground.d.ts.map

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

package/lib/playground.js

@@ -1,7 +1,10 @@
-import { EqualNode } from "./tree/nodes/equations/equalNode.js";
-import { parseAlgebraic } from "./tree/parsers/latexParser.js";
 export const playground = () => {
     // console.log(x.equals(x.simplify()));
-    const eq = new EqualNode(parseAlgebraic("\\frac{3x+2}{4}"), parseAlgebraic("3x"));
+    // const eq = new EqualNode(
+    //   parseAlgebraic("\\frac{3x+2}{4}"),
+    //   parseAlgebraic("3x"),
+    // );
+    // console.log(eq.isolate("x").toTex());
     // console.log(parseAlgebraic("\\left|x^2\\right|").toTex());
+    // console.log(add(multiply(3, "x"), multiply(4, "x")).simplify().toTex());
 };

package/lib/tree/nodes/equations/equalNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAEL,eAAe,EAEhB,MAAM,uBAAuB,CAAC;AAQ/B,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC;IAClB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,8BAAsB,oBAAoB;IACxC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,SAAS;CAOrE;AAED,eAAO,MAAM,WAAW,SAAU,aAAa,KAAG,IAAI,IAAI,SACzB,CAAC;AAElC,qBAAa,SAAU,YAAW,aAAa;IAC7C,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,aAAa,IAAI,oBAAoB;IAQrC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;IAIR,OAAO;IAIP,OAAO;IAIP,OAAO,CAAC,OAAO,EAAE,MAAM;IA8FvB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa;IAG3C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,MAAM;IAGvE,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,aAAa;CAGzE;AAED,eAAO,MAAM,qBAAqB,MAC7B,aAAa,KACb,aAAa,KACb,aAAa,KACb,aAAa,sBA2DjB,CAAC"}
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAEL,eAAe,EAEhB,MAAM,uBAAuB,CAAC;AAQ/B,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC;IAClB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,8BAAsB,oBAAoB;IACxC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,SAAS;CAOrE;AAED,eAAO,MAAM,WAAW,SAAU,aAAa,KAAG,IAAI,IAAI,SACzB,CAAC;AAElC,qBAAa,SAAU,YAAW,aAAa;IAC7C,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,aAAa,IAAI,oBAAoB;IAQrC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;IAIR,OAAO;IAIP,OAAO;IAIP,OAAO,CAAC,OAAO,EAAE,MAAM;IAiGvB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa;IAG3C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,MAAM;IAGvE,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,aAAa;CAGzE;AAED,eAAO,MAAM,qBAAqB,MAC7B,aAAa,KACb,aAAa,KACb,aAAa,KACb,aAAa,sBA2DjB,CAAC"}

package/lib/tree/nodes/equations/equalNode.js

@@ -95,17 +95,22 @@ export class EqualNode {
         const simpOpts = {
             towardsDistribute: true,
             forbidFactorize: true,
+            forceDistributeFractions: false,
         };
         let left = substract(this.leftChild, this.rightChild).simplify(simpOpts);
         // let simp = new EqualNode(left, right);
+        let i = 0;
         const recur = () => {
+            i++;
+            if (i > 100)
+                throw new Error("too many iterations in isolate");
             if (isVariableNode(left) && left.name === varName) {
                 return;
             }
             else if (isAddNode(left)) {
                 // const xIsLeft = ??
                 // if xIsLeft, right = right-node.right, left = left-node.right
-                const xIsLeft = hasVariableNode(left.leftChild);
+                const xIsLeft = hasVariableNode(left.leftChild, varName);
                 if (xIsLeft) {
                     right = substract(right, left.rightChild).simplify(simpOpts);
                     left = substract(left, left.rightChild).simplify(simpOpts);
@@ -116,7 +121,7 @@ export class EqualNode {
                 }
             }
             else if (isSubstractNode(left)) {
-                const xIsLeft = hasVariableNode(left.leftChild);
+                const xIsLeft = hasVariableNode(left.leftChild, varName);
                 if (xIsLeft) {
                     right = add(right, left.rightChild).simplify(simpOpts);
                     left = add(left, left.rightChild).simplify(simpOpts);
@@ -127,37 +132,37 @@ export class EqualNode {
                 }
             }
             else if (isMultiplyNode(left)) {
-                const xIsLeft = hasVariableNode(left.leftChild);
+                const xIsLeft = hasVariableNode(left.leftChild, varName);
                 if (xIsLeft) {
-                    right = frac(right, left.rightChild).simplify(simpOpts);
-                    left = frac(left, left.rightChild).simplify(simpOpts);
+                    right = frac(right, left.rightChild).simplify();
+                    left = frac(left, left.rightChild).simplify();
                 }
                 else {
-                    right = frac(right, left.leftChild).simplify(simpOpts);
-                    left = frac(left, left.leftChild).simplify(simpOpts);
+                    right = frac(right, left.leftChild).simplify();
+                    left = frac(left, left.leftChild).simplify();
                 }
             }
             else if (isFractionNode(left)) {
-                console.log(left.leftChild);
-                const xIsLeft = hasVariableNode(left.leftChild);
+                // console.log(left.leftChild);
+                const xIsLeft = hasVariableNode(left.leftChild, varName);
                 if (xIsLeft) {
-                    right = multiply(right, left.rightChild).simplify(simpOpts);
-                    left = multiply(left, left.rightChild).simplify(simpOpts);
+                    right = multiply(right, left.rightChild).simplify();
+                    left = multiply(left, left.rightChild).simplify();
                 }
                 else {
                     if (right.equals((0).toTree())) {
                         //A/f(x) = 0 --> f(x) = 0
-                        left = left.rightChild.simplify(simpOpts);
+                        left = left.rightChild.simplify();
                     }
                     else {
-                        right = frac(1, right).simplify(simpOpts);
-                        left = frac(1, left).simplify(simpOpts);
+                        right = frac(1, right).simplify();
+                        left = frac(1, left).simplify();
                     }
                 }
             }
             else if (isOppositeNode(left)) {
-                left = opposite(left).simplify(simpOpts);
-                right = opposite(right).simplify(simpOpts);
+                left = opposite(left).simplify();
+                right = opposite(right).simplify();
             }
             else {
                 throw new Error("Isolation only implemented for basic operations yet");

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

@@ -1,3 +1,3 @@
 import { Node } from "./node.js";
-export declare const hasVariableNode: (n: Node) => boolean;
+export declare const hasVariableNode: (n: Node, name?: string) => boolean;
 //# sourceMappingURL=hasVariableNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasVariableNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/hasVariableNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAIjC,eAAO,MAAM,eAAe,MAAO,IAAI,KAAG,OAMzC,CAAC"}
+{"version":3,"file":"hasVariableNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/hasVariableNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAIjC,eAAO,MAAM,eAAe,MAAO,IAAI,SAAS,MAAM,KAAG,OAQxD,CAAC"}

package/lib/tree/nodes/hasVariableNode.js

@@ -1,12 +1,12 @@
 import { isFunctionNode } from "./functions/functionNode.js";
 import { isOperatorNode } from "./operators/operatorNode.js";
 import { isVariableNode } from "./variables/variableNode.js";
-export const hasVariableNode = (n) => {
-    if (isVariableNode(n))
+export const hasVariableNode = (n, name) => {
+    if (isVariableNode(n) && (!name || n.name === name))
         return true;
     if (isOperatorNode(n))
-        return hasVariableNode(n.leftChild) || hasVariableNode(n.rightChild);
+        return (hasVariableNode(n.leftChild, name) || hasVariableNode(n.rightChild, name));
     if (isFunctionNode(n))
-        return hasVariableNode(n.child);
+        return hasVariableNode(n.child, name);
     return false;
 };

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

@@ -11,7 +11,7 @@ export declare class AddNode implements CommutativeOperatorNode {
     opts?: NodeOptions;
     isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
-    shuffle: () => void;
+    shuffle: () => AddNode;
     deepShuffle: (opts?: DeepShuffleOpts) => AddNode;
     toMathString(): string;
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];

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;AAcrE,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;IAMvD,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;CAK3C"}
+{"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;AAcrE,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,gBAGL;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;IAMvD,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;CAK3C"}

package/lib/tree/nodes/operators/addNode.js

@@ -38,7 +38,8 @@ export class AddNode {
     }
     shuffle = () => {
         if (coinFlip())
-            [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+            return this;
+        return new AddNode(this.rightChild, this.leftChild, this.opts);
     };
     deepShuffle = (opts) => {
         const left = isCommutativeOperatorNode(this.leftChild)

package/lib/tree/nodes/operators/divideNode.d.ts

@@ -33,6 +33,6 @@ export declare class DivideNode implements OperatorNode {
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): DivideNode;
     derivative(varName?: string | undefined): AlgebraicNode;
-    shuffle: () => void;
+    shuffle: () => this;
 }
 //# sourceMappingURL=divideNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"divideNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/divideNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,eAAO,MAAM,MAAM,MACd,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,eAOnB,CAAC;AA4BF,qBAAa,UAAW,YAAW,YAAY;IAC7C,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;;;OAGG;gBAES,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa;IAQ/D,YAAY,IAAI,MAAM;IAGtB,kBAAkB;IAIlB,aAAa;;;;;;;;;IAQb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAYpC,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAGf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAO1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAGvD,OAAO,aAGL;CACH"}
+{"version":3,"file":"divideNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/divideNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,eAAO,MAAM,MAAM,MACd,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,eAOnB,CAAC;AA4BF,qBAAa,UAAW,YAAW,YAAY;IAC7C,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;;;OAGG;gBAES,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa;IAQ/D,YAAY,IAAI,MAAM;IAGtB,kBAAkB;IAIlB,aAAa;;;;;;;;;IAQb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAYpC,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAGf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAO1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAGvD,OAAO,aAEL;CACH"}

package/lib/tree/nodes/operators/divideNode.js

@@ -101,7 +101,6 @@ export class DivideNode {
         throw new Error("unimplemented derivative");
     }
     shuffle = () => {
-        if (coinFlip())
-            [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+        return this;
     };
 }

package/lib/tree/nodes/operators/multiplyNode.d.ts

@@ -12,7 +12,7 @@ export declare class MultiplyNode implements CommutativeOperatorNode {
     type: NodeType;
     isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
-    shuffle: () => void;
+    shuffle: () => MultiplyNode;
     deepShuffle: (opts?: DeepShuffleOpts) => MultiplyNode;
     toReversed: () => MultiplyNode;
     toMathString(): string;

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

@@ -1 +1 @@
-{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.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,EAGZ,MAAM,mBAAmB,CAAC;AAY3B,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,qBAAqB,CAAC;AAU7B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,MAChB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAYrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,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;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,WAAW,UAAW,eAAe,kBAUnC;IAEF,UAAU,qBAER;IACF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAgFrC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAsL/C,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;IAM1C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.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,EAGZ,MAAM,mBAAmB,CAAC;AAY3B,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,qBAAqB,CAAC;AAU7B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,MAChB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAYrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,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;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,qBAGL;IAEF,WAAW,UAAW,eAAe,kBAUnC;IAEF,UAAU,qBAER;IACF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAgFrC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAsL/C,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;IAM1C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}

package/lib/tree/nodes/operators/multiplyNode.js

@@ -54,7 +54,8 @@ export class MultiplyNode {
     }
     shuffle = () => {
         if (coinFlip())
-            [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+            return this;
+        return new MultiplyNode(this.rightChild, this.leftChild, this.opts);
     };
     deepShuffle = (opts) => {
         const left = isCommutativeOperatorNode(this.leftChild)

package/lib/tree/nodes/operators/operatorNode.d.ts

@@ -23,7 +23,7 @@ export type DeepShuffleOpts = {
     nodeIdsToShuffle: OperatorIds[];
 };
 export interface CommutativeOperatorNode extends OperatorNode {
-    shuffle: () => void;
+    shuffle: () => CommutativeOperatorNode;
     deepShuffle: (opts?: DeepShuffleOpts) => CommutativeOperatorNode;
     toAllTexs: () => string[];
 }

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

@@ -1 +1 @@
-{"version":3,"file":"operatorNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/operatorNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAqB,MAAM,YAAY,CAAC;AAErD,oBAAY,WAAW;IACrB,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;IACL,KAAK,IAAA;IACL,QAAQ,IAAA;IACR,mBAAmB,IAAA;IACnB,MAAM,IAAA;CACP;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;CAC3B;AACD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,IAAI,GACN,CAAC,IAAI,uBAAuB,CAI9B;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,gBAAgB,EAAE,WAAW,EAAE,CAAC;CACjC,CAAC;AACF,MAAM,WAAW,uBAAwB,SAAQ,YAAY;IAC3D,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,uBAAuB,CAAC;IACjE,SAAS,EAAE,MAAM,MAAM,EAAE,CAAC;CAC3B"}
+{"version":3,"file":"operatorNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/operatorNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAqB,MAAM,YAAY,CAAC;AAErD,oBAAY,WAAW;IACrB,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;IACL,KAAK,IAAA;IACL,QAAQ,IAAA;IACR,mBAAmB,IAAA;IACnB,MAAM,IAAA;CACP;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;CAC3B;AACD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,IAAI,GACN,CAAC,IAAI,uBAAuB,CAI9B;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,gBAAgB,EAAE,WAAW,EAAE,CAAC;CACjC,CAAC;AACF,MAAM,WAAW,uBAAwB,SAAQ,YAAY;IAC3D,OAAO,EAAE,MAAM,uBAAuB,CAAC;IACvC,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,uBAAuB,CAAC;IACjE,SAAS,EAAE,MAAM,MAAM,EAAE,CAAC;CAC3B"}

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

@@ -1,5 +1,6 @@
 import { Node, NodeIds, NodeOptions, NodeType, ToTexOptions } from "../node.js";
 import { OperatorIds, OperatorNode } from "./operatorNode.js";
+import { AddNode } from "./addNode.js";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 export declare function isSubstractNode(a: Node): a is SubstractNode;
 export declare const substract: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string) => SubstractNode;
@@ -30,6 +31,6 @@ export declare class SubstractNode implements OperatorNode {
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): SubstractNode;
     derivative(varName?: string | undefined): AlgebraicNode;
-    shuffle: () => void;
+    shuffle: () => this | AddNode;
 }
 //# sourceMappingURL=substractNode.d.ts.map

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;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"}
+{"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;AAE9E,OAAO,EAAO,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,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,uBAGL;CACH"}

package/lib/tree/nodes/operators/substractNode.js

@@ -1,8 +1,8 @@
 // import { subtract } from "mathjs";
 import { NodeIds, NodeType } from "../node.js";
 import { OperatorIds, isOperatorNode } from "./operatorNode.js";
-import { OppositeNode } from "../functions/oppositeNode.js";
-import { AddNode } from "./addNode.js";
+import { opposite, OppositeNode } from "../functions/oppositeNode.js";
+import { add, AddNode } from "./addNode.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
 import { colorize } from "../../../utils/latex/colorize.js";
 export function isSubstractNode(a) {
@@ -94,6 +94,7 @@ export class SubstractNode {
     }
     shuffle = () => {
         if (coinFlip())
-            [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+            return this;
+        return add(opposite(this.rightChild), this.leftChild);
     };
 }

package/package.json

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