math-exercises 3.0.214 → 3.0.216

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

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

package/lib/math/geometry/point.js

@@ -160,7 +160,9 @@ export class Point {
     }
     toGGBCommand({ isFixed = true, isSelectionnable = false, showLabel = true, style, size, color, label, isVisible = true, } = {}) {
         const commands = [
-            `${this.name} = Point({${this.x.toMathString()}, ${this.y.toMathString()}})`,
+            `${this.name} = ${isFixed
+                ? `Point({${this.x.toMathString()}, ${this.y.toMathString()}})`
+                : `(${this.x.toMathString()}, ${this.y.toMathString()})`}`,
             `SetFixed(${this.name},${isFixed ? "true" : "false"},${isSelectionnable ? "true" : "false"})`,
             `ShowLabel(${this.name},${showLabel ? "true" : "false"})`,
         ];

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

@@ -39,7 +39,7 @@ export declare class Segment {
         color?: string;
         size?: "scriptsize" | "tiny" | "small" | "large";
     }): string[];
-    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showLength, style, thickness, }?: ToGGBCommandsProps): string[];
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, isSelectionnable, showLabel, showUnderlyingPointsLabel, showLength, style, thickness, color, }?: ToGGBCommandsProps): string[];
     includes(point: Point): boolean;
     toVector(): import("./vector.js").Vector;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGvE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAOb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAYvD;AAED,KAAK,uBAAuB,GAAG;IAC7B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,KAAK,YAAY,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3E,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;gBACT,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,YAAY;IAS9D,aAAa,IAAI,kBAAkB;IAUnC,WAAW;IAGX,SAAS;IAST,aAAa;IAYb,KAAK;IAGL,YAAY;IAGZ,WAAW;IAGX,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAiBN,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,UAAkB,EAClB,KAAK,EACL,SAAS,GACV,GAAE,kBAAuB;IAkC5B,QAAQ,CAAC,KAAK,EAAE,KAAK;IAOrB,QAAQ;CAGT"}
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGvE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAOb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAYvD;AAED,KAAK,uBAAuB,GAAG;IAC7B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,KAAK,YAAY,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3E,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;gBACT,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,YAAY;IAS9D,aAAa,IAAI,kBAAkB;IAUnC,WAAW;IAGX,SAAS;IAST,aAAa;IAYb,KAAK;IAGL,YAAY;IAGZ,WAAW;IAGX,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAiBN,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,gBAAuB,EACvB,SAAiB,EACjB,yBAAgC,EAChC,UAAkB,EAClB,KAAK,EACL,SAAS,EACT,KAAK,GACN,GAAE,kBAAuB;IAqC5B,QAAQ,CAAC,KAAK,EAAE,KAAK;IAOrB,QAAQ;CAGT"}

package/lib/math/geometry/segment.js

@@ -89,12 +89,15 @@ export class Segment {
         }
         return cmds;
     }
-    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showLength = false, style, thickness, } = {}) {
+    toGGBCommands(shouldBuildPoints, { isFixed = true, isSelectionnable = true, showLabel = false, showUnderlyingPointsLabel = true, showLength = false, style, thickness, color, } = {}) {
         const commands = [
             `${this.ggbName}=Segment(${this.pointA.name},${this.pointB.name})`,
-            `SetFixed(${this.ggbName},${isFixed ? "true" : "false"},${isFixed ? "false" : "true"})`,
+            `SetFixed(${this.ggbName},${isFixed ? "true" : "false"},${isSelectionnable ? "true" : "false"})`,
             `ShowLabel(${this.ggbName},${showLabel ? "true" : "false"})`,
         ];
+        if (color !== undefined) {
+            commands.push(`SetColor(${this.ggbName}, ${color})`);
+        }
         if (style !== undefined) {
             commands.push(`SetLineStyle(${this.ggbName}, ${style})`);
         }

package/lib/math/graphs/graph.d.ts

@@ -0,0 +1,43 @@
+import { Matrix, MatrixIdentifiers } from "../matrices/matrix.js";
+export declare abstract class GraphConstructor {
+    static randomConnected(nbVertices: number, isSimple?: boolean, //simple === no loop A--A
+    isDirected?: boolean, minDensity?: number, poolVertexName?: string[]): Graph;
+    static random(nbVertices: number, isSimple?: boolean, //simple === no loop A--A
+    isDirected?: boolean, minDensity?: number, poolVertexName?: string[], isConnected?: boolean): Graph;
+    static randomChain(nbVertices: number, poolVertexName: string[] | undefined, isDirected: boolean): Graph;
+    static graphByMergingSimpleGraphs(arrGraph: Graph[]): Graph;
+    static graphByAddingRandomEdge(graph: Graph): Graph;
+    static fromIdentifiers(identifiers: GraphIdentifiers): Graph;
+}
+export type GraphIdentifiers = {
+    vertexNames: string[];
+    matIds: MatrixIdentifiers;
+    isDirected: boolean;
+};
+export declare class Graph {
+    vertexNames: string[];
+    mat: Matrix;
+    isDirected: boolean;
+    constructor(vertexNames: string[], mat: Matrix, isDirected?: boolean);
+    toIdentifiers(): GraphIdentifiers;
+    dictConnections(): Record<string, Record<string, boolean>>;
+    arrConnection(): [string, string, boolean][];
+    density(): number;
+    densifyUpTo(minDensity: number): Graph;
+    undirectedGraph(): Graph;
+    isWeaklyConnected(): boolean;
+    getWeaklyConnectedSubgraphChainsAsArrIndex(): number[][];
+    getSomePathsWithNbEdges(nbEdges: number, nbToFindIfPossible: number): number[][];
+    /**
+     *
+     * @param nameVertexTarget
+     * @returns [d, d-, d+]
+     */
+    getArrDegreeOfVertex(nameVertexTarget: string): number[];
+    getArrVertexNameAdjacent(nameVertexTarget: string): string[];
+    getArrVertexNameAdjacentXComing(nameVertexTarget: string, isIncomingVertices: boolean): string[];
+    isValidPath(arrNameVertex: string[]): boolean;
+    adjacencyMatrix(): Matrix;
+    equals(graph2: Graph): boolean;
+}
+//# sourceMappingURL=graph.d.ts.map

package/lib/math/graphs/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../src/math/graphs/graph.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,MAAM,EAEN,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAE/B,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CACpB,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,OAAc,EAAE,yBAAyB;IACnD,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,MAAa,EAEzB,cAAc,GAAE,MAAM,EAA8B;IA6EtD,MAAM,CAAC,MAAM,CACX,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,OAAc,EAAE,yBAAyB;IACnD,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,MAAa,EACzB,cAAc,GAAE,MAAM,EAA8B,EACpD,WAAW,GAAE,OAAc;IAkC7B,MAAM,CAAC,WAAW,CAChB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EAAE,YAA4B,EACpD,UAAU,EAAE,OAAO;IAuErB,MAAM,CAAC,0BAA0B,CAAC,QAAQ,EAAE,KAAK,EAAE;IAgCnD,MAAM,CAAC,uBAAuB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IA0BnD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAKrD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,qBAAa,KAAK;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;gBACR,WAAW,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO;IAMpE,aAAa;IASb,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAmB1D,aAAa,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAc5C,OAAO,IAAI,MAAM;IAIjB,WAAW,CAAC,UAAU,EAAE,MAAM;IAc9B,eAAe,IAAI,KAAK;IASxB,iBAAiB,IAAI,OAAO;IAoC5B,0CAA0C,IAAI,MAAM,EAAE,EAAE;IA8CxD,uBAAuB,CACrB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,MAAM,GACzB,MAAM,EAAE,EAAE;IAmCb;;;;OAIG;IACH,oBAAoB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE;IAqBxD,wBAAwB,CAAC,gBAAgB,EAAE,MAAM;IAUjD,+BAA+B,CAC7B,gBAAgB,EAAE,MAAM,EACxB,kBAAkB,EAAE,OAAO;IAmB7B,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,OAAO;IAQ7C,eAAe;IAWf,MAAM,CAAC,MAAM,EAAE,KAAK;CAQrB"}

package/lib/math/graphs/graph.js

@@ -0,0 +1,391 @@
+import { NodeComparator } from "../../tree/utilities/nodeComparator.js";
+import { random } from "../../utils/alea/random.js";
+import { shuffle } from "../../utils/alea/shuffle.js";
+import { splitIntoRandomChunks } from "../../utils/arrays/arrayChunks.js";
+import { zip } from "../../utils/arrays/arrayZip.js";
+import { Matrix, MatrixConstructor, } from "../matrices/matrix.js";
+export class GraphConstructor {
+    static randomConnected(nbVertices, isSimple = true, //simple === no loop A--A
+    isDirected = false, minDensity = 0.12, 
+    // maxDensity: number = 0.4,
+    poolVertexName = "ABCDEFGHIJKLM".split("")) {
+        const vertexNames = poolVertexName.slice(0, nbVertices);
+        const arrIndex = shuffle([...new Array(nbVertices).keys()]);
+        // console.log("arrArrIndex", arrArrIndex);
+        const coreChain = (() => {
+            if (arrIndex.length > 1) {
+                return zip(arrIndex.slice(0, -1), arrIndex.slice(1));
+            }
+            else {
+                if (isSimple) {
+                    return [];
+                }
+                else {
+                    const [indexSolo] = arrIndex;
+                    return [[indexSolo, indexSolo]];
+                }
+            }
+        })();
+        // console.log("arrCoreChain", arrCoreChain);
+        const coreNet = (() => {
+            const coreNetDirected = coreChain.reduce((acc, [startI, endI], i, coreChain) => {
+                if (i === 0) {
+                    acc.push([startI, endI]);
+                }
+                else {
+                    const [start0, _] = coreChain[0];
+                    const arrEndPrevious = coreChain.slice(0, i).map(([_, end]) => end);
+                    const arrEndAvailable = [start0, ...arrEndPrevious];
+                    const startIRandom = random(arrEndAvailable);
+                    acc.push([startIRandom, endI]);
+                }
+                return acc;
+            }, []);
+            if (isDirected) {
+                return coreNetDirected;
+            }
+            else {
+                const coreNetDirectedReversed = coreNetDirected.map(([startI, endI]) => [endI, startI]);
+                const coreNetSimple = [...coreNetDirected, ...coreNetDirectedReversed];
+                return coreNetSimple;
+            }
+        })();
+        // console.log("arrCoreNet", arrCoreNet);
+        const dictConnectionsCore = coreNet.reduce((acc, [startI, endI]) => {
+            if (!acc[startI]) {
+                acc[startI] = {};
+            }
+            acc[startI][endI] = true;
+            return acc;
+        }, {});
+        // console.log("dictConnectionsCore", dictConnectionsCore);
+        const [rows, cols] = [nbVertices, nbVertices];
+        const elts = [...Array(rows).keys()].map((i) => [...Array(cols).keys()].map((j) => (dictConnectionsCore[i]?.[j] ? 1 : 0).toTree()));
+        // console.log(
+        //   "elts",
+        //   elts.map((row) => row.map((elt) => elt.toTex())),
+        // );
+        //fill randomly
+        const mat = new Matrix(elts);
+        const graphSrc = new Graph(vertexNames, mat, isDirected);
+        const graphDensified = graphSrc.densifyUpTo(minDensity);
+        return graphDensified;
+    }
+    static random(nbVertices, isSimple = true, //simple === no loop A--A
+    isDirected = false, minDensity = 0.12, poolVertexName = "ABCDEFGHIJKLM".split(""), isConnected = true) {
+        if (isConnected) {
+            return this.randomConnected(nbVertices, isSimple, isDirected, minDensity, poolVertexName);
+        }
+        else {
+            const vertexNames = shuffle(poolVertexName.slice(0, nbVertices));
+            const minLengthChunk = nbVertices < 4 ? 1 : 2;
+            const arrVertexNamesChunk = splitIntoRandomChunks(vertexNames, 2, vertexNames.length - minLengthChunk);
+            const arrSubGraph = arrVertexNamesChunk.map((vertexNamesChunk) => this.randomConnected(vertexNamesChunk.length, isSimple, isDirected, minDensity, vertexNamesChunk));
+            return this.graphByMergingSimpleGraphs(arrSubGraph);
+        }
+    }
+    static randomChain(nbVertices, poolVertexName = "ABCDEFGHIJKLM".split(""), isDirected) {
+        if (nbVertices < 2) {
+            throw new Error("nbVertices < 2");
+        }
+        const vertexNames = poolVertexName.slice(0, nbVertices);
+        const arrIndex = shuffle([...new Array(nbVertices).keys()]);
+        // console.log("arrArrIndex", arrArrIndex);
+        const coreChain = zip(arrIndex.slice(0, -1), arrIndex.slice(1));
+        const dictConnectionsCore = coreChain.reduce((acc, [startI, endI]) => {
+            if (!acc[startI]) {
+                acc[startI] = {};
+            }
+            acc[startI][endI] = true;
+            return acc;
+        }, {});
+        // console.log("dictConnectionsCore", dictConnectionsCore);
+        const [rows, cols] = [nbVertices, nbVertices];
+        const elts = [...Array(rows).keys()].map((i) => [...Array(cols).keys()].map((j) => (dictConnectionsCore[i]?.[j] ? 1 : 0).toTree()));
+        const matDirected = new Matrix(elts);
+        const mat = isDirected ? matDirected : matDirected.symmetrized();
+        return new Graph(vertexNames, mat, isDirected);
+    }
+    // static randomWeighted(
+    //   nbVertices: number,
+    //   isDirected: boolean = false,
+    //   isConnected: boolean = true,
+    //   precision: number,
+    // ) {
+    //   const graphSimple = GraphConstructor.random(
+    //     nbVertices,
+    //     isDirected,
+    //     isConnected,
+    //   );
+    // }
+    // static randomValued(
+    //   nbVertices: number,
+    //   isDirected: boolean = false,
+    //   isConnected: boolean = true,
+    //   funcRandomValue: () => number,
+    // ) {
+    //   const graphSimple = GraphConstructor.random(
+    //     nbVertices,
+    //     isDirected,
+    //     isConnected,
+    //   );
+    //   const elementsValued = graphSimple.mat.elements.map((row) =>
+    //     row.map((elt) =>
+    //       NodeComparator.compareViaSub(elt, (0).toTree())
+    //         ? (0).toTree()
+    //         : funcRandomValue().toTree(),
+    //     ),
+    //   );
+    //   return new Graph(graphSimple.vertexNames, new Matrix(elementsValued));
+    // }
+    static graphByMergingSimpleGraphs(arrGraph) {
+        const isDirected = arrGraph.some((graph) => graph.isDirected);
+        const arrNameVertexSorted = arrGraph
+            .map((graph) => graph.vertexNames)
+            .reduce((acc, vertexNames) => {
+            acc = [...new Set([...acc, ...vertexNames])].toSorted((str1, str2) => str1.localeCompare(str2));
+            return acc;
+        }, []);
+        const arrDictConnections = arrGraph.map((graph) => graph.dictConnections());
+        const elementsMerged = arrNameVertexSorted.map(([nameVertexRow]) => arrNameVertexSorted.map(([nameVertexCol]) => arrDictConnections.reduce((acc, dict) => {
+            if (NodeComparator.isEqualViaSub(acc, (0).toTree())) {
+                if (dict[nameVertexRow]?.[nameVertexCol]) {
+                    acc = (1).toTree();
+                }
+            }
+            else {
+                //ignore
+            }
+            return acc;
+        }, (0).toTree())));
+        const matMerged = new Matrix(elementsMerged);
+        return new Graph(arrNameVertexSorted, matMerged, isDirected);
+    }
+    static graphByAddingRandomEdge(graph) {
+        const arrIJWithoutDiag = [...Array(graph.vertexNames.length).keys()]
+            .flatMap((i) => [...Array(graph.vertexNames.length).keys()].map((j) => [i, j]))
+            .filter(([i, j]) => i !== j);
+        const edgeIJNotExisting = shuffle(arrIJWithoutDiag).find(([i, j]) => NodeComparator.isEqualViaSub(graph.mat.elements[i][j], (0).toTree()));
+        if (edgeIJNotExisting) {
+            const [vertexNameStart, vertexNameEnd] = edgeIJNotExisting.map((index) => graph.vertexNames[index]);
+            const miniGraph = GraphConstructor.randomConnected(2, true, graph.isDirected, 0, [vertexNameStart, vertexNameEnd]);
+            return GraphConstructor.graphByMergingSimpleGraphs([graph, miniGraph]);
+        }
+        else {
+            return graph;
+        }
+    }
+    static fromIdentifiers(identifiers) {
+        const { vertexNames, matIds, isDirected } = identifiers;
+        const mat = MatrixConstructor.fromIdentifiers(matIds);
+        return new Graph(vertexNames, mat, isDirected);
+    }
+}
+export class Graph {
+    vertexNames;
+    mat;
+    isDirected;
+    constructor(vertexNames, mat, isDirected) {
+        this.vertexNames = vertexNames;
+        this.mat = mat;
+        this.isDirected = isDirected ?? !mat.isSymmetrical();
+    }
+    toIdentifiers() {
+        const graphIds = {
+            vertexNames: this.vertexNames,
+            matIds: this.mat.toIdentifiers(),
+            isDirected: this.isDirected,
+        };
+        return graphIds;
+    }
+    dictConnections() {
+        return Object.fromEntries(this.mat.elements.map((row, i) => {
+            const nameFrom = this.vertexNames[i];
+            const dictTo = Object.fromEntries(row.map((elt, j) => {
+                const nameTo = this.vertexNames[j];
+                const isConnection = !NodeComparator.isEqualViaSub(elt, (0).toTree());
+                return [nameTo, isConnection];
+            }));
+            return [nameFrom, dictTo];
+        }));
+    }
+    arrConnection() {
+        return Object.entries(this.dictConnections()).flatMap(([nameVertexStart, dict]) => Object.entries(dict).map(([nameVertexEnd, isConnection]) => [nameVertexStart, nameVertexEnd, isConnection]));
+    }
+    density() {
+        return this.mat.density();
+    }
+    densifyUpTo(minDensity) {
+        const { vertexNames, isDirected } = this;
+        let mat = this.mat;
+        let counter = -1;
+        while (mat.density() < minDensity && counter < 1000) {
+            counter++;
+            const graphPrev = new Graph(vertexNames, mat, isDirected);
+            const graph = GraphConstructor.graphByAddingRandomEdge(graphPrev);
+            mat = graph.mat;
+        }
+        return new Graph(vertexNames, mat, isDirected);
+    }
+    undirectedGraph() {
+        const graphReversed = new Graph(this.vertexNames, this.mat.transposed());
+        const graphUndirected = GraphConstructor.graphByMergingSimpleGraphs([
+            this,
+            graphReversed,
+        ]);
+        return graphUndirected;
+    }
+    isWeaklyConnected() {
+        const adjMatrix = (this.isDirected ? this.undirectedGraph() : this)
+            .adjacencyMatrix()
+            .elements.map((row) => row.map((elt) => elt.evaluate()));
+        //AI CODE (Edge) {
+        const n = adjMatrix.length;
+        // Validate adjacency matrix
+        if (n === 0)
+            return false;
+        for (const row of adjMatrix) {
+            if (row.length !== n) {
+                throw new Error("Invalid adjacency matrix: must be square.");
+            }
+        }
+        const visited = new Array(n).fill(false);
+        // DFS traversal
+        function dfs(node) {
+            visited[node] = true;
+            for (let neighbor = 0; neighbor < n; neighbor++) {
+                if (adjMatrix[node][neighbor] !== 0 && !visited[neighbor]) {
+                    dfs(neighbor);
+                }
+            }
+        }
+        // Start DFS from node 0
+        dfs(0);
+        // Check if all nodes were visited
+        return visited.every((v) => v);
+        //AI CODE (Edge) }
+    }
+    getWeaklyConnectedSubgraphChainsAsArrIndex() {
+        const adjMatrix = (this.isDirected ? this.undirectedGraph() : this)
+            .adjacencyMatrix()
+            .elements.map((row) => row.map((elt) => elt.evaluate()));
+        //AI CODE (Edge) {
+        // Validate input
+        if (!Array.isArray(adjMatrix) || adjMatrix.length === 0) {
+            throw new Error("Adjacency matrix must be a non-empty 2D array.");
+        }
+        const n = adjMatrix.length;
+        if (!adjMatrix.every((row) => Array.isArray(row) && row.length === n)) {
+            throw new Error("Adjacency matrix must be square.");
+        }
+        const visited = new Array(n).fill(false);
+        const subgraphs = [];
+        // DFS to collect connected nodes
+        function dfs(node, component) {
+            visited[node] = true;
+            component.push(node);
+            for (let neighbor = 0; neighbor < n; neighbor++) {
+                if (adjMatrix[node][neighbor] !== 0 && !visited[neighbor]) {
+                    dfs(neighbor, component);
+                }
+            }
+        }
+        // Find connected components
+        for (let i = 0; i < n; i++) {
+            if (!visited[i]) {
+                const component = [];
+                dfs(i, component);
+                if (component.length > 1) {
+                    // Only keep subgraphs with ≥ 2 nodes
+                    subgraphs.push(component);
+                }
+            }
+        }
+        return subgraphs;
+        //AI CODE (Edge) }
+    }
+    getSomePathsWithNbEdges(nbEdges, nbToFindIfPossible) {
+        const n = nbEdges;
+        const adjMatrix = this.adjacencyMatrix().elements.map((row) => row.map((elt) => elt.evaluate()));
+        const numVertices = adjMatrix.length;
+        const paths = [];
+        function dfs(currentPath) {
+            if (paths.length === nbToFindIfPossible)
+                return;
+            if (currentPath.length - 1 === n) {
+                paths.push([...currentPath]); // store a copy
+                return;
+            }
+            const last = currentPath[currentPath.length - 1];
+            const arrNeighborShuffled = shuffle([...Array(numVertices).keys()]);
+            arrNeighborShuffled.forEach((neighbor) => {
+                if (adjMatrix[last][neighbor] !== 0) {
+                    // edge exists
+                    currentPath.push(neighbor);
+                    dfs(currentPath);
+                    currentPath.pop();
+                }
+            });
+        }
+        const arrStartShuffled = shuffle([...Array(numVertices).keys()]);
+        arrStartShuffled.forEach((start) => {
+            dfs([start]);
+        });
+        return paths;
+    }
+    /**
+     *
+     * @param nameVertexTarget
+     * @returns [d, d-, d+]
+     */
+    getArrDegreeOfVertex(nameVertexTarget) {
+        if (this.isDirected) {
+            const dMinus = this.getArrVertexNameAdjacentXComing(nameVertexTarget, true).length;
+            const dPlus = this.getArrVertexNameAdjacentXComing(nameVertexTarget, false).length;
+            const d = dMinus + dPlus;
+            return [d, dMinus, dPlus];
+        }
+        else {
+            const dPlus = this.getArrVertexNameAdjacentXComing(nameVertexTarget, false).length;
+            return [dPlus, dPlus, dPlus];
+        }
+    }
+    getArrVertexNameAdjacent(nameVertexTarget) {
+        const arrNameVertexAdjacent = [
+            ...new Set([
+                ...this.getArrVertexNameAdjacentXComing(nameVertexTarget, true),
+                ...this.getArrVertexNameAdjacentXComing(nameVertexTarget, false),
+            ]),
+        ];
+        return arrNameVertexAdjacent;
+    }
+    getArrVertexNameAdjacentXComing(nameVertexTarget, isIncomingVertices) {
+        if (isIncomingVertices) {
+            const arrNameVertexAdjacentIncoming = Object.entries(this.dictConnections())
+                .filter(([_, dict]) => dict[nameVertexTarget])
+                .map(([nameVertex, _]) => nameVertex);
+            return arrNameVertexAdjacentIncoming;
+        }
+        else {
+            const arrNameVertexAdjacentOutgoing = Object.entries(this.dictConnections()[nameVertexTarget])
+                .filter(([_, isConnection]) => isConnection)
+                .map(([vertexName, _]) => vertexName);
+            return arrNameVertexAdjacentOutgoing;
+        }
+    }
+    isValidPath(arrNameVertex) {
+        const dictConnections = this.dictConnections();
+        return zip(arrNameVertex.slice(0, -1), arrNameVertex.slice(1)).every(([nameVertexStart, nameVertexEnd]) => dictConnections[nameVertexStart]?.[nameVertexEnd]);
+    }
+    adjacencyMatrix() {
+        const elementsQuantized = this.mat.elements.map((row) => row.map((elt) => NodeComparator.isEqualViaSub(elt, (0).toTree())
+            ? (0).toTree()
+            : (1).toTree()));
+        return new Matrix(elementsQuantized);
+    }
+    equals(graph2) {
+        const isSameVertex = () => zip(this.vertexNames, graph2.vertexNames).every(([nameVertex1, nameVertex2]) => nameVertex1 === nameVertex2);
+        const isSameMat = () => this.mat.equals(graph2.mat);
+        return isSameVertex() && isSameMat();
+    }
+}

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

@@ -1,13 +1,52 @@
-import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { AlgebraicNode, SimplifyOptions } from "../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
+import { SubstractNode } from "../../tree/nodes/operators/substractNode.js";
+import { RandintProps } from "../utils/random/randint.js";
+type MatrixConstructorOpts = {
+    allowIdentity?: boolean;
+    elementsOpts?: RandintProps;
+    adjacentAllowLoop?: boolean;
+    niceInversible?: boolean;
+};
 export declare abstract class MatrixConstructor {
-    static random(rows: number, cols: number): Matrix;
+    static random(rows: number, cols: number, opts?: MatrixConstructorOpts): Matrix;
+    static identity(order: number): Matrix;
+    static randomInversible(rows: number, cols: number, opts?: MatrixConstructorOpts): Matrix;
+    static fromIdentifiers(identifiers: MatrixIdentifiers): Matrix;
+    static emptyVarMatrix(nbRows: number, nbCols: number): Matrix;
+    static randomAdjacent(length: number, opts?: MatrixConstructorOpts): Matrix;
 }
+export type MatrixIdentifiers = {
+    id: "matrix";
+    elementsIds: NodeIdentifiers[][];
+};
 export declare class Matrix {
     elements: AlgebraicNode[][];
     rows: number;
     columns: number;
     constructor(elements: AlgebraicNode[][]);
-    determinant(): AlgebraicNode;
+    transposed(): Matrix;
+    isSymmetrical(): boolean;
+    symmetrized(): Matrix;
+    toIdentifiers(): MatrixIdentifiers;
+    determinant(): SubstractNode;
+    toInversed(): Matrix;
+    isIdentity(): boolean;
+    isTransition(): boolean;
+    inverse(): Matrix | undefined;
+    density(): number;
+    matForMapFunc(func: (elt: AlgebraicNode, i: number, j: number) => AlgebraicNode): Matrix;
+    times(k: AlgebraicNode): Matrix;
+    opposite(): Matrix;
+    isMatAdditionPossible(matPrime: Matrix): boolean;
+    add(matPrime: Matrix): Matrix;
+    substract(matPrime: Matrix): Matrix;
+    isMatProductPossible(matPrime: Matrix): boolean;
+    matrixProduct(matPrime: Matrix): Matrix;
+    power(exponent: number): Matrix;
+    equals(matPrime: Matrix): boolean;
     toTex(): string;
+    simplify(simplifyOpts?: SimplifyOptions): Matrix;
 }
+export {};
 //# sourceMappingURL=matrix.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../src/math/matrices/matrix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAMzC;AACD,qBAAa,MAAM;IACjB,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,QAAQ,EAAE,aAAa,EAAE,EAAE;IAKvC,WAAW;IAUX,KAAK;CAUN"}
+{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../src/math/matrices/matrix.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,OAAO,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAK5E,OAAO,EAAW,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAEnE,KAAK,qBAAqB,GAAG;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AACF,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,qBAAqB;IActE,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM;IAS7B,MAAM,CAAC,gBAAgB,CACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,qBAAqB;IAW9B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,iBAAiB;IAQrD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAQpD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,qBAAqB;CAWnE;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,QAAQ,CAAC;IACb,WAAW,EAAE,eAAe,EAAE,EAAE,CAAC;CAClC,CAAC;AAEF,qBAAa,MAAM;IACjB,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,QAAQ,EAAE,aAAa,EAAE,EAAE;IAMvC,UAAU;IAIV,aAAa;IAQb,WAAW;IAIX,aAAa,IAAI,iBAAiB;IAQlC,WAAW;IASX,UAAU;IAaV,UAAU;IAcV,YAAY;IAgBZ,OAAO;IAgBP,OAAO;IAOP,aAAa,CACX,IAAI,EAAE,CAAC,GAAG,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,aAAa;IAQnE,KAAK,CAAC,CAAC,EAAE,aAAa;IAMtB,QAAQ;IAIR,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIhD,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAM7B,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAInC,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI/C,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAmBvC,KAAK,CAAC,QAAQ,EAAE,MAAM;IAUtB,MAAM,CAAC,QAAQ,EAAE,MAAM;IAYvB,KAAK;IAML,QAAQ,CAAC,YAAY,CAAC,EAAE,eAAe;CAMxC"}