math-exercises 3.0.124 → 3.0.126

package/lib/pc/constants/molecularChemistry/molecule.js

@@ -35,6 +35,58 @@ export class Molecule {
         this.iupact = iupact;
         this.type = type;
     }
+    static electronegativityOrder = (() => {
+        const arrayOfAtoms = `Rn	Xe	Kr	Ar	Ne	He
+Fr	Cs	Rb	K	Na	Li
+Ra	Ba	Sr	Ca	Mg	Be
+Lr Ac	Lu La	Y	Sc
+Rf	Hf	Zr	Ti
+Db	Ta	Nb	V
+Sg	W	Mo	Cr
+Bh	Re	Tc	Mn
+Hs	Os	Ru	Fe
+Mt	Ir	Rh	Co
+Ds	Pt	Pd	Ni
+Rg	Au	Ag	Cu
+Hg	Cd	Zn
+Tl	In	Ga	Al	B
+Pb	Sn	Ge	Si	C
+Bi	Sb	As	P	N	H
+Po	Te	Se	S	O
+At	I	Br	Cl	F`
+            .replace(/\s/g, ",")
+            .split(",");
+        return Object.fromEntries(arrayOfAtoms.map((atom, i) => {
+            return [atom, i];
+        }));
+    })();
+    getRawFormula() {
+        const symboleForAtomsData = Object.fromEntries(this.atoms.map((atomsData) => [atomsData.atom.symbole, atomsData]));
+        const symbolsFirst = this.isOrganic ? ["C", "H", "O"] : [];
+        const arrayFirst = symbolsFirst
+            .map((symbole) => symboleForAtomsData[symbole])
+            .filter((atomsData) => !!atomsData);
+        const arrayRest = (() => {
+            const symboleForAtomsDataCopy = Object.assign(symboleForAtomsData, {});
+            symbolsFirst.forEach((symbole) => {
+                delete symboleForAtomsDataCopy[symbole];
+            });
+            return Object.values(symboleForAtomsDataCopy);
+        })().toSorted(({ atom: atom1 }, { atom: atom2 }) => Molecule.electronegativityOrder[atom1.symbole] -
+            Molecule.electronegativityOrder[atom2.symbole]);
+        const sortedArrayAtomsData = [...arrayFirst, ...arrayRest];
+        let rawFormula = ``;
+        for (let i = 0; i < sortedArrayAtomsData.length; i++) {
+            const atomData = sortedArrayAtomsData[i];
+            if (atomData.count > 1) {
+                rawFormula += `${atomData.atom.symbole}_{${atomData.count.frenchify()}}`;
+            }
+            else {
+                rawFormula += `${atomData.atom.symbole}`;
+            }
+        }
+        return rawFormula;
+    }
 }
 export const molecules = [
     new Molecule("Dihydrogène", "H_2", 2.016, [{ name: "H", count: 2 }], false, "gas"),

package/lib/pc/units/timeUnits.d.ts

@@ -1,13 +1,15 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
 import { Measure } from "../measure/measure.js";
 import { BasicUnit } from "./interfaces/basicUnit.js";
-export type TimeValues = "h" | "mi" | "s" | "ms";
+export type TimeValues = "h" | "min" | "s" | "ms";
 export declare class TimeUnit extends BasicUnit<TimeValues> {
     static readonly h: TimeUnit;
-    static readonly mi: TimeUnit;
+    static readonly min: TimeUnit;
     static readonly s: TimeUnit;
     static readonly ms: TimeUnit;
     className(): string;
     convert(significantPart: number, exponent: number, convertToUnit: TimeValues): Measure<TimeValues>;
-    convertToMinute(significantPart: number): number;
+    static convertToMinute(unit: TimeValues): AlgebraicNode;
+    static getConversionFactor(from: TimeValues, to: TimeValues): import("../../tree/nodes/operators/fractionNode.js").FractionNode;
 }
 //# sourceMappingURL=timeUnits.d.ts.map

package/lib/pc/units/timeUnits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timeUnits.d.ts","sourceRoot":"","sources":["../../../src/pc/units/timeUnits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAEtD,MAAM,MAAM,UAAU,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC;AAKjD,qBAAa,QAAS,SAAQ,SAAS,CAAC,UAAU,CAAC;IACjD,MAAM,CAAC,QAAQ,CAAC,CAAC,WAAqB;IACtC,MAAM,CAAC,QAAQ,CAAC,EAAE,WAAsB;IACxC,MAAM,CAAC,QAAQ,CAAC,CAAC,WAAqB;IACtC,MAAM,CAAC,QAAQ,CAAC,EAAE,WAAsB;IAExC,SAAS,IAAI,MAAM;IAInB,OAAO,CACL,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,UAAU,GACxB,OAAO,CAAC,UAAU,CAAC;IAatB,eAAe,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM;CAajD"}
+{"version":3,"file":"timeUnits.d.ts","sourceRoot":"","sources":["../../../src/pc/units/timeUnits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAEtD,MAAM,MAAM,UAAU,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC;AAKlD,qBAAa,QAAS,SAAQ,SAAS,CAAC,UAAU,CAAC;IACjD,MAAM,CAAC,QAAQ,CAAC,CAAC,WAAqB;IACtC,MAAM,CAAC,QAAQ,CAAC,GAAG,WAAuB;IAC1C,MAAM,CAAC,QAAQ,CAAC,CAAC,WAAqB;IACtC,MAAM,CAAC,QAAQ,CAAC,EAAE,WAAsB;IAExC,SAAS,IAAI,MAAM;IAInB,OAAO,CACL,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,UAAU,GACxB,OAAO,CAAC,UAAU,CAAC;IAiBtB,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa;IAavD,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU;CAG5D"}

package/lib/pc/units/timeUnits.js

@@ -1,38 +1,44 @@
+import { frac } from "../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../tree/nodes/operators/multiplyNode.js";
 import { Measure } from "../measure/measure.js";
 import { BasicUnit } from "./interfaces/basicUnit.js";
-const times = ["h", "mi", "s", "ms"];
+const times = ["h", "min", "s", "ms"];
 // const timesValue = [1 / 60, 1, 60, 60000];
 export class TimeUnit extends BasicUnit {
     static h = new TimeUnit("h");
-    static mi = new TimeUnit("mi");
+    static min = new TimeUnit("min");
     static s = new TimeUnit("s");
     static ms = new TimeUnit("ms");
     className() {
         return "TimeUnit";
     }
     convert(significantPart, exponent, convertToUnit) {
-        const timeObjects = [TimeUnit.h, TimeUnit.mi, TimeUnit.s, TimeUnit.ms];
+        const timeObjects = [TimeUnit.h, TimeUnit.min, TimeUnit.s, TimeUnit.ms];
         const unitIndex = times.findIndex((value) => convertToUnit === value);
-        if (!times.includes(convertToUnit))
+        if (!unitIndex) {
             throw new Error(`cannot convert ${this.toTex()} to ${convertToUnit}.`);
-        // let convertedSignificantPart = this.convertToMinute(significantPart);
-        // if (convertToUnit !== "mi") {
-        //   convertedSignificantPart =
-        //     timesValue[unitIndex] * convertedSignificantPart;
-        // }
-        return new Measure(significantPart, exponent, timeObjects[unitIndex]);
+        }
+        else {
+            const timeObject = timeObjects[unitIndex];
+            const factor = TimeUnit.getConversionFactor(this.unit, convertToUnit);
+            //!TODO: precision loss here /!\
+            const significantPartTo = multiply(significantPart, factor).evaluate();
+            return new Measure(significantPartTo, exponent, timeObject);
+        }
     }
-    convertToMinute(significantPart) {
-        switch (this.unit) {
+    static convertToMinute(unit) {
+        switch (unit) {
             case "h":
-                return significantPart * 60;
-            case "mi":
-                return significantPart;
-            case "s:":
-                return significantPart / 60;
+                return (60).toTree();
+            case "min":
+                return (1).toTree();
+            case "s":
+                return frac(1, 60);
             case "ms":
-                return significantPart / 60000;
+                return frac(1, 60_000);
         }
-        return 0;
+    }
+    static getConversionFactor(from, to) {
+        return frac(TimeUnit.convertToMinute(from), TimeUnit.convertToMinute(to));
     }
 }

package/lib/tests/questionTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAwP3B,CAAC"}
+{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CA0P3B,CAAC"}

package/lib/tests/questionTest.js

@@ -195,7 +195,7 @@ export const questionTest = (exo, question) => {
             if (prop.statement.includes("[object Object]"))
                 throw new Error(`exo ${exo.id} has invalid prop (objectObject) : ${prop}`);
             if (!props.every((prop2) => prop2.id === prop.id || prop.statement !== prop2.statement))
-                throw new Error(`exo ${exo.id} has invalid prop (duplicate): ${prop}`);
+                throw new Error(`exo ${exo.id} has invalid prop (duplicate): ${prop.statement}`);
             if (prop.format !== "raw") {
                 if (!latexTester(prop.statement, true))
                     throw new Error(`exo ${exo.id} has invalid prop (latex error): ${prop}`);

package/lib/tests/singleExo.test.js

@@ -1,9 +1,9 @@
 import "../prototypesEnhancement.js";
 import { exoTest } from "./exoTest.js";
-import { decimalToScientific } from "../exercises/math/index.js";
+import { colinearityFromPicture, } from "../exercises/math/index.js";
 try {
-    for (let i = 0; i < 100; i++)
-        exoTest(decimalToScientific);
+    for (let i = 0; i < 1000; i++)
+        exoTest(colinearityFromPicture);
 }
 catch (err) {
     throw err;

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

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IAC5E,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,OAAO,KAAK,aAAa,CAAC;IACnE,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AACD,8BAAsB,cAAc;;IAElC,OAAO,CAAC,MAAM,CAAC,QAAQ;CAGxB;AACD,eAAO,MAAM,eAAe,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,aACI,CAAC"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;CAIxC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;IAC5E,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,OAAO,KAAK,aAAa,CAAC;IACnE,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AACD,8BAAsB,cAAc;;IAElC,OAAO,CAAC,MAAM,CAAC,QAAQ;CAGxB;AACD,eAAO,MAAM,eAAe,GAAI,MAAM,IAAI,KAAG,IAAI,IAAI,aACI,CAAC"}

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

@@ -1,5 +1,5 @@
 import { Node, NodeIds, NodeOptions, NodeType, ToTexOptions } from "../node.js";
-import { CommutativeOperatorNode, DeepShuffleOpts, OperatorIds } from "./operatorNode.js";
+import { CommutativeOperatorNode, OperatorIds } from "./operatorNode.js";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 export declare function isAddNode(a: Node): a is AddNode;
 export declare const add: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string) => AddNode;
@@ -11,8 +11,10 @@ export declare class AddNode implements CommutativeOperatorNode {
     opts?: NodeOptions;
     isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
+    /**
+     * @deprecated This function is outdated. Use `NodeShuffler.shuffle` instead.
+     */
     shuffle: () => AddNode;
-    deepShuffle: (opts?: DeepShuffleOpts) => AddNode;
     toMathString(): string;
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
     toAllTexs(): string[];

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,EAGZ,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,GACd,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,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,GAAI,OAAO,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,EAAE,IAAI,UAAQ,GAAG,aAAa;IAsJ7D,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,WAAW,EAEZ,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAerE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,GACd,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,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;;OAEG;IACH,OAAO,gBAIL;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,EAAE,IAAI,UAAQ,GAAG,aAAa;IAsJ7D,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

@@ -1,7 +1,6 @@
 // import { add } from "mathjs";
 import { NodeIds, NodeType } from "../node.js";
-import { OperatorIds, isCommutativeOperatorNode, isOperatorNode, } from "./operatorNode.js";
-import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { OperatorIds, isOperatorNode, } from "./operatorNode.js";
 import { permute } from "../../../utils/arrays/permutations.js";
 import { getCartesiansProducts } from "../../../utils/arrays/cartesianProducts.js";
 import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
@@ -13,6 +12,7 @@ import { FractionNode, isFractionNode } from "./fractionNode.js";
 import { colorize } from "../../../utils/latex/colorize.js";
 import { round } from "../../../math/utils/round.js";
 import { MonomNode, isMonom, parseToMonomNode, } from "../polynomials/monomNode.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
 export function isAddNode(a) {
     return isOperatorNode(a) && a.id === OperatorIds.add;
 }
@@ -36,22 +36,13 @@ export class AddNode {
         this.opts = opts;
         this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
     }
+    /**
+     * @deprecated This function is outdated. Use `NodeShuffler.shuffle` instead.
+     */
     shuffle = () => {
-        if (coinFlip())
-            return this;
-        return new AddNode(this.rightChild, this.leftChild, this.opts);
-    };
-    deepShuffle = (opts) => {
-        const left = isCommutativeOperatorNode(this.leftChild)
-            ? this.leftChild.deepShuffle(opts)
-            : this.leftChild;
-        const right = isCommutativeOperatorNode(this.rightChild)
-            ? this.rightChild.deepShuffle(opts)
-            : this.rightChild;
-        if (coinFlip() && (!opts || opts?.nodeIdsToShuffle?.includes(this.id)))
-            return new AddNode(right, left, this.opts);
-        else
-            return new AddNode(left, right, this.opts);
+        // return NodeShuffler.shuffle(this); //this causes an import death loop
+        const shuffledChildren = shuffle([this.leftChild, this.rightChild]);
+        return new AddNode(shuffledChildren[0], shuffledChildren[1]);
     };
     toMathString() {
         return `${this.leftChild.toMathString()} + (${this.rightChild.toMathString()})`;

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

@@ -33,6 +33,6 @@ export declare class FractionNode implements OperatorNode {
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): FractionNode;
     toSimplificationTex(): string;
-    derivative(_varName?: string | undefined): AlgebraicNode;
+    derivative(_varName?: string): AlgebraicNode;
 }
 //# sourceMappingURL=fractionNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.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;AAK9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKrE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAMxD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,IAAI,GACf,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,iBAOnB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AACF,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,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;IAiBpB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,uBAAuB;IAQxC,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,SAAS;IAoBT,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IA8BrC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,UAAQ,GAAG,aAAa;IA0M5D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,mBAAmB;IAQnB,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGzD"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.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;AAK9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKrE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAMxD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,IAAI,GACf,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,iBAOnB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AACF,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,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;IAiBpB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,uBAAuB;IAQxC,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,SAAS;IAoBT,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IA8BrC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,GAAG,UAAQ,GAAG,aAAa;IA8M5D,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,mBAAmB;IAQnB,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,aAAa;CAG7C"}

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

@@ -262,8 +262,12 @@ export class FractionNode {
         let counter = 0;
         const simplifyIteration = () => {
             counter++;
-            if (counter > 1000)
+            // if (opts?.nbMaxSteps && counter > opts?.nbMaxSteps) {
+            //   return;
+            // }
+            if (counter > 1000) {
                 throw new Error(`should-throw Too many iterations in simplify, ${this.toTex()}`);
+            }
             for (let i = 0; i < externalsNums.length; i++) {
                 const num = externalsNums[i];
                 for (let j = 0; j < externalsDenums.length; j++) {

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

@@ -1,5 +1,5 @@
 import { Node, NodeIds, NodeOptions, NodeType, ToTexOptions } from "../node.js";
-import { CommutativeOperatorNode, DeepShuffleOpts, OperatorIds } from "./operatorNode.js";
+import { CommutativeOperatorNode, OperatorIds } from "./operatorNode.js";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 export declare function isMultiplyNode(a: Node): a is MultiplyNode;
 export declare const multiply: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string, opts?: NodeOptions) => MultiplyNode;
@@ -12,8 +12,10 @@ export declare class MultiplyNode implements CommutativeOperatorNode {
     type: NodeType;
     isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
+    /**
+     * @deprecated This function is outdated. Use `NodeShuffler.shuffle` instead.
+     */
     shuffle: () => MultiplyNode;
-    deepShuffle: (opts?: DeepShuffleOpts) => MultiplyNode;
     toReversed: () => MultiplyNode;
     toMathString(): string;
     toTex(options?: ToTexOptions): 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;AAiB3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAWrE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,GACnB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,GAAI,KAAK,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,GAAI,OAAO,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,EAAE,GAAG,UAAQ,GAAG,aAAa;IAiK5D,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,WAAW,EAEZ,MAAM,mBAAmB,CAAC;AAgB3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAYrE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,GACnB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,OAAO,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,GAAI,KAAK,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;;OAEG;IACH,OAAO,qBAIL;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,EAAE,GAAG,UAAQ,GAAG,aAAa;IAiK5D,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

@@ -1,7 +1,6 @@
 // import { multiply } from "mathjs";
 import { NodeIds, NodeType } from "../node.js";
-import { OperatorIds, isCommutativeOperatorNode, isOperatorNode, } from "./operatorNode.js";
-import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { OperatorIds, isOperatorNode, } from "./operatorNode.js";
 import { permute } from "../../../utils/arrays/permutations.js";
 import { getCartesiansProducts, getFlatCartesianProducts, } from "../../../utils/arrays/cartesianProducts.js";
 import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
@@ -19,6 +18,7 @@ import { colorize } from "../../../utils/latex/colorize.js";
 import { isSubstractNode } from "./substractNode.js";
 import { isConstantNode } from "../numbers/constantNode.js";
 import { ExpNode, isExpNode } from "../functions/expNode.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
 export function isMultiplyNode(a) {
     return isOperatorNode(a) && a.id === OperatorIds.multiply;
 }
@@ -53,22 +53,13 @@ export class MultiplyNode {
         this.opts = opts;
         this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
     }
+    /**
+     * @deprecated This function is outdated. Use `NodeShuffler.shuffle` instead.
+     */
     shuffle = () => {
-        if (coinFlip())
-            return this;
-        return new MultiplyNode(this.rightChild, this.leftChild, this.opts);
-    };
-    deepShuffle = (opts) => {
-        const left = isCommutativeOperatorNode(this.leftChild)
-            ? this.leftChild.deepShuffle(opts)
-            : this.leftChild;
-        const right = isCommutativeOperatorNode(this.rightChild)
-            ? this.rightChild.deepShuffle(opts)
-            : this.rightChild;
-        if (coinFlip() && (!opts || opts?.nodeIdsToShuffle?.includes(this.id)))
-            return new MultiplyNode(right, left, this.opts);
-        else
-            return new MultiplyNode(left, right, this.opts);
+        // return NodeShuffler.shuffle(this); //this causes an import death loop
+        const shuffledChildren = shuffle([this.leftChild, this.rightChild]);
+        return new MultiplyNode(shuffledChildren[0], shuffledChildren[1]);
     };
     toReversed = () => {
         return new MultiplyNode(this.rightChild, this.leftChild, this.opts);

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

@@ -20,11 +20,11 @@ export interface OperatorNode extends AlgebraicNode {
 export declare function isOperatorNode(a: Node): a is OperatorNode;
 export declare function isCommutativeOperatorNode(a: Node): a is CommutativeOperatorNode;
 export type DeepShuffleOpts = {
-    nodeIdsToShuffle: OperatorIds[];
+    nodeTypesToShuffle: string[];
+    nodeTypesNoFurther: string[];
 };
 export interface CommutativeOperatorNode extends OperatorNode {
-    shuffle: () => CommutativeOperatorNode;
-    deepShuffle: (opts?: DeepShuffleOpts) => CommutativeOperatorNode;
+    shuffle: () => AlgebraicNode;
     toAllTexs: () => string[];
 }
 //# sourceMappingURL=operatorNode.d.ts.map

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,EAAY,MAAM,YAAY,CAAC;AAE5C,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"}
+{"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,EAAY,MAAM,YAAY,CAAC;AAE5C,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,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,MAAM,WAAW,uBAAwB,SAAQ,YAAY;IAC3D,OAAO,EAAE,MAAM,aAAa,CAAC;IAE7B,SAAS,EAAE,MAAM,MAAM,EAAE,CAAC;CAC3B"}

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

@@ -19,6 +19,6 @@ export declare class VariableNode extends CAlgebraicNode implements AlgebraicNod
     simplify(): this;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): AlgebraicNode;
-    derivative(varName?: string | undefined): AlgebraicNode;
+    derivative(varName?: string): AlgebraicNode;
 }
 //# sourceMappingURL=variableNode.d.ts.map

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

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

package/lib/tree/utilities/nodeShuffler.d.ts

@@ -0,0 +1,12 @@
+import { AlgebraicNode } from "../nodes/algebraicNode.js";
+export type DeepShuffleOpts = {
+    nodeTypesToShuffle: string[];
+    nodeTypesNoFurther: string[];
+};
+export declare abstract class NodeShuffler {
+    static shuffle: <T extends AlgebraicNode>(algebraicNode: T, shuffleArrayIn?: number[]) => AlgebraicNode;
+    static deepShuffle: <T extends AlgebraicNode>(algebraicNode: T, deepShuffleOpts?: DeepShuffleOpts, shuffleArrayIn?: number[]) => AlgebraicNode;
+    private static getCreateNodeFromChildrenFunction;
+    static getChildren(algebraicNode: AlgebraicNode): AlgebraicNode[];
+}
+//# sourceMappingURL=nodeShuffler.d.ts.map

package/lib/tree/utilities/nodeShuffler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeShuffler.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeShuffler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AA8B1D,MAAM,MAAM,eAAe,GAAG;IAC5B,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,8BAAsB,YAAY;IAChC,MAAM,CAAC,OAAO,GAAI,CAAC,SAAS,aAAa,EACvC,eAAe,CAAC,EAChB,iBAAiB,MAAM,EAAE,KACxB,aAAa,CAQd;IAGF,MAAM,CAAC,WAAW,GAAI,CAAC,SAAS,aAAa,EAC3C,eAAe,CAAC,EAChB,kBAAiB,eAGhB,EACD,iBAAiB,MAAM,EAAE,KACxB,aAAa,CAyBd;IAEF,OAAO,CAAC,MAAM,CAAC,iCAAiC,CAgF9C;IAEF,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,aAAa;CAShD"}

package/lib/tree/utilities/nodeShuffler.js

@@ -0,0 +1,123 @@
+import { shuffle } from "../../utils/alea/shuffle.js";
+import { abs } from "../nodes/functions/absNode.js";
+import { arccos } from "../nodes/functions/arccosNode.js";
+import { CosNode } from "../nodes/functions/cosNode.js";
+import { FunctionsIds, isFunctionNode, } from "../nodes/functions/functionNode.js";
+import { AddNode } from "../nodes/operators/addNode.js";
+import { BinomialCoefficientNode } from "../nodes/operators/binomialCoefficientNode.js";
+import { DivideNode } from "../nodes/operators/divideNode.js";
+import { FractionNode } from "../nodes/operators/fractionNode.js";
+import { MultiplyNode } from "../nodes/operators/multiplyNode.js";
+import { PowerNode } from "../nodes/operators/powerNode.js";
+import { SubstractNode } from "../nodes/operators/substractNode.js";
+import { sin } from "../nodes/functions/sinNode.js";
+import { sqrt } from "../nodes/functions/sqrtNode.js";
+import { tan } from "../nodes/functions/tanNode.js";
+import { ArcsinNode } from "../nodes/functions/arcSinNode.js";
+import { ArctanNode } from "../nodes/functions/arctanNode.js";
+import { ExpNode } from "../nodes/functions/expNode.js";
+import { LogNode } from "../nodes/functions/logNode.js";
+import { Log10Node } from "../nodes/functions/log10Node.js";
+import { NodeConstructor } from "../nodes/nodeConstructor.js";
+import { isOperatorNode, OperatorIds, } from "../nodes/operators/operatorNode.js";
+import { opposite } from "../nodes/functions/oppositeNode.js";
+export class NodeShuffler {
+    static shuffle = (algebraicNode, shuffleArrayIn) => {
+        const children = this.getChildren(algebraicNode);
+        const shuffleArray = shuffleArrayIn ?? shuffle([...Array(children.length).keys()]);
+        const shuffledChildren = shuffleArray.map((iTo) => children[iTo]);
+        return this.getCreateNodeFromChildrenFunction(algebraicNode)(shuffledChildren);
+    };
+    //commutative by default
+    static deepShuffle = (algebraicNode, deepShuffleOpts = {
+        nodeTypesToShuffle: ["AddNode", "MultiplyNode"],
+        nodeTypesNoFurther: [],
+    }, shuffleArrayIn) => {
+        const isCanBeTraversed = !deepShuffleOpts.nodeTypesNoFurther.includes(algebraicNode.constructor.name);
+        const children = this.getChildren(algebraicNode).map((childNode) => isCanBeTraversed
+            ? this.deepShuffle(childNode, deepShuffleOpts, shuffleArrayIn)
+            : childNode);
+        const createNodeFromChildren = this.getCreateNodeFromChildrenFunction(algebraicNode);
+        if (children.length > 0) {
+            const isCanBeShuffled = (deepShuffleOpts?.nodeTypesToShuffle ?? []).includes(algebraicNode.constructor.name);
+            if (isCanBeShuffled) {
+                const shuffleArray = shuffleArrayIn ?? shuffle([...Array(children.length).keys()]);
+                const shuffledChildren = shuffleArray.map((iTo) => children[iTo]);
+                return createNodeFromChildren(shuffledChildren);
+            }
+            else {
+                createNodeFromChildren(children);
+            }
+        }
+        return createNodeFromChildren(children);
+    };
+    static getCreateNodeFromChildrenFunction = (algebraicNode) => {
+        if (isOperatorNode(algebraicNode)) {
+            switch (algebraicNode.id) {
+                case OperatorIds.binomialCoefficient:
+                    return (children) => new BinomialCoefficientNode(children[0], children[1], algebraicNode.opts);
+                case OperatorIds.divide:
+                    return (children) => new DivideNode(children[0], children[1]);
+                case OperatorIds.fraction:
+                    return (children) => new FractionNode(children[0], children[1], algebraicNode.opts);
+                case OperatorIds.integral:
+                    //   throw new Error("unsupported node type: integral");  //need to do intelligent shuffle here
+                    return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
+                case OperatorIds.limit:
+                    //   throw new Error("unsupported node type: limit");   //need to do intelligent shuffle here
+                    return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
+                case OperatorIds.multiply:
+                    return (children) => new MultiplyNode(children[0], children[1], algebraicNode.opts);
+                case OperatorIds.power:
+                case OperatorIds.square: //this is so nice
+                    return (children) => new PowerNode(children[0], children[1], algebraicNode.opts);
+                case OperatorIds.substract:
+                    return (children) => new SubstractNode(children[0], children[1], algebraicNode.opts);
+                case OperatorIds.add:
+                    return (children) => new AddNode(children[0], children[1], algebraicNode.opts);
+            }
+        }
+        else if (isFunctionNode(algebraicNode)) {
+            switch (algebraicNode.id) {
+                case FunctionsIds.arccos:
+                    return (children) => arccos(children[0]);
+                case FunctionsIds.arcsin:
+                    return (children) => new ArcsinNode(children[0]);
+                case FunctionsIds.arctan:
+                    return (children) => new ArctanNode(children[0]);
+                case FunctionsIds.cos:
+                    return (children) => new CosNode(children[0]);
+                case FunctionsIds.exp:
+                    return (children) => new ExpNode(children[0], algebraicNode.opts);
+                case FunctionsIds.log:
+                    return (children) => new LogNode(children[0], algebraicNode.opts);
+                case FunctionsIds.log10:
+                    return (children) => new Log10Node(children[0], algebraicNode.opts);
+                case FunctionsIds.opposite:
+                    return (children) => opposite(children[0]);
+                case FunctionsIds.sin:
+                    return (children) => sin(children[0]);
+                case FunctionsIds.sqrt:
+                    return (children) => sqrt(children[0]);
+                case FunctionsIds.tan:
+                    return (children) => tan(children[0]);
+                case FunctionsIds.abs:
+                    return (children) => abs(children[0]);
+            }
+        }
+        else {
+            return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
+        }
+    };
+    static getChildren(algebraicNode) {
+        if (isOperatorNode(algebraicNode)) {
+            return [algebraicNode.leftChild, algebraicNode.rightChild];
+        }
+        else if (isFunctionNode(algebraicNode)) {
+            return [algebraicNode.child];
+        }
+        else {
+            return [];
+        }
+    }
+}

package/lib/utils/arrays/getAllPicks.d.ts

@@ -0,0 +1,2 @@
+export declare function getAllPicks<T>(array: T[]): T[][];
+//# sourceMappingURL=getAllPicks.d.ts.map

package/lib/utils/arrays/getAllPicks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAllPicks.d.ts","sourceRoot":"","sources":["../../../src/utils/arrays/getAllPicks.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,CAoBhD"}

package/lib/utils/arrays/getAllPicks.js

@@ -0,0 +1,17 @@
+export function getAllPicks(array) {
+    const result = [];
+    const generateSubsets = (current, index) => {
+        if (index === array.length) {
+            result.push([...current]);
+            return;
+        }
+        // Exclude the current element
+        generateSubsets(current, index + 1);
+        // Include the current element
+        current.push(array[index]);
+        generateSubsets(current, index + 1);
+        current.pop();
+    };
+    generateSubsets([], 0);
+    return result;
+}

package/lib/utils/errors/handleVEAError.d.ts

@@ -1,2 +1,2 @@
-export declare const handleVEAError: (err: Error | unknown) => false;
+export declare const handleVEAError: (err: unknown) => false;
 //# sourceMappingURL=handleVEAError.d.ts.map

package/lib/utils/errors/handleVEAError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handleVEAError.d.ts","sourceRoot":"","sources":["../../../src/utils/errors/handleVEAError.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,GAAI,KAAK,KAAK,GAAG,OAAO,KAAG,KAIrD,CAAC"}
+{"version":3,"file":"handleVEAError.d.ts","sourceRoot":"","sources":["../../../src/utils/errors/handleVEAError.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,GAAI,KAAK,OAAO,KAAG,KAI7C,CAAC"}

package/lib/utils/strings/decapitalize.d.ts

@@ -0,0 +1,2 @@
+export declare function decapitalize(str: string): string;
+//# sourceMappingURL=decapitalize.d.ts.map

package/lib/utils/strings/decapitalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decapitalize.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/decapitalize.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/lib/utils/strings/decapitalize.js

@@ -0,0 +1,3 @@
+export function decapitalize(str) {
+    return str.charAt(0).toLocaleLowerCase() + str.slice(1);
+}

package/package.json

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