math-exercises 3.0.214 → 3.0.216

package/lib/math/matrices/matrix.js

@@ -1,10 +1,51 @@
-import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode.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 { frac } from "../../tree/nodes/operators/fractionNode.js";
+import { multiply, MultiplyNode, } from "../../tree/nodes/operators/multiplyNode.js";
 import { SubstractNode } from "../../tree/nodes/operators/substractNode.js";
+import { NodeComparator } from "../../tree/utilities/nodeComparator.js";
+import { zip } from "../../utils/arrays/arrayZip.js";
+import { transpose } from "../../utils/arrays/transpose.js";
+import { doWhile } from "../../utils/doWhile.js";
 import { randint } from "../utils/random/randint.js";
 export class MatrixConstructor {
-    static random(rows, cols) {
-        const elts = Array.from(Array(rows), (_) => Array.from(Array(cols), (_) => randint(-10, 11).toTree()));
-        return new Matrix(elts);
+    static random(rows, cols, opts) {
+        const allowIdentity = opts?.allowIdentity ?? false;
+        const elementsOpts = opts?.elementsOpts ?? [-10, 11];
+        const mat = doWhile(() => new Matrix(Array.from(Array(rows), (_) => Array.from(Array(cols), (_) => randint(...elementsOpts).toTree()))), (m) => !allowIdentity && m.isIdentity());
+        return mat;
+    }
+    static identity(order) {
+        return new Matrix(Array.from(Array(order), (_, i) => Array.from(Array(order), (_, i2) => i === i2 ? (1).toTree() : (0).toTree())));
+    }
+    static randomInversible(rows, cols, opts) {
+        const mat = doWhile(() => MatrixConstructor.random(rows, cols, opts), (m) => {
+            const det = m.determinant().evaluate();
+            return det === 0 || (!!opts?.niceInversible && Math.abs(det) > 10);
+        });
+        return mat;
+    }
+    static fromIdentifiers(identifiers) {
+        return new Matrix(identifiers.elementsIds.map((row) => row.map((cell) => reifyAlgebraic(cell))));
+    }
+    static emptyVarMatrix(nbRows, nbCols) {
+        const nodeVarEmpty = "".toTree();
+        const elements = [...Array(nbRows).keys()].map(() => [...Array(nbCols).keys()].map(() => nodeVarEmpty));
+        return new Matrix(elements);
+    }
+    static randomAdjacent(length, opts) {
+        const nbs = Array.from({ length }, () => Array(length).fill(0));
+        for (let i = 0; i < length; i++) {
+            for (let j = 0; j <= i; j++) {
+                if (!opts?.adjacentAllowLoop && j === i)
+                    nbs[i][j] = 0;
+                else
+                    nbs[i][j] = randint(0, 2);
+                nbs[j][i] = nbs[i][j];
+            }
+        }
+        return new Matrix(nbs.map((row) => row.map((nb) => nb.toTree())));
     }
 }
 export class Matrix {
@@ -16,15 +57,140 @@ export class Matrix {
         this.columns = elements[0].length;
         this.rows = elements.length;
     }
+    transposed() {
+        return new Matrix(transpose(this.elements));
+    }
+    isSymmetrical() {
+        return [...new Array(this.rows).keys()]
+            .flatMap((i) => [...new Array(this.columns).keys()].map((j) => [i, j]))
+            .every(([i, j]) => NodeComparator.isEqualViaSub(this.elements[i][j], this.elements[j][i]));
+    }
+    symmetrized() {
+        return this.add(this.transposed()).times(frac(1, 2));
+    }
+    toIdentifiers() {
+        return {
+            id: "matrix",
+            elementsIds: this.elements.map((row) => row.map((cell) => cell.toIdentifiers())),
+        };
+    }
     determinant() {
         if (this.rows === 2 && this.columns === 2) {
-            return new SubstractNode(new MultiplyNode(this.elements[0][0], this.elements[1][1]), new MultiplyNode(this.elements[0][1], this.elements[1][0])).simplify();
+            return new SubstractNode(new MultiplyNode(this.elements[0][0], this.elements[1][1]), new MultiplyNode(this.elements[0][1], this.elements[1][0]));
         }
         throw Error("general determinant not implemented yet");
     }
+    toInversed() {
+        if (this.rows !== 2 || this.columns !== 2)
+            throw Error("general inverse not implemented yet");
+        const det = this.determinant();
+        if (det.simplify().toTex() === "0")
+            throw Error("matrix is not inversible");
+        return new Matrix([
+            [this.elements[1][1], opposite(this.elements[0][1])],
+            [opposite(this.elements[1][0]), this.elements[0][0]],
+        ]).times(frac(1, det));
+    }
+    isIdentity() {
+        if (this.rows !== this.columns) {
+            return false;
+        }
+        return (this.elements.every((row, index) => row[index].equals((1).toTree())) &&
+            this.elements.every((row, index) => row.every((cell, index2) => cell.equals((0).toTree()) || index === index2)));
+    }
+    isTransition() {
+        return (this.elements
+            .flat()
+            .every((x) => x.evaluate() >= 0 && x.evaluate() <= 1) &&
+            this.elements.every((row) => row
+                .reduce((acc, curr) => add(acc, curr).simplify(), (0).toTree())
+                .evaluate() === 1));
+    }
+    inverse() {
+        if (this.rows === 2 && this.columns === 2) {
+            const nodeDet = this.determinant().simplify({ towardsDistribute: true });
+            if (NodeComparator.isEqualViaSub(nodeDet, (0).toTree())) {
+                return undefined;
+            }
+            else {
+                const [[a, b], [c, d]] = this.elements;
+                return new Matrix([
+                    [d, opposite(b)],
+                    [opposite(c), a],
+                ]).times(frac(1, nodeDet));
+            }
+        }
+        throw Error("general inverse not implemented yet");
+    }
+    density() {
+        const nbElementsNonZero = this.elements
+            .flat()
+            .filter((elt) => !NodeComparator.isEqualViaSub(elt, (0).toTree())).length;
+        return nbElementsNonZero / (this.rows * this.columns);
+    }
+    matForMapFunc(func) {
+        const arrElementMapped = this.elements.map((row, i) => row.map((elt, j) => func(elt, i, j)));
+        return new Matrix(arrElementMapped);
+    }
+    times(k) {
+        const arrElementScaled = this.elements.map((row) => row.map((elt) => multiply(k, elt)));
+        return new Matrix(arrElementScaled);
+    }
+    opposite() {
+        return this.times((-1).toTree());
+    }
+    isMatAdditionPossible(matPrime) {
+        return this.rows === matPrime.rows && this.columns === matPrime.columns;
+    }
+    add(matPrime) {
+        const arrElementSum = zip(this.elements, matPrime.elements).map(([row, rowPrime]) => row.map((elt, i) => add(elt, rowPrime[i])));
+        return new Matrix(arrElementSum);
+    }
+    substract(matPrime) {
+        return this.add(matPrime.opposite());
+    }
+    isMatProductPossible(matPrime) {
+        return this.rows === matPrime.columns;
+    }
+    matrixProduct(matPrime) {
+        const matPrimeTransposed = matPrime.transposed();
+        const arrElementProduct = this.elements.map((row) => matPrimeTransposed.elements.map((column) => zip(row, column).reduce((acc, [nodeAik, nodeBkj], i) => {
+            const nodeAikBkj = multiply(nodeAik, nodeBkj, {
+                forceTimesSign: true,
+            });
+            if (i === 0) {
+                return nodeAikBkj;
+            }
+            else {
+                return add(acc, nodeAikBkj);
+            }
+        }, (0).toTree())));
+        return new Matrix(arrElementProduct);
+    }
+    power(exponent) {
+        return [...Array(exponent).keys()].reduce((acc, i) => {
+            if (i === 0) {
+                return this;
+            }
+            else {
+                return acc.matrixProduct(this);
+            }
+        }, this);
+    }
+    equals(matPrime) {
+        return this.elements.every((row, i) => row.every((elt, j) => {
+            const eltPrime = matPrime.elements[i][j];
+            return (NodeComparator.isEqualViaSub(eltPrime, elt) ||
+                NodeComparator.isEqualViaFrac(eltPrime, elt));
+        }));
+    }
     toTex() {
         return `\\begin{pmatrix}${this.elements
-            .map((row, index) => `${row.map((cell) => cell.toTex()).join("&")} ${index < this.elements.length - 1 ? "\\\\[6pt]" : ""}`)
-            .join("")}\\end{pmatrix}`;
+            .map((row) => `${row.map((cell) => cell.toTex()).join("&")}`)
+            .join("\\\\")}\\end{pmatrix}`;
+    }
+    simplify(simplifyOpts) {
+        const arrElementSimplified = this.elements.map((row) => row.map((elt) => elt.simplify(simplifyOpts)));
+        return new Matrix(arrElementSimplified);
     }
 }

package/lib/math/matrices/parseMatrix.d.ts

@@ -0,0 +1,3 @@
+import { Matrix } from "./matrix.js";
+export declare const parseMatrix: (tex: string) => Matrix;
+//# sourceMappingURL=parseMatrix.d.ts.map

package/lib/math/matrices/parseMatrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseMatrix.d.ts","sourceRoot":"","sources":["../../../src/math/matrices/parseMatrix.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,MAyBzC,CAAC"}

package/lib/math/matrices/parseMatrix.js

@@ -0,0 +1,22 @@
+import { parseAlgebraic } from "../../tree/parsers/latexParser.js";
+import { Matrix } from "./matrix.js";
+export const parseMatrix = (tex) => {
+    const parseMatrixToArrArrStr = (input) => {
+        // Extrait le contenu entre \begin{...} et \end{...}
+        const match = input.match(/\\begin\{[a-zA-Z*]+\}([\s\S]*)\\end\{[a-zA-Z*]+\}/);
+        const content = match ? match[1] : undefined;
+        if (content) {
+            return content
+                .split("\\\\") // sépare les lignes
+                .map((row) => row.trim())
+                .filter((row) => row.length > 0) // ignore une éventuelle ligne vide en fin
+                .map((row) => row.split("&").map((cell) => cell.trim()));
+        }
+        else {
+            throw new Error("Unsupported tex: " + tex);
+        }
+    };
+    const elts = parseMatrixToArrArrStr(tex).map((row) => row.map((str) => parseAlgebraic(str)));
+    const mat = new Matrix(elts);
+    return mat;
+};

package/lib/math/systems/generalSystem.d.ts

@@ -1,6 +1,7 @@
 import { AlgebraicNode, SimplifyOptions } from "../../tree/nodes/algebraicNode.js";
 import { EqualNode } from "../../tree/nodes/equations/equalNode.js";
 import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
+import { Matrix } from "../matrices/matrix.js";
 export declare abstract class GeneralSystemConstructor {
     static random(): GeneralSystem;
     static niceValues(): GeneralSystem;
@@ -17,6 +18,7 @@ export declare class GeneralSystem {
     getEqualNodes(varNames?: string[]): EqualNode[];
     checkCouple(x: AlgebraicNode, y: AlgebraicNode): boolean;
     multiplyEquation(nodes: AlgebraicNode[]): GeneralSystem;
+    getMatrix(): Matrix;
     solve(): {
         x: AlgebraicNode;
         y: AlgebraicNode;

package/lib/math/systems/generalSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generalSystem.d.ts","sourceRoot":"","sources":["../../../src/math/systems/generalSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAS,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAC3E,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,MAAM;IAeb,MAAM,CAAC,UAAU;IAiBjB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,wBAAwB;CAKrD;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,EAAE,eAAe,EAAE,EAAE,CAAC;CAChC,CAAC;AAEF,qBAAa,aAAa;IACxB,MAAM,EAAE,aAAa,EAAE,EAAE,CAAC;gBAId,MAAM,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,EAAE;IAKhD,aAAa,IAAI,wBAAwB;IAKzC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAM/B,aAAa,CAAC,QAAQ,GAAE,MAAM,EAAe;IAU7C,WAAW,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAQ9C,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE;IAUvC,KAAK;;;;IAoDL,KAAK,CAAC,QAAQ,GAAE,MAAM,EAAe;IAerC,eAAe,CACb,QAAQ,GAAE,MAAM,EAAe,EAC/B,eAAe,GAAE,OAAc;CAqIlC"}
+{"version":3,"file":"generalSystem.d.ts","sourceRoot":"","sources":["../../../src/math/systems/generalSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAS,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAC3E,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAI/C,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,MAAM;IAeb,MAAM,CAAC,UAAU;IAiBjB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,wBAAwB;CAKrD;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,EAAE,eAAe,EAAE,EAAE,CAAC;CAChC,CAAC;AAEF,qBAAa,aAAa;IACxB,MAAM,EAAE,aAAa,EAAE,EAAE,CAAC;gBAId,MAAM,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,EAAE;IAKhD,aAAa,IAAI,wBAAwB;IAKzC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAM/B,aAAa,CAAC,QAAQ,GAAE,MAAM,EAAe;IAU7C,WAAW,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAQ9C,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE;IAUvC,SAAS;IAIT,KAAK;;;;IAoDL,KAAK,CAAC,QAAQ,GAAE,MAAM,EAAe;IAerC,eAAe,CACb,QAAQ,GAAE,MAAM,EAAe,EAC/B,eAAe,GAAE,OAAc;CAqIlC"}

package/lib/math/systems/generalSystem.js

@@ -6,6 +6,7 @@ import { multiply } from "../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../tree/nodes/operators/substractNode.js";
 import { doWhile } from "../../utils/doWhile.js";
 import { alignTex } from "../../utils/latex/alignTex.js";
+import { Matrix } from "../matrices/matrix.js";
 import { lcm } from "../utils/arithmetic/lcm.js";
 import { randint } from "../utils/random/randint.js";
 export class GeneralSystemConstructor {
@@ -80,6 +81,10 @@ export class GeneralSystem {
                 : this.coeffs[1],
         ]);
     }
+    getMatrix() {
+        const coeffs = this.coeffs.map((row) => row.slice(0, row.length - 1));
+        return new Matrix(coeffs);
+    }
     solve() {
         if (this.coeffs.length !== 2)
             throw Error("General system resolution not implemented yet");

package/lib/math/utils/geometry/angleBetweenPoints.d.ts

@@ -0,0 +1,4 @@
+import { Point } from "../../../math/geometry/point.js";
+export declare const valueAngleBetweenPoints: (point1: Point, pointCenter: Point, point2: Point) => number;
+export declare const exactAngleCandidate: (valueAngle: number) => import("../../../tree/nodes/numbers/constantNode.js").ConstantNode | import("../../../tree/nodes/numbers/numberNode.js").NumberNode | import("../../../tree/nodes/operators/multiplyNode.js").MultiplyNode;
+//# sourceMappingURL=angleBetweenPoints.d.ts.map

package/lib/math/utils/geometry/angleBetweenPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angleBetweenPoints.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/geometry/angleBetweenPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AASrD,eAAO,MAAM,uBAAuB,GAClC,QAAQ,KAAK,EACb,aAAa,KAAK,EAClB,QAAQ,KAAK,WAoCd,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,4MAoCrD,CAAC"}

package/lib/math/utils/geometry/angleBetweenPoints.js

@@ -0,0 +1,58 @@
+import { SpaceVector } from "../../../math/geometry/spaceVector.js";
+import { VectorConstructor } from "../../../math/geometry/vector.js";
+import { opposite } from "../../../tree/nodes/functions/oppositeNode.js";
+import { PiNode } from "../../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
+export const valueAngleBetweenPoints = (point1, pointCenter, point2) => {
+    const vec1 = VectorConstructor.fromPoints(pointCenter, point1);
+    const vec2 = VectorConstructor.fromPoints(pointCenter, point2);
+    const [nodeNorm1, nodeNorm2] = [vec1, vec2].map((vec) => vec.getNorm());
+    const nodeScalarProduct = vec1.scalarProduct(vec2);
+    const nodeCosAngle = frac(nodeScalarProduct, multiply(nodeNorm1, nodeNorm2));
+    const valueCosAngle = Math.min(1, Math.max(-1, nodeCosAngle.evaluate()));
+    const valueAngle = (() => {
+        const valueAngleRaw = Math.acos(valueCosAngle);
+        const nodeVectorialProduct = (() => {
+            const spaceVec1 = new SpaceVector(vec1.name, vec1.x, vec1.y, (0).toTree());
+            const spaceVec2 = new SpaceVector(vec2.name, vec2.x, vec2.y, (0).toTree());
+            return spaceVec1.vetorialProduct(spaceVec2);
+        })();
+        if (nodeVectorialProduct.z.evaluate() > 0) {
+            return valueAngleRaw;
+        }
+        else {
+            return -valueAngleRaw;
+        }
+    })();
+    return valueAngle;
+};
+export const exactAngleCandidate = (valueAngle) => {
+    const nodeAngleExactCandidate = (() => {
+        if (Math.abs(valueAngle - 0) < 0.05) {
+            return (0).toTree();
+        }
+        else {
+            const sign = valueAngle >= 0 ? +1 : -1;
+            const nMax = 8; //Pi/8 is the limit
+            const [nodeAngleCandidate] = [...Array(nMax).keys()]
+                .map((i) => i + 1)
+                .flatMap((n) => {
+                const nodeAngleBase = frac(PiNode, n);
+                const arrNodeAngle = [...Array(n + 1).keys()].map((i) => {
+                    const nodeAngleCandidate = multiply(multiply(sign, i), nodeAngleBase);
+                    return nodeAngleCandidate;
+                });
+                return arrNodeAngle;
+            })
+                .filter((nodeAngleCandidate) => Math.abs(nodeAngleCandidate.evaluate() - valueAngle) < 0.05);
+            return nodeAngleCandidate;
+        }
+    })();
+    if (nodeAngleExactCandidate &&
+        NodeComparator.isEqualViaSub(nodeAngleExactCandidate, opposite(PiNode))) {
+        return PiNode;
+    }
+    return nodeAngleExactCandidate;
+};

package/lib/math/utils/geometry/angleNWSE.d.ts

@@ -0,0 +1,3 @@
+export declare function createTypeAngleSectorNWSE(valueAngle: number): "E" | "N" | "S" | "W";
+export declare function createTypeAngleSectorNWSESecondary(valueAngle: number): "WSW" | "SSW" | "SSE" | "ESE" | "ENE" | "NNE" | "NNW" | "WNW";
+//# sourceMappingURL=angleNWSE.d.ts.map

package/lib/math/utils/geometry/angleNWSE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angleNWSE.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/geometry/angleNWSE.ts"],"names":[],"mappings":"AAEA,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,yBAyB3D;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,iEA2CpE"}

package/lib/math/utils/geometry/angleNWSE.js

@@ -0,0 +1,56 @@
+import { PiNode } from "../../../tree/nodes/numbers/piNode.js";
+export function createTypeAngleSectorNWSE(valueAngle) {
+    const valuePi = PiNode.evaluate();
+    const valueAngleOffsetForTuningSectors = valuePi * 0.25; //ici on veut des secteurs de type N W S E
+    const valueAngleInMinusPiPlusPi = (valueAngle - valueAngleOffsetForTuningSectors) % valuePi;
+    if (-valuePi <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < -valuePi * 0.5) {
+        return "S";
+    }
+    else if (-valuePi * 0.5 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < 0) {
+        return "W";
+    }
+    else if (0 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < valuePi * 0.5) {
+        return "N";
+    }
+    else {
+        return "E";
+    }
+}
+export function createTypeAngleSectorNWSESecondary(valueAngle) {
+    const valuePi = PiNode.evaluate();
+    const valueAngleInMinusPiPlusPi = valueAngle % valuePi;
+    if (-valuePi <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < -valuePi * 0.75) {
+        return "WSW";
+    }
+    else if (-valuePi * 0.75 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < -valuePi * 0.5) {
+        return "SSW";
+    }
+    else if (-valuePi * 0.5 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < -valuePi * 0.25) {
+        return "SSE";
+    }
+    else if (-valuePi * 0.25 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < 0) {
+        return "ESE";
+    }
+    else if (0 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < valuePi * 0.25) {
+        return "ENE";
+    }
+    else if (valuePi * 0.25 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < valuePi * 0.5) {
+        return "NNE";
+    }
+    else if (valuePi * 0.5 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < valuePi * 0.75) {
+        return "NNW";
+    }
+    else {
+        return "WNW";
+    }
+}

package/lib/math/utils/graphs/graphRenderer.d.ts

@@ -0,0 +1,25 @@
+import { Graph } from "../../graphs/graph.js";
+import * as TSGraphViz from "ts-graphviz";
+import { Engine } from "@hpcc-js/wasm-graphviz";
+export interface GraphNode {
+    label: string;
+    x: number;
+    y: number;
+}
+export interface GraphEdge {
+    from: string;
+    to: string;
+}
+export declare class GraphRenderer {
+    static convertToGraphVizGraph(graph: Graph): TSGraphViz.Digraph;
+    static renderToSVG(graph: Graph, layoutEngineIn?: Engine): string;
+    static convertSVGToNodesAndEdges(strSVG: string): {
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    };
+    static renderToNodesAndEdges(graph: Graph, layoutEngineIn?: Engine): {
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    };
+}
+//# sourceMappingURL=graphRenderer.d.ts.map

package/lib/math/utils/graphs/graphRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphRenderer.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/graphs/graphRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE9C,OAAO,KAAK,UAAU,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAY,MAAM,wBAAwB,CAAC;AAM1D,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,qBAAa,aAAa;IACxB,MAAM,CAAC,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAAC,OAAO;IAkE/D,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,cAAc,CAAC,EAAE,MAAM;IA0BxD,MAAM,CAAC,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG;QAChD,KAAK,EAAE,SAAS,EAAE,CAAC;QACnB,KAAK,EAAE,SAAS,EAAE,CAAC;KACpB;IAwDD,MAAM,CAAC,qBAAqB,CAAC,KAAK,EAAE,KAAK,EAAE,cAAc,CAAC,EAAE,MAAM;eA1DzD,SAAS,EAAE;eACX,SAAS,EAAE;;CA6DrB"}

package/lib/math/utils/graphs/graphRenderer.js

@@ -0,0 +1,123 @@
+import * as TSGraphViz from "ts-graphviz";
+import { Graphviz } from "@hpcc-js/wasm-graphviz";
+const graphviz = await Graphviz.load();
+import { JSDOM } from "jsdom";
+import { random } from "../../../utils/alea/random.js";
+export class GraphRenderer {
+    static convertToGraphVizGraph(graph) {
+        const digraph = new TSGraphViz.Digraph();
+        // Create nodes
+        const dictGraphvizNode = Object.fromEntries(graph.vertexNames.map((nameVertex) => {
+            const graphvizNode = new TSGraphViz.Node(nameVertex, {});
+            return [nameVertex, graphvizNode];
+        }));
+        // Create edges between the nodes
+        const arrConnectionNoDuplicate = (() => {
+            const arrConnection = Object.entries(graph.dictConnections()).flatMap(([nameVertexStart, dictConnections]) => {
+                return Object.entries(dictConnections)
+                    .filter(([_, isConnection]) => isConnection)
+                    .map(([nameVertexEnd, _]) => [nameVertexStart, nameVertexEnd]);
+            });
+            if (graph.isDirected) {
+                return arrConnection;
+            }
+            else {
+                return arrConnection
+                    .map(([nameVertexStart, nameVertexEnd]) => [nameVertexStart, nameVertexEnd].join("-"))
+                    .reduce((acc, strEdge) => {
+                    const strEdgeReversed = strEdge.split("").toReversed().join("");
+                    if (acc.includes(strEdgeReversed)) {
+                        //ignore
+                    }
+                    else {
+                        acc = [...acc, strEdge];
+                    }
+                    return acc;
+                }, [])
+                    .map((strEdge) => {
+                    const [nameVertexStart, nameVertexEnd] = strEdge.split("-");
+                    return [nameVertexStart, nameVertexEnd];
+                });
+            }
+        })();
+        const arrEdge = arrConnectionNoDuplicate.map(([nameVertexStart, nameVertexEnd]) => {
+            const [graphvizNodeStart, graphvizNodeEnd] = [
+                nameVertexStart,
+                nameVertexEnd,
+            ].map((nameVertex) => dictGraphvizNode[nameVertex]);
+            const graphvizEdge = new TSGraphViz.Edge([graphvizNodeStart, graphvizNodeEnd], {});
+            return graphvizEdge;
+        });
+        // Add elements to the graph
+        Object.entries(dictGraphvizNode).forEach(([_, graphvizNode]) => digraph.addNode(graphvizNode));
+        arrEdge.forEach((graphvizEdge) => digraph.addEdge(graphvizEdge));
+        return digraph;
+    }
+    static renderToSVG(graph, layoutEngineIn) {
+        const digraph = GraphRenderer.convertToGraphVizGraph(graph);
+        const dot = TSGraphViz.toDot(digraph);
+        // Render DOT to SVG
+        /*
+        const arrLayoutEngine = [
+          "circo",
+          "dot",
+          "fdp",
+          "neato",
+          "nop",
+          "nop2",
+          // "osage",
+          // "patchwork",
+          "sfdp",
+          "twopi",
+        ];
+        */
+        const layoutEngine = layoutEngineIn ?? random(["fdp", "circo"]);
+        const svg = graphviz.layout(dot, "svg", layoutEngine);
+        return svg;
+    }
+    static convertSVGToNodesAndEdges(strSVG) {
+        function parseSvgGraph(svgString) {
+            const domParser = new new JSDOM().window.DOMParser();
+            const doc = domParser.parseFromString(svgString, "image/svg+xml");
+            const svgEl = doc.querySelector("svg");
+            const height = parseFloat(svgEl?.getAttribute("height") ?? "0");
+            // Translation du groupe racine (pattern classique Graphviz)
+            const graphGroup = doc.querySelector("g.graph") ?? doc.querySelector("svg > g");
+            const transform = graphGroup?.getAttribute("transform") ?? "";
+            const match = transform.match(/translate\(([-\d.]+)[ ,]([-\d.]+)\)/);
+            const [tx, ty] = match
+                ? [parseFloat(match[1]), parseFloat(match[2])]
+                : [0, 0];
+            // Sommets
+            const nodes = Array.from(doc.querySelectorAll("g.node")).map((g) => {
+                const ellipse = g.querySelector("ellipse");
+                const text = g.querySelector("text");
+                const label = text?.textContent?.trim() ??
+                    g.querySelector("title")?.textContent?.trim() ??
+                    "";
+                const cx = parseFloat(ellipse?.getAttribute("cx") ?? "0");
+                const cy = parseFloat(ellipse?.getAttribute("cy") ?? "0");
+                return {
+                    label,
+                    x: cx + tx,
+                    y: height - (cy + ty), // flip vertical SVG -> GeoGebra
+                };
+            });
+            // Arêtes : lues directement depuis le <title> de chaque g.edge (ex: "A->B")
+            const edges = Array.from(doc.querySelectorAll("g.edge"))
+                .map((g) => g.querySelector("title")?.textContent?.trim() ?? "")
+                .map((title) => {
+                const [from, to] = title.split(/-&gt;|->/).map((s) => s.trim());
+                return { from, to };
+            })
+                .filter((e) => Boolean(e.from && e.to));
+            return { nodes, edges };
+        }
+        const { nodes, edges } = parseSvgGraph(strSVG);
+        return { nodes, edges };
+    }
+    static renderToNodesAndEdges(graph, layoutEngineIn) {
+        const strSVG = this.renderToSVG(graph, layoutEngineIn);
+        return this.convertSVGToNodesAndEdges(strSVG);
+    }
+}

package/lib/playground.d.ts

@@ -1,2 +1,7 @@
-export declare const playground: () => void;
+export declare const playground: () => Promise<void>;
+/***
+ *
+ * !!TODO
+ *  - j'ai l'impression que opposite(3).simplify() et numberNode(-3) ne passent pas tjrs "equals", j'ai du mal à comprendre pourquoi alors que opposite(3) se simplifie bien en numberNode
+ */
 //# sourceMappingURL=playground.d.ts.map

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,YAGtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,qBAAiB,CAAC;AAEzC;;;;GAIG"}

package/lib/playground.js

@@ -1,5 +1,6 @@
-import { parseAlgebraic } from "./tree/parsers/latexParser.js";
-export const playground = () => {
-    const a = "8^9\\cos^3";
-    console.log(parseAlgebraic(a).toTex());
-};
+export const playground = async () => { };
+/***
+ *
+ * !!TODO
+ *  - j'ai l'impression que opposite(3).simplify() et numberNode(-3) ne passent pas tjrs "equals", j'ai du mal à comprendre pourquoi alors que opposite(3) se simplifie bien en numberNode
+ */

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

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

package/lib/tests/singleExo.test.js

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

package/lib/tree/parsers/latexParser.d.ts

@@ -7,6 +7,6 @@ type ParserOptions = {
     allowStartingPower?: boolean;
 };
 export declare const parseAlgebraic: (latex: string, opts?: ParserOptions) => AlgebraicNode | IDontKnowNode;
-export declare const parseLatex: (latex: string) => AlgebraicNode | EqualNode | InequationNode | IDontKnowNode;
+export declare const parseLatex: (latex: string) => AlgebraicNode | EqualNode | IDontKnowNode | InequationNode;
 export {};
 //# sourceMappingURL=latexParser.d.ts.map

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

@@ -2,7 +2,7 @@ import { AlgebraicNode, SimplifyOptions } from "../nodes/algebraicNode.js";
 import { ToTexOptions } from "../nodes/node.js";
 export declare abstract class NodeSimplifier {
     static getDepth: <T extends AlgebraicNode>(algebraicNode: T, simplifyOpts: SimplifyOptions, toTexOptions?: ToTexOptions) => number;
-    static getPEMDASPriority: (algebraicNode: AlgebraicNode) => 1 | 0 | 2 | 100 | -1 | 3 | 5 | 4;
+    static getPEMDASPriority: (algebraicNode: AlgebraicNode) => 1 | 0 | 2 | 100 | -1 | 5 | 3 | 4;
     static nodesSortedByPEMDASPriorityAsc: (nodes: AlgebraicNode[]) => AlgebraicNode[];
     static nodesStepByStep: <T extends AlgebraicNode>(algebraicNode: T, simplifyOpts: SimplifyOptions, simplifierOpts?: {
         isMultiTopLevel: boolean;

package/lib/types/keyIds.d.ts

@@ -27,6 +27,8 @@ export type KeyId =
  | "guillemet" | "quote" | "hyphen" | "euro" | "space" | "underscore" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "É" | "È" | "Ç" | "À" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "é" | "è" | "à" | "ç" | "ù" | "ô"
 /**numbers */
  | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
+/**matrix*/
+ | "mat-2-2" | "det-2-2"
 /**atoms */
  | "Hydrogène" | "Hélium" | "Lithium" | "Béryllium" | "Bore" | "Carbone" | "Azote" | "Oxygène" | "Fluor" | "Néon" | "Sodium" | "Magnésium" | "Aluminium" | "Silicium" | "Phosphore" | "Soufre" | "Chlore" | "Argon" | "Potassium" | "Calcium" | "Scandium" | "Titane" | "Vanadium" | "Chrome" | "Manganèse" | "Fer" | "Cobalt" | "Nickel" | "Cuivre" | "Zinc" | "Gallium" | "Germanium" | "Arsenic" | "Sélénium" | "Brome" | "Krypton" | "Rubidium" | "Strontium" | "Yttrium" | "Zirconium" | "Niobium" | "Molybdène" | "Technétium" | "Ruthénium" | "Rhodium" | "Palladium" | "Argent" | "Cadmium" | "Indium" | "Étain" | "Antimoine" | "Tellure" | "Iode" | "Xénon" | "Césium" | "Baryum" | "Lanthane" | "Cérium" | "Praséodyme" | "Néodyme" | "Prométhium" | "Samarium" | "Europium" | "Gadolinium" | "Térbium" | "Dysprosium" | "Holmium" | "Erbium" | "Thulium" | "Ytterbium" | "Lutétium" | "Hafnium" | "Tantale" | "Tungstène" | "Rhénium" | "Osmium" | "Iridium" | "Platine" | "Or" | "Mercure" | "Thallium" | "Plomb" | "Bismuth" | "Polonium" | "Astate" | "Radon" | "Francium" | "Radium" | "Actinium" | "Thorium" | "Protactinium" | "Uranium" | "Neptunium" | "Plutonium" | "Américium" | "Curium" | "Berkélium" | "Californium" | "Einsteinium" | "Fermium" | "Mendélévium" | "Nobelium" | "Lawrencium" | "Rutherfordium" | "Dubnium" | "Seaborgium" | "Bohrium" | "Hassium" | "Meitnérium" | "Darmstadtium" | "Roentgenium" | "Copernicium" | "Nihonium" | "Flerovium" | "Moscovium" | "Livermorium" | "Tennessine" | "Oganesson"
 /**Molecules */