math-exercises 3.0.125 → 3.0.126

package/lib/math/geometry/CloudPoints.js

@@ -7,6 +7,8 @@ import { AddNode } from "../../tree/nodes/operators/addNode.js";
 import { randint } from "../utils/random/randint.js";
 import { covarianceXY } from "../utils/stats/covariance.js";
 import { variance } from "../utils/stats/variance.js";
+import { randfloat } from "../utils/random/randfloat.js";
+import { coinFlip } from "../../utils/alea/coinFlip.js";
 export class CloudPointsConstructor {
     static random(nbPoints) {
         const names = [];
@@ -32,6 +34,99 @@ export class CloudPointsConstructor {
         });
         return new CloudPoints(points);
     }
+    static randomWithEvolutionType(nbPoints, evolutionType) {
+        const boxRunning = {
+            xMin: 0,
+            xMax: 0.5,
+            yMin: 0,
+            yMax: 1,
+        };
+        let firstPoint;
+        switch (evolutionType) {
+            case "increasing":
+                {
+                    firstPoint = new Point("P_0", boxRunning.xMin, boxRunning.yMin);
+                }
+                break;
+            case "decreasing":
+                {
+                    firstPoint = new Point("P_0", boxRunning.xMin, boxRunning.yMax);
+                }
+                break;
+            case "scatter":
+            default:
+                {
+                    firstPoint = new Point("P_0", boxRunning.xMin, randfloat(boxRunning.yMin, boxRunning.yMax));
+                }
+                break;
+        }
+        const points = [firstPoint];
+        const zeroOne = coinFlip() ? 0 : 1;
+        for (let i = 0; i < nbPoints - 1; i++) {
+            const point = new Point(`P_${i}`, randfloat(boxRunning.xMin, boxRunning.xMax), randfloat(boxRunning.yMin, boxRunning.yMax));
+            boxRunning.xMin = point.x.evaluate();
+            boxRunning.xMax = boxRunning.xMax + 0.5 / (nbPoints - 1);
+            switch (evolutionType) {
+                case "increasing":
+                    {
+                        boxRunning.yMin = point.y.evaluate();
+                    }
+                    break;
+                case "decreasing":
+                    {
+                        boxRunning.yMax = point.y.evaluate();
+                    }
+                    break;
+                case "scatter":
+                    {
+                        if (i % 2 === zeroOne) {
+                            boxRunning.yMin = point.y.evaluate();
+                            boxRunning.yMax = 1;
+                        }
+                        else {
+                            boxRunning.yMin = 0;
+                            boxRunning.yMax = point.y.evaluate();
+                        }
+                    }
+                    break;
+            }
+            points.push(point);
+        }
+        return new CloudPoints(points);
+    }
+    static cloudPointsByReboxingCloudPoints(cloudPoints, boxTarget) {
+        const boxFrom = { xMin: NaN, xMax: NaN, yMin: NaN, yMax: NaN };
+        cloudPoints.points.forEach((point, i) => {
+            const x = point.x.evaluate();
+            const y = point.y.evaluate();
+            boxFrom.xMin = i === 0 ? x : Math.min(x, boxFrom.xMin);
+            boxFrom.xMax = i === 0 ? x : Math.max(x, boxFrom.xMax);
+            boxFrom.yMin = i === 0 ? y : Math.min(y, boxFrom.yMin);
+            boxFrom.yMax = i === 0 ? y : Math.max(y, boxFrom.yMax);
+        });
+        //allow zero slope: prevent overboxing
+        const boxFromYXRatio = (boxFrom.yMax - boxFrom.yMin) / (boxFrom.xMax - boxFrom.xMin);
+        if (boxFromYXRatio < 0.33) {
+            boxFrom.yMin =
+                boxFrom.yMin - (boxFrom.yMax - boxFrom.yMin) / boxFromYXRatio;
+            boxFrom.yMax =
+                boxFrom.yMax + (boxFrom.yMax - boxFrom.yMin) / boxFromYXRatio;
+        }
+        const pointsReboxed = cloudPoints.points.map((point) => {
+            const x = point.x.evaluate();
+            const y = point.y.evaluate();
+            const progressX = (x - boxFrom.xMin) / (boxFrom.xMax - boxFrom.xMin);
+            const progressY = (y - boxFrom.yMin) / (boxFrom.yMax - boxFrom.yMin);
+            const xReboxed = boxTarget.xMin + progressX * (boxTarget.xMax - boxTarget.xMin);
+            const yReboxed = boxTarget.yMin + progressY * (boxTarget.yMax - boxTarget.yMin);
+            return new Point(point.name, xReboxed, yReboxed);
+        });
+        return new CloudPoints(pointsReboxed);
+    }
+    static fromIdentifiers(cloudPointsIdentifiers) {
+        const points = cloudPointsIdentifiers.pointsIdentifiers.map((pIds) => PointConstructor.fromIdentifiers(pIds));
+        return new CloudPoints(points);
+    }
 }
 export class CloudPoints {
     points;
@@ -74,6 +169,11 @@ export class CloudPoints {
         const b = avgY - a * avgX;
         return new EqualNode(new VariableNode("y"), new AddNode(new MultiplyNode(new NumberNode(+a.toFixed(2)), new VariableNode("x")).simplify(), new NumberNode(+b.toFixed(2))));
     }
+    getSlopeNode() {
+        const equalNode = this.getFineAdjustement();
+        return equalNode.rightChild.leftChild
+            .leftChild;
+    }
     getCorrelationCoeff() {
         const xValues = this.points.map((point) => {
             return point.getXnumber();
@@ -92,4 +192,23 @@ export class CloudPoints {
         const yVariance = variance(yValues, avgY);
         return new NumberNode(+(covXY / Math.sqrt(xVariance * yVariance)).toFixed(2));
     }
+    getEvolutionType() {
+        const pointsSortedByXIncreasing = this.points.toSorted((p1, p2) => p1.x.evaluate() - p2.x.evaluate());
+        const pointsSortedByYIncreasing = this.points.toSorted((p1, p2) => p1.y.evaluate() - p2.y.evaluate());
+        const isIncreasing = pointsSortedByXIncreasing.every((point, i) => point === pointsSortedByYIncreasing[i]);
+        if (isIncreasing) {
+            return "increasing";
+        }
+        else {
+            const isDecreasing = pointsSortedByXIncreasing
+                .toReversed()
+                .every((point, i) => point === pointsSortedByYIncreasing[i]);
+            if (isDecreasing) {
+                return "decreasing";
+            }
+            else {
+                return "scatter";
+            }
+        }
+    }
 }

package/lib/math/geometry/line.d.ts

@@ -46,5 +46,6 @@ export declare class Line {
     toTexNoLeftRight(): string;
     toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, color, label, }?: ToGGBCommandsProps): string[];
     intersect(line: Line, intersectName?: string): Point;
+    translate(x: AlgebraicNode | number, y: AlgebraicNode | number): Line;
 }
 //# sourceMappingURL=line.d.ts.map

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,EAAS,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmB3E,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;IAGnC,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;IAItD,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,SAAS;CAsBnC;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,MAAM,SAAI;IAkBjC,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,iBAAiB,QAAO,SAAS,CAO/B;IAEF,oBAAoB,IAAI,SAAS;IAUjC,iBAAiB;IA2BjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAEhC,KAAiB,EACjB,KAAiB,GAClB,GAAE,kBAAuB;IA2C5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAY7C"}
+{"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;AAmB3E,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;IAGnC,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;IAItD,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,SAAS;CAsBnC;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;gBAGd,MAAM,EAAE,KAAK,EACb,MAAM,EAAE,KAAK,EACb,IAAI,CAAC,EAAE,MAAM;IA4Bf,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,MAAM,SAAI;IAkBjC,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,iBAAiB,QAAO,SAAS,CAO/B;IAEF,oBAAoB,IAAI,SAAS;IAUjC,iBAAiB;IA2BjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAEhC,KAAiB,EACjB,KAAiB,GAClB,GAAE,kBAAuB;IA2C5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;IAa5C,SAAS,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,EAAE,CAAC,EAAE,aAAa,GAAG,MAAM;CAG/D"}

package/lib/math/geometry/line.js

@@ -59,6 +59,7 @@ export class Line {
     name;
     unformatedName;
     ggbName;
+    //!TODO Sebastien : "_nbMaxStepsForSimplify" ne doit pas être nécessaire, à fix
     constructor(pointA, pointB, name) {
         this.pointA = pointA;
         this.pointB = pointB;
@@ -71,8 +72,12 @@ export class Line {
             this.b = undefined;
         }
         else {
-            this.a = new FractionNode(new SubstractNode(this.pointB.y, this.pointA.y), new SubstractNode(this.pointB.x, this.pointA.x)).simplify();
-            this.b = new SubstractNode(this.pointA.y, new MultiplyNode(this.a, this.pointA.x)).simplify();
+            this.a = new FractionNode(new SubstractNode(this.pointB.y, this.pointA.y), new SubstractNode(this.pointB.x, this.pointA.x)).simplify({
+            // nbMaxSteps: _nbMaxStepsForSimplify,
+            });
+            this.b = new SubstractNode(this.pointA.y, new MultiplyNode(this.a, this.pointA.x)).simplify({
+            // nbMaxSteps: _nbMaxStepsForSimplify,
+            });
         }
     }
     toIdentifiers() {
@@ -244,4 +249,7 @@ export class Line {
         const solve = sys.solve();
         return new Point(intersectName ?? "I", solve.x, solve.y);
     }
+    translate(x, y) {
+        return new Line(this.pointA.translate(x, y), this.pointB.translate(x, y));
+    }
 }

package/lib/math/geometry/vector.d.ts

@@ -48,5 +48,6 @@ export declare class Vector {
     getOrthogonal(): Vector;
     isNull(): boolean;
     toGGBCommands(): never[];
+    rotate(angle: number, name: string): Vector;
 }
 //# sourceMappingURL=vector.d.ts.map

package/lib/math/geometry/vector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAoB7C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOvD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,MAAM;IAOtD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;IAGnC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,iBAAiB;CAOtD;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAEF,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,QAAQ;IAIR,KAAK,IAAI,MAAM;IAIf,aAAa,IAAI,iBAAiB;IAOlC,eAAe,IAAI,MAAM;IAMzB,QAAQ,IAAI,MAAM;IAIlB,oBAAoB,IAAI,MAAM;IAG9B,aAAa;IAGb,iBAAiB,IAAI,MAAM;IAM3B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAK9B,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI1C,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAItC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAIrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,QAAQ;IAGR,aAAa,CAAC,CAAC,EAAE,MAAM;IAIvB,mBAAmB,CAAC,CAAC,EAAE,MAAM;IAO7B,QAAQ;IAGR,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM;IAwB7B,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAWtB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAG5B,OAAO,IAAI,aAAa;IAUxB,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB,YAAY;IAMZ,YAAY;IAOZ,aAAa;IAIb,MAAM;IAGN,aAAa;CAGd"}
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAoB7C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOpD,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM;IAOvD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,MAAM;IAOtD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;IAGnC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,iBAAiB;CAOtD;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAEF,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAO5D,QAAQ;IAIR,KAAK,IAAI,MAAM;IAIf,aAAa,IAAI,iBAAiB;IAOlC,eAAe,IAAI,MAAM;IAMzB,QAAQ,IAAI,MAAM;IAIlB,oBAAoB,IAAI,MAAM;IAG9B,aAAa;IAGb,iBAAiB,IAAI,MAAM;IAM3B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAK9B,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI1C,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAItC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa;IAIrC,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAOrC,QAAQ;IAGR,aAAa,CAAC,CAAC,EAAE,MAAM;IAIvB,mBAAmB,CAAC,CAAC,EAAE,MAAM;IAO7B,QAAQ;IAGR,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM;IAwB7B,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAWtB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAG5B,OAAO,IAAI,aAAa;IAUxB,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAO5C,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB,YAAY;IAMZ,YAAY;IAOZ,aAAa;IAIb,MAAM;IAGN,aAAa;IAKb,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAqBnC"}

package/lib/math/geometry/vector.js

@@ -164,4 +164,16 @@ export class Vector {
     toGGBCommands() {
         return [];
     }
+    //!TODO Sebastien : "_nbMaxStepsForSimplify" ne doit pas être nécessaire, à fix
+    rotate(angle, name) {
+        //x' = cos(t)*x -sin(t)*y
+        //y' = sin(t)*x + cos(t)*y
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        return new Vector(name, substract(multiply(cos, this.x).simplify(), multiply(sin, this.y).simplify()).simplify({
+        // nbMaxSteps: _nbMaxStepsForSimplify,
+        }), add(multiply(sin, this.x).simplify(), multiply(cos, this.y).simplify()).simplify({
+        // nbMaxSteps: _nbMaxStepsForSimplify,
+        }));
+    }
 }

package/lib/math/progCalc/progCalc.d.ts

@@ -0,0 +1,46 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { VariableNode } from "../../tree/nodes/variables/variableNode.js";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
+export type ProgCalcOperator = "opposite" | "inverse" | "add" | "subtract" | "multiply" | "divide";
+export interface ProgCalcOperationGenerationConfig {
+    operator: ProgCalcOperator;
+    createParam: () => number | undefined;
+}
+export declare const arrOpGenConfigDefault: ProgCalcOperationGenerationConfig[];
+export declare abstract class ProgCalcOperationConstructor {
+    static randomFromOpGenConfig(opGenConfig: ProgCalcOperationGenerationConfig): ProgCalcOperation;
+    static fromIdentifiers(opIds: ProgCalcOperationIdentifiers): ProgCalcOperation;
+}
+export type ProgCalcOperationIdentifiers = {
+    operator: ProgCalcOperator;
+    param?: NodeIdentifiers;
+};
+export declare class ProgCalcOperation {
+    operationIds: ProgCalcOperationIdentifiers;
+    strFrench: string;
+    func: (node: AlgebraicNode) => AlgebraicNode;
+    inverseOperationIds: ProgCalcOperationIdentifiers;
+    constructor(operationIds: ProgCalcOperationIdentifiers, strFrench: string, func: (node: AlgebraicNode) => AlgebraicNode, inverseOperationIds: ProgCalcOperationIdentifiers);
+    getInverseOperation(): ProgCalcOperation;
+    toIdentifiers(): ProgCalcOperationIdentifiers;
+}
+export type ProgCalcIdentifiers = {
+    operationIds: ProgCalcOperationIdentifiers[];
+};
+export declare abstract class ProgCalcConstructor {
+    static random(nbSteps: number, isSingleUseOperators?: boolean, arrAvailableOpGenConfig?: ProgCalcOperationGenerationConfig[]): ProgCalc;
+    static randomWithMandatory(nbSteps: number, isSingleUseOperators: boolean, arrOpGenConfigMandatory: ProgCalcOperationGenerationConfig[], arrOpGenConfigAll: ProgCalcOperationGenerationConfig[]): ProgCalc;
+    static exampleRandomAffine(nbSteps?: number, isSingleUseOperators?: boolean): ProgCalc;
+    static randomMental(nbSteps: number, nodeStartingNumber: AlgebraicNode, nbDigits?: number, isSingleUseOperators?: boolean): ProgCalc;
+    static fromIdentifiers(pcIds: ProgCalcIdentifiers): ProgCalc;
+}
+export declare class ProgCalc {
+    operations: ProgCalcOperation[];
+    constructor(arrOperation: ProgCalcOperation[]);
+    apply(node: AlgebraicNode): AlgebraicNode;
+    getArrOfFrenchStrings(): string[];
+    getInverseProgCalc(): ProgCalc | undefined;
+    toTree(nodeVariable: VariableNode): AlgebraicNode;
+    toIdentifiers(): ProgCalcIdentifiers;
+}
+//# sourceMappingURL=progCalc.d.ts.map

package/lib/math/progCalc/progCalc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progCalc.d.ts","sourceRoot":"","sources":["../../../src/math/progCalc/progCalc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAI1E,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,gBAAgB,GACxB,UAAU,GACV,SAAS,GACT,KAAK,GACL,UAAU,GACV,UAAU,GACV,QAAQ,CAAC;AAEb,MAAM,WAAW,iCAAiC;IAChD,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,WAAW,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,eAAO,MAAM,qBAAqB,EAAE,iCAAiC,EA2BpE,CAAC;AAEF,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,qBAAqB,CAAC,WAAW,EAAE,iCAAiC;IAS3E,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAwE3D;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,YAAY,EAAE,4BAA4B,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,CAAC;IAC7C,mBAAmB,EAAE,4BAA4B,CAAC;gBAGhD,YAAY,EAAE,4BAA4B,EAC1C,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,EAC5C,mBAAmB,EAAE,4BAA4B;IAQnD,mBAAmB,IAAI,iBAAiB;IAMxC,aAAa,IAAI,4BAA4B;CAG9C;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,EAAE,4BAA4B,EAAE,CAAC;CAC9C,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,MAAM,EACf,oBAAoB,GAAE,OAAc,EACpC,uBAAuB,GAAE,iCAAiC,EAA0B;IAatF,MAAM,CAAC,mBAAmB,CACxB,OAAO,EAAE,MAAM,EACf,oBAAoB,EAAE,OAAO,EAC7B,uBAAuB,EAAE,iCAAiC,EAAE,EAC5D,iBAAiB,EAAE,iCAAiC,EAAE;IAyBxD,MAAM,CAAC,mBAAmB,CACxB,OAAO,GAAE,MAAU,EACnB,oBAAoB,GAAE,OAAc;IA6CtC,MAAM,CAAC,YAAY,CACjB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,aAAa,EACjC,QAAQ,GAAE,MAAU,EACpB,oBAAoB,GAAE,OAAc;IA2EtC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,mBAAmB;CAMlD;AAED,qBAAa,QAAQ;IACnB,UAAU,EAAE,iBAAiB,EAAE,CAAC;gBAEpB,YAAY,EAAE,iBAAiB,EAAE;IAI7C,KAAK,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa;IASzC,qBAAqB,IAAI,MAAM,EAAE;IAIjC,kBAAkB,IAAI,QAAQ,GAAG,SAAS;IAO1C,MAAM,CAAC,YAAY,EAAE,YAAY,GAAG,aAAa;IAIjD,aAAa,IAAI,mBAAmB;CAOrC"}

package/lib/math/progCalc/progCalc.js

@@ -0,0 +1,239 @@
+import { opposite } from "../../tree/nodes/functions/oppositeNode.js";
+import { add } from "../../tree/nodes/operators/addNode.js";
+import { frac } from "../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../tree/nodes/operators/substractNode.js";
+import { random, randomMany } from "../../utils/alea/random.js";
+import { randint } from "../utils/random/randint.js";
+import { isInt } from "../../utils/isInt.js";
+import { NodeConstructor, } from "../../tree/nodes/nodeConstructor.js";
+import { shuffle } from "../../utils/alea/shuffle.js";
+export const arrOpGenConfigDefault = [
+    {
+        operator: "opposite",
+        createParam: () => undefined,
+    },
+    {
+        operator: "inverse",
+        createParam: () => undefined,
+    },
+    {
+        operator: "add",
+        createParam: () => randint(-10, 11, []),
+    },
+    {
+        operator: "subtract",
+        createParam: () => randint(-10, 11, []),
+    },
+    {
+        operator: "multiply",
+        createParam: () => randint(-10, 11, [0]),
+    },
+    {
+        operator: "divide",
+        createParam: () => randint(-10, 11, [0]),
+    },
+];
+export class ProgCalcOperationConstructor {
+    static randomFromOpGenConfig(opGenConfig) {
+        const opIds = {
+            operator: opGenConfig.operator,
+            param: opGenConfig.createParam()?.toTree().toIdentifiers(),
+        };
+        return ProgCalcOperationConstructor.fromIdentifiers(opIds);
+    }
+    static fromIdentifiers(opIds) {
+        switch (opIds.operator) {
+            case "opposite":
+                return new ProgCalcOperation(opIds, `Prendre l'opposé`, (node) => opposite(node), { operator: "opposite" });
+            case "inverse":
+                return new ProgCalcOperation(opIds, `Prendre l'inverse`, (node) => frac(1, node), { operator: "inverse" });
+            case "add": {
+                const nodeParam = NodeConstructor.fromIdentifiers(opIds.param);
+                return new ProgCalcOperation(opIds, `Ajouter $ ${nodeParam.toTex()} $`, (nodeX) => add(nodeX, nodeParam), { operator: "subtract", param: opIds.param });
+            }
+            case "subtract": {
+                const nodeParam = NodeConstructor.fromIdentifiers(opIds.param);
+                const strFrench = random([
+                    `Soustraire $ ${nodeParam.toTex()} $`,
+                    `Oter $ ${nodeParam.toTex()} $`,
+                    `Enlever $ ${nodeParam.toTex()} $`,
+                ]);
+                return new ProgCalcOperation(opIds, strFrench, (nodeX) => substract(nodeX, nodeParam), { operator: "add", param: opIds.param });
+            }
+            case "multiply": {
+                const nodeParam = NodeConstructor.fromIdentifiers(opIds.param);
+                return new ProgCalcOperation(opIds, `Multiplier par $ ${nodeParam.toTex()} $`, (nodeX) => multiply(nodeX, nodeParam), { operator: "divide", param: opIds.param });
+            }
+            case "divide": {
+                const nodeParam = NodeConstructor.fromIdentifiers(opIds.param);
+                return new ProgCalcOperation(opIds, `Diviser par $ ${nodeParam.toTex()} $`, (nodeX) => frac(nodeX, nodeParam), { operator: "multiply", param: opIds.param });
+            }
+        }
+    }
+}
+export class ProgCalcOperation {
+    operationIds;
+    strFrench;
+    func;
+    inverseOperationIds;
+    constructor(operationIds, strFrench, func, inverseOperationIds) {
+        this.operationIds = operationIds;
+        this.strFrench = strFrench;
+        this.func = func;
+        this.inverseOperationIds = inverseOperationIds;
+    }
+    getInverseOperation() {
+        return ProgCalcOperationConstructor.fromIdentifiers(this.inverseOperationIds);
+    }
+    toIdentifiers() {
+        return this.operationIds;
+    }
+}
+export class ProgCalcConstructor {
+    static random(nbSteps, isSingleUseOperators = true, arrAvailableOpGenConfig = arrOpGenConfigDefault) {
+        const arrOpGenConfig = isSingleUseOperators
+            ? randomMany(arrAvailableOpGenConfig, nbSteps)
+            : [...Array(nbSteps).keys()].map(() => random(arrAvailableOpGenConfig));
+        return new ProgCalc(shuffle(arrOpGenConfig).map((opGenConfig) => ProgCalcOperationConstructor.randomFromOpGenConfig(opGenConfig)));
+    }
+    static randomWithMandatory(nbSteps, isSingleUseOperators, arrOpGenConfigMandatory, arrOpGenConfigAll) {
+        const nbFiller = nbSteps - arrOpGenConfigMandatory.length;
+        const arrOpGenConfigFiller = nbFiller > 0 && isSingleUseOperators
+            ? randomMany(arrOpGenConfigAll.filter((opGenConfig) => !arrOpGenConfigMandatory.includes(opGenConfig)), nbFiller)
+            : [...Array(nbFiller).keys()].map(() => random(arrOpGenConfigAll));
+        const arrOpGenConfig = [
+            ...arrOpGenConfigMandatory,
+            ...arrOpGenConfigFiller,
+        ];
+        return new ProgCalc(shuffle(arrOpGenConfig).map((opGenConfig) => ProgCalcOperationConstructor.randomFromOpGenConfig(opGenConfig)));
+    }
+    static exampleRandomAffine(nbSteps = 2, isSingleUseOperators = true) {
+        const arrOpGenAddsub = [
+            {
+                operator: "add",
+                createParam: () => randint(-10, 11, [0]),
+            },
+            {
+                operator: "subtract",
+                createParam: () => randint(-10, 11, [0]),
+            },
+        ];
+        const arrOpGenMuldiv = [
+            {
+                operator: "opposite",
+                createParam: () => undefined,
+            },
+            {
+                operator: "multiply",
+                createParam: () => randint(-10, 11, [0, 1]),
+            },
+            {
+                operator: "divide",
+                createParam: () => randint(-10, 11, [0, 1]),
+            },
+        ];
+        const arrOpGenConfigAll = [...arrOpGenAddsub, ...arrOpGenMuldiv];
+        //ensure that there is at least 1 addsub and 1 muldiv operation
+        const opGenConfigAddsub = random(arrOpGenAddsub);
+        const opGenConfigMuldiv = random(arrOpGenMuldiv);
+        const arrOpGenConfigMandatory = shuffle([
+            opGenConfigAddsub,
+            opGenConfigMuldiv,
+        ]);
+        return ProgCalcConstructor.randomWithMandatory(nbSteps, isSingleUseOperators, arrOpGenConfigMandatory, arrOpGenConfigAll);
+    }
+    static randomMental(nbSteps, nodeStartingNumber, nbDigits = 0, isSingleUseOperators = true) {
+        //we ensure that intermediate operations will yield a result with nbDigits
+        const arrOpGenAll = [
+            {
+                operator: "opposite",
+                createParam: () => undefined,
+            },
+            {
+                operator: "inverse",
+                createParam: () => undefined,
+            },
+            {
+                operator: "add",
+                createParam: () => randint(-10, 11, []),
+            },
+            {
+                operator: "subtract",
+                createParam: () => randint(-10, 11, []),
+            },
+            {
+                operator: "multiply",
+                createParam: () => randint(-10, 11, [0]),
+            },
+            {
+                operator: "divide",
+                createParam: () => randint(-10, 11, [0]),
+            },
+        ];
+        const arrOperation = [];
+        let nodeCurrent = nodeStartingNumber;
+        let arrAvailableOpGenConfigCurrent = arrOpGenAll;
+        for (let i = 0; i < nbSteps; i++) {
+            let isOperationValid = false;
+            let operation;
+            do {
+                const opGenConfig = random(arrAvailableOpGenConfigCurrent.filter((opGenConfig) => {
+                    const isZero = nodeCurrent.evaluate() === 0;
+                    return !(opGenConfig.operator === "inverse" && isZero);
+                }));
+                operation =
+                    ProgCalcOperationConstructor.randomFromOpGenConfig(opGenConfig);
+                const nodeResult = operation.func(nodeCurrent);
+                const numberResult = nodeResult.evaluate();
+                const isValidResult = isInt(numberResult * Math.pow(10, nbDigits));
+                if (isValidResult) {
+                    isOperationValid = true;
+                    nodeCurrent = nodeResult;
+                    const operatorUsed = operation.operationIds.operator;
+                    if (isSingleUseOperators) {
+                        arrAvailableOpGenConfigCurrent =
+                            arrAvailableOpGenConfigCurrent.filter((opGenConfig) => opGenConfig.operator !== operatorUsed);
+                    }
+                }
+            } while (!isOperationValid);
+            arrOperation.push(operation);
+        }
+        return new ProgCalc(arrOperation);
+    }
+    static fromIdentifiers(pcIds) {
+        const arrOperation = pcIds.operationIds.map(ProgCalcOperationConstructor.fromIdentifiers);
+        return new ProgCalc(arrOperation);
+    }
+}
+export class ProgCalc {
+    operations;
+    constructor(arrOperation) {
+        this.operations = arrOperation;
+    }
+    apply(node) {
+        let nodeCurrent = node;
+        for (let i = 0; i < this.operations.length; i++) {
+            const operation = this.operations[i];
+            nodeCurrent = operation.func(nodeCurrent);
+        }
+        return nodeCurrent;
+    }
+    getArrOfFrenchStrings() {
+        return this.operations.map((op) => op.strFrench);
+    }
+    getInverseProgCalc() {
+        const arrOpInverse = this.operations
+            .reverse()
+            .map((op) => op.getInverseOperation());
+        return new ProgCalc(arrOpInverse);
+    }
+    toTree(nodeVariable) {
+        return this.apply(nodeVariable);
+    }
+    toIdentifiers() {
+        return {
+            operationIds: this.operations.map((operation) => operation.toIdentifiers()),
+        };
+    }
+}

package/lib/math/utils/latex/realize.d.ts

@@ -0,0 +1,12 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+import { EqualNode } from "../../../tree/nodes/equations/equalNode.js";
+import { InequationNode } from "../../../tree/nodes/inequations/inequationNode.js";
+export type RandomNodeType = "I" | "RI" | "H" | "RH" | "F" | CustomRandomNodeType;
+export type CustomRandomNodeType = {
+    custom: () => AlgebraicNode;
+};
+export declare function randomNodeWithType(rvType: RandomNodeType): AlgebraicNode | import("../../../tree/nodes/numbers/constantNode.js").ConstantNode | import("../../../tree/nodes/numbers/numberNode.js").NumberNode;
+export declare function realize(varNameToGenType: Record<string, RandomNodeType>): (str: string) => string;
+export declare function realizeLatex(varNameToGenType: Record<string, RandomNodeType>): (str: string) => AlgebraicNode | EqualNode | InequationNode;
+export declare function realizeAlgebraic(varNameToGenType: Record<string, RandomNodeType>): (str: string) => AlgebraicNode | EqualNode | InequationNode;
+//# sourceMappingURL=realize.d.ts.map

package/lib/math/utils/latex/realize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realize.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/latex/realize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAC;AAKhF,MAAM,MAAM,cAAc,GACtB,GAAG,GACH,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,GAAG,GACH,oBAAoB,CAAC;AACzB,MAAM,MAAM,oBAAoB,GAAG;IAAE,MAAM,EAAE,MAAM,aAAa,CAAA;CAAE,CAAC;AAEnE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,uJAiBxD;AAED,wBAAgB,OAAO,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,IACrD,KAAK,MAAM,KAAG,MAAM,CAStC;AAED,wBAAgB,YAAY,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,IAC1D,KAAK,MAAM,KAAG,aAAa,GAAG,SAAS,GAAG,cAAc,CAG1E;AAED,wBAAgB,gBAAgB,CAC9B,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,IAE/B,KAAK,MAAM,KAAG,aAAa,GAAG,SAAS,GAAG,cAAc,CAG1E"}

package/lib/math/utils/latex/realize.js

@@ -0,0 +1,43 @@
+import { parseAlgebraic, parseLatex } from "../../../tree/parsers/latexParser.js";
+import { randfloat } from "../random/randfloat.js";
+import { randint } from "../random/randint.js";
+export function randomNodeWithType(rvType) {
+    if (typeof rvType !== "string") {
+        return rvType.custom();
+    }
+    else {
+        switch (rvType) {
+            case "I":
+                return randint(1, 10).toTree();
+            case "RI":
+                return randint(-9, 10, [0]).toTree();
+            case "H":
+                return randint(1, 100).toTree();
+            case "RH":
+                return randint(-99, 100, [0]).toTree();
+            case "F":
+                return randfloat(0, 1, 2, [0]).toTree();
+        }
+    }
+}
+export function realize(varNameToGenType) {
+    return function (str) {
+        let outStr = str;
+        Object.keys(varNameToGenType).forEach((key) => {
+            const randomNodeType = varNameToGenType[key];
+            const tex = `{${randomNodeWithType(randomNodeType).toTex()}}`;
+            outStr = outStr.replaceAll(key, tex);
+        });
+        return outStr;
+    };
+}
+export function realizeLatex(varNameToGenType) {
+    return function (str) {
+        return parseLatex(realize(varNameToGenType)(str));
+    };
+}
+export function realizeAlgebraic(varNameToGenType) {
+    return function (str) {
+        return parseAlgebraic(realize(varNameToGenType)(str));
+    };
+}

package/lib/pc/constants/molecularChemistry/molecule.d.ts

@@ -19,6 +19,8 @@ export declare class Molecule {
     iupact?: string;
     type?: string;
     constructor(name: string, formula: string, weight: number, atoms: AtomShortcut[], isOrganic: boolean, state: "solid" | "liquid" | "gas" | "aqueous", iupact?: string, type?: string);
+    static electronegativityOrder: Record<string, number>;
+    getRawFormula(): string;
 }
 export declare const molecules: Molecule[];
 export {};

package/lib/pc/constants/molecularChemistry/molecule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"molecule.d.ts","sourceRoot":"","sources":["../../../../src/pc/constants/molecularChemistry/molecule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAU,MAAM,YAAY,CAAC;AAE3C,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AACD,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAYF,qBAAa,QAAQ;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;gBAGZ,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,YAAY,EAAE,EACrB,SAAS,EAAE,OAAO,EAClB,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,EAC7C,MAAM,CAAC,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM;CAiBhB;AAED,eAAO,MAAM,SAAS,YA43CrB,CAAC"}
+{"version":3,"file":"molecule.d.ts","sourceRoot":"","sources":["../../../../src/pc/constants/molecularChemistry/molecule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAU,MAAM,YAAY,CAAC;AAE3C,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AACD,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAYF,qBAAa,QAAQ;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;gBAGZ,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,YAAY,EAAE,EACrB,SAAS,EAAE,OAAO,EAClB,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,EAC7C,MAAM,CAAC,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM;IAkBf,MAAM,CAAC,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BhD;IAEL,aAAa;CAmCd;AAED,eAAO,MAAM,SAAS,YA43CrB,CAAC"}

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"),