flockml 1.0.0

package/dist/client-node.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlockNode = void 0;
+const network_1 = require("./network");
+const quantization_1 = require("./quantization");
+const privacy_1 = require("./privacy");
+const worker_1 = require("./worker");
+const messages_1 = require("./messages");
+const tf = __importStar(require("@tensorflow/tfjs"));
+/**
+ * The FlockML Client Node.
+ *
+ * Powered by TFJS. It encapsulates the neural network, the privacy engine, and the quantization engine.
+ * In a full production build, this entire class would be serialized into a Blob
+ * and executed inside a background Web Worker to keep the UI at 60fps.
+ */
+class FlockNode {
+    network;
+    isConnected = false;
+    isTraining = false;
+    privacyEpsilon = 0.5;
+    workerManager;
+    dynamicBatchSize = 32;
+    // Error Feedback Memory Caches
+    error_ih;
+    error_ho;
+    error_bh;
+    error_bo;
+    constructor(inputNodes = 2, hiddenNodes = 4, outputNodes = 1) {
+        this.network = new network_1.NeuralNetwork(inputNodes, hiddenNodes, outputNodes);
+        this.workerManager = new worker_1.WorkerManager();
+    }
+    /**
+     * Connects to the central FedAvg Coordinator.
+     */
+    connect(websocketUrl) {
+        // Mocking WebSocket connection for the MVP
+        console.log(`[FlockML] Connecting to ${websocketUrl}...`);
+        this.isConnected = true;
+        console.log(`[FlockML] Connected. Awaiting global weights.`);
+        // Wire up the dynamic device profiler to automatically scale the batch size
+        this.workerManager.onDeviceProfiled = (batchSize) => {
+            this.dynamicBatchSize = batchSize;
+        };
+        // Initialize background thread
+        this.workerManager.initializeWorker();
+    }
+    /**
+     * Receives the latest global model from the server.
+     */
+    syncGlobalWeights(qWeightsIH, qWeightsHO, qBiasH, qBiasO) {
+        tf.tidy(() => {
+            const ih = quantization_1.Quantizer.dequantize(qWeightsIH);
+            const ho = quantization_1.Quantizer.dequantize(qWeightsHO);
+            const bh = quantization_1.Quantizer.dequantize(qBiasH);
+            const bo = quantization_1.Quantizer.dequantize(qBiasO);
+            this.network.weights_ih.assign(ih);
+            this.network.weights_ho.assign(ho);
+            this.network.bias_h.assign(bh);
+            this.network.bias_o.assign(bo);
+        });
+    }
+    /**
+     * Performs one local training epoch on a batch of data.
+     */
+    trainLocalBatch(inputs, targets) {
+        if (!this.isConnected)
+            throw new Error("FlockNode is not connected to a coordinator.");
+        this.isTraining = true;
+        // Dispatch heavy math to background Web Worker thread
+        this.workerManager.dispatchTrainingJob(inputs, targets);
+        // Legacy fallback for tests (mocking actual training update)
+        for (let i = 0; i < inputs.length; i++) {
+            this.network.train(inputs[i], targets[i]);
+        }
+    }
+    /**
+     * Cleans up background threads.
+     */
+    destroy() {
+        this.workerManager.terminate();
+        this.network.dispose();
+        if (this.error_ih)
+            this.error_ih.dispose();
+        if (this.error_ho)
+            this.error_ho.dispose();
+        if (this.error_bh)
+            this.error_bh.dispose();
+        if (this.error_bo)
+            this.error_bo.dispose();
+    }
+    /**
+     * Helper function to map our payload into the protobuf format
+     */
+    mapToProto(payload) {
+        return {
+            data: new Uint8Array(payload.data),
+            min: payload.min,
+            max: payload.max,
+            rows: payload.rows,
+            cols: payload.cols
+        };
+    }
+    /**
+     * Secures, compresses, and binary-serializes the newly trained weights.
+     */
+    exportSecureGradients() {
+        // 2. Apply Differential Privacy (Laplacian Noise) to protect user data
+        privacy_1.DifferentialPrivacy.applyNoise(this.network.weights_ih, this.privacyEpsilon);
+        privacy_1.DifferentialPrivacy.applyNoise(this.network.weights_ho, this.privacyEpsilon);
+        privacy_1.DifferentialPrivacy.applyNoise(this.network.bias_h, this.privacyEpsilon);
+        privacy_1.DifferentialPrivacy.applyNoise(this.network.bias_o, this.privacyEpsilon);
+        // 3. Quantize matrices to 8-bit integers while preserving precision loss in Error Memory
+        const qIH = quantization_1.Quantizer.quantizeWithErrorFeedback(this.network.weights_ih, this.error_ih);
+        if (this.error_ih)
+            this.error_ih.dispose();
+        this.error_ih = qIH.newError;
+        const qHO = quantization_1.Quantizer.quantizeWithErrorFeedback(this.network.weights_ho, this.error_ho);
+        if (this.error_ho)
+            this.error_ho.dispose();
+        this.error_ho = qHO.newError;
+        const qBH = quantization_1.Quantizer.quantizeWithErrorFeedback(this.network.bias_h, this.error_bh);
+        if (this.error_bh)
+            this.error_bh.dispose();
+        this.error_bh = qBH.newError;
+        const qBO = quantization_1.Quantizer.quantizeWithErrorFeedback(this.network.bias_o, this.error_bo);
+        if (this.error_bo)
+            this.error_bo.dispose();
+        this.error_bo = qBO.newError;
+        // 4. Binary Serialization (Protocol Buffers) to cut network payload bloat
+        const message = messages_1.flockml.GradientUpdate.create({
+            weightsIh: this.mapToProto(qIH.payload),
+            weightsHo: this.mapToProto(qHO.payload),
+            biasH: this.mapToProto(qBH.payload),
+            biasO: this.mapToProto(qBO.payload),
+            batchSize: this.dynamicBatchSize
+        });
+        return messages_1.flockml.GradientUpdate.encode(message).finish();
+    }
+}
+exports.FlockNode = FlockNode;

package/dist/coordinator.d.ts

@@ -0,0 +1,41 @@
+import { NeuralNetwork } from './network';
+import { QuantizedPayload } from './quantization';
+import * as tf from '@tensorflow/tfjs';
+/**
+ * The Central Brain: FedAvg Coordinator.
+ *
+ * Powered by TFJS. Averages massive incoming weight tensors continuously
+ * using hardware acceleration.
+ */
+export declare class Coordinator {
+    globalModel: NeuralNetwork;
+    clientUpdates: {
+        weights_ih: tf.Tensor2D;
+        weights_ho: tf.Tensor2D;
+        bias_h: tf.Tensor2D;
+        bias_o: tf.Tensor2D;
+    }[];
+    constructor(inputNodes: number, hiddenNodes: number, outputNodes: number);
+    private mapFromProto;
+    /**
+     * Receives a binary protobuf payload from a browser client.
+     */
+    receiveUpdate(binaryPayload: Uint8Array): void;
+    /**
+     * The Federated Averaging (FedAvg) Algorithm with Anomaly Detection.
+     *
+     * Averages all the incoming matrices. Because of Differential Privacy,
+     * the Laplacian noise mathematically cancels out to 0 here, leaving only
+     * the pure, learned signal from the crowdsourced devices.
+     */
+    aggregate(): void;
+    /**
+     * Broadcasts the current global model weights to all new clients.
+     */
+    getGlobalWeightsForBroadcast(): {
+        weights_ih: QuantizedPayload;
+        weights_ho: QuantizedPayload;
+        bias_h: QuantizedPayload;
+        bias_o: QuantizedPayload;
+    };
+}

package/dist/coordinator.js

@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Coordinator = void 0;
+const network_1 = require("./network");
+const quantization_1 = require("./quantization");
+const messages_1 = require("./messages");
+const tf = __importStar(require("@tensorflow/tfjs"));
+/**
+ * The Central Brain: FedAvg Coordinator.
+ *
+ * Powered by TFJS. Averages massive incoming weight tensors continuously
+ * using hardware acceleration.
+ */
+class Coordinator {
+    globalModel;
+    clientUpdates;
+    constructor(inputNodes, hiddenNodes, outputNodes) {
+        this.globalModel = new network_1.NeuralNetwork(inputNodes, hiddenNodes, outputNodes);
+        this.clientUpdates = [];
+    }
+    mapFromProto(protoPayload) {
+        if (!protoPayload)
+            throw new Error("Missing payload section");
+        return {
+            data: protoPayload.data || new Uint8Array(),
+            min: protoPayload.min || 0,
+            max: protoPayload.max || 0,
+            rows: protoPayload.rows || 0,
+            cols: protoPayload.cols || 0
+        };
+    }
+    /**
+     * Receives a binary protobuf payload from a browser client.
+     */
+    receiveUpdate(binaryPayload) {
+        const message = messages_1.flockml.GradientUpdate.decode(binaryPayload);
+        const weights_ih = quantization_1.Quantizer.dequantize(this.mapFromProto(message.weightsIh));
+        const weights_ho = quantization_1.Quantizer.dequantize(this.mapFromProto(message.weightsHo));
+        const bias_h = quantization_1.Quantizer.dequantize(this.mapFromProto(message.biasH));
+        const bias_o = quantization_1.Quantizer.dequantize(this.mapFromProto(message.biasO));
+        this.clientUpdates.push({
+            weights_ih,
+            weights_ho,
+            bias_h,
+            bias_o
+        });
+    }
+    /**
+     * The Federated Averaging (FedAvg) Algorithm with Anomaly Detection.
+     *
+     * Averages all the incoming matrices. Because of Differential Privacy,
+     * the Laplacian noise mathematically cancels out to 0 here, leaving only
+     * the pure, learned signal from the crowdsourced devices.
+     */
+    aggregate() {
+        if (this.clientUpdates.length === 0)
+            return;
+        // 1. Anomaly Detection (Anti-Sybil / Data Poisoning)
+        // Runs mathematically on the GPU without downloading large buffers to CPU
+        const safeUpdates = this.clientUpdates.filter(update => {
+            return tf.tidy(() => {
+                const checkTensor = (t) => {
+                    const hasNaN = tf.sum(tf.cast(tf.isNaN(t), 'int32')).dataSync()[0] > 0;
+                    const maxAbs = tf.max(tf.abs(t)).dataSync()[0];
+                    return !hasNaN && maxAbs <= 1000;
+                };
+                return checkTensor(update.weights_ih) &&
+                    checkTensor(update.weights_ho) &&
+                    checkTensor(update.bias_h) &&
+                    checkTensor(update.bias_o);
+            });
+        });
+        if (safeUpdates.length === 0) {
+            console.warn("[Coordinator] All received updates were flagged as anomalous and dropped.");
+            // Dispose the tensors since we are dropping them
+            for (const update of this.clientUpdates) {
+                update.weights_ih.dispose();
+                update.weights_ho.dispose();
+                update.bias_h.dispose();
+                update.bias_o.dispose();
+            }
+            this.clientUpdates = [];
+            return;
+        }
+        if (safeUpdates.length < this.clientUpdates.length) {
+            console.warn(`[Coordinator] Dropped ${this.clientUpdates.length - safeUpdates.length} poisoned payloads.`);
+        }
+        // 2. Federated Averaging
+        const averageTensor = (matrixKey, targetVar) => {
+            tf.tidy(() => {
+                const tensors = safeUpdates.map(u => u[matrixKey]);
+                const stacked = tf.stack(tensors);
+                const mean = tf.mean(stacked, 0);
+                targetVar.assign(mean);
+            });
+        };
+        averageTensor('weights_ih', this.globalModel.weights_ih);
+        averageTensor('weights_ho', this.globalModel.weights_ho);
+        averageTensor('bias_h', this.globalModel.bias_h);
+        averageTensor('bias_o', this.globalModel.bias_o);
+        // Dispose all client tensors after aggregation to prevent memory leaks
+        for (const update of this.clientUpdates) {
+            update.weights_ih.dispose();
+            update.weights_ho.dispose();
+            update.bias_h.dispose();
+            update.bias_o.dispose();
+        }
+        this.clientUpdates = [];
+    }
+    /**
+     * Broadcasts the current global model weights to all new clients.
+     */
+    getGlobalWeightsForBroadcast() {
+        return {
+            weights_ih: quantization_1.Quantizer.quantize(this.globalModel.weights_ih),
+            weights_ho: quantization_1.Quantizer.quantize(this.globalModel.weights_ho),
+            bias_h: quantization_1.Quantizer.quantize(this.globalModel.bias_h),
+            bias_o: quantization_1.Quantizer.quantize(this.globalModel.bias_o)
+        };
+    }
+}
+exports.Coordinator = Coordinator;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { NeuralNetwork } from './network';
+export { Quantizer, type QuantizedPayload } from './quantization';
+export { DifferentialPrivacy } from './privacy';
+export { Coordinator } from './coordinator';
+export { FlockNode as FlockNode } from './client-node';

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlockNode = exports.Coordinator = exports.DifferentialPrivacy = exports.Quantizer = exports.NeuralNetwork = void 0;
+var network_1 = require("./network");
+Object.defineProperty(exports, "NeuralNetwork", { enumerable: true, get: function () { return network_1.NeuralNetwork; } });
+var quantization_1 = require("./quantization");
+Object.defineProperty(exports, "Quantizer", { enumerable: true, get: function () { return quantization_1.Quantizer; } });
+var privacy_1 = require("./privacy");
+Object.defineProperty(exports, "DifferentialPrivacy", { enumerable: true, get: function () { return privacy_1.DifferentialPrivacy; } });
+var coordinator_1 = require("./coordinator");
+Object.defineProperty(exports, "Coordinator", { enumerable: true, get: function () { return coordinator_1.Coordinator; } });
+var client_node_1 = require("./client-node");
+Object.defineProperty(exports, "FlockNode", { enumerable: true, get: function () { return client_node_1.FlockNode; } });

package/dist/matrix.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Core Linear Algebra Engine for Browser-Native Neural Networks.
+ *
+ * This class handles all matrix math required for Forward Passes and Backpropagation.
+ * Optimized for V8 JIT compilation using typed Float32Arrays where possible,
+ * though standard arrays are used here for structural simplicity in the MVP.
+ */
+export declare class Matrix {
+    rows: number;
+    cols: number;
+    data: number[][];
+    constructor(rows: number, cols: number);
+    /**
+     * Creates a matrix from an existing 2D array.
+     */
+    static fromArray(arr: number[][]): Matrix;
+    /**
+     * Randomizes the matrix weights (typically for initialization).
+     * Uses a standard normal distribution approximation (Xavier initialization simplified).
+     */
+    randomize(): void;
+    /**
+     * Matrix Dot Product (Matrix Multiplication).
+     * Used heavily in the Forward Pass to calculate layer activations.
+     * O(n^3) complexity - prime candidate for WebGPU acceleration later.
+     */
+    static dot(a: Matrix, b: Matrix): Matrix;
+    /**
+     * Element-wise addition.
+     */
+    add(n: Matrix | number): void;
+    /**
+     * Element-wise subtraction (A - B). Returns a new Matrix.
+     * Crucial for calculating the Error (Target - Prediction).
+     */
+    static subtract(a: Matrix, b: Matrix): Matrix;
+    /**
+     * Element-wise multiplication (Hadamard product). Returns a new Matrix.
+     */
+    static multiply(a: Matrix, b: Matrix): Matrix;
+    /**
+     * Scalar multiplication.
+     */
+    multiply(n: number): void;
+    /**
+     * Applies a function to every element in the matrix.
+     * Used for Activation Functions (e.g., Sigmoid, ReLU) and their derivatives.
+     */
+    map(func: (val: number, i: number, j: number) => number): void;
+    /**
+     * Static version of map, returns a new Matrix.
+     */
+    static map(matrix: Matrix, func: (val: number, i: number, j: number) => number): Matrix;
+    /**
+     * Transposes the matrix (flips rows and columns).
+     * Crucial for calculating gradients during Backpropagation.
+     */
+    static transpose(matrix: Matrix): Matrix;
+    /**
+     * Converts a 1D array to a Matrix (Column vector).
+     */
+    static from1DArray(arr: number[]): Matrix;
+    /**
+     * Converts the Matrix back to a 1D array.
+     */
+    toArray(): number[];
+}

package/dist/matrix.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * Core Linear Algebra Engine for Browser-Native Neural Networks.
+ *
+ * This class handles all matrix math required for Forward Passes and Backpropagation.
+ * Optimized for V8 JIT compilation using typed Float32Arrays where possible,
+ * though standard arrays are used here for structural simplicity in the MVP.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Matrix = void 0;
+class Matrix {
+    rows;
+    cols;
+    data;
+    constructor(rows, cols) {
+        this.rows = rows;
+        this.cols = cols;
+        this.data = Array(this.rows).fill(0).map(() => Array(this.cols).fill(0));
+    }
+    /**
+     * Creates a matrix from an existing 2D array.
+     */
+    static fromArray(arr) {
+        const m = new Matrix(arr.length, arr[0].length);
+        for (let i = 0; i < m.rows; i++) {
+            for (let j = 0; j < m.cols; j++) {
+                m.data[i][j] = arr[i][j];
+            }
+        }
+        return m;
+    }
+    /**
+     * Randomizes the matrix weights (typically for initialization).
+     * Uses a standard normal distribution approximation (Xavier initialization simplified).
+     */
+    randomize() {
+        for (let i = 0; i < this.rows; i++) {
+            for (let j = 0; j < this.cols; j++) {
+                // Random value between -1 and 1
+                this.data[i][j] = Math.random() * 2 - 1;
+            }
+        }
+    }
+    /**
+     * Matrix Dot Product (Matrix Multiplication).
+     * Used heavily in the Forward Pass to calculate layer activations.
+     * O(n^3) complexity - prime candidate for WebGPU acceleration later.
+     */
+    static dot(a, b) {
+        if (a.cols !== b.rows) {
+            throw new Error(`Incompatible matrices for dot product: ${a.cols} !== ${b.rows}`);
+        }
+        const result = new Matrix(a.rows, b.cols);
+        for (let i = 0; i < result.rows; i++) {
+            for (let j = 0; j < result.cols; j++) {
+                let sum = 0;
+                for (let k = 0; k < a.cols; k++) {
+                    sum += a.data[i][k] * b.data[k][j];
+                }
+                result.data[i][j] = sum;
+            }
+        }
+        return result;
+    }
+    /**
+     * Element-wise addition.
+     */
+    add(n) {
+        if (n instanceof Matrix) {
+            if (this.rows !== n.rows || this.cols !== n.cols) {
+                throw new Error('Incompatible matrices for addition');
+            }
+            for (let i = 0; i < this.rows; i++) {
+                for (let j = 0; j < this.cols; j++) {
+                    this.data[i][j] += n.data[i][j];
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < this.rows; i++) {
+                for (let j = 0; j < this.cols; j++) {
+                    this.data[i][j] += n;
+                }
+            }
+        }
+    }
+    /**
+     * Element-wise subtraction (A - B). Returns a new Matrix.
+     * Crucial for calculating the Error (Target - Prediction).
+     */
+    static subtract(a, b) {
+        if (a.rows !== b.rows || a.cols !== b.cols) {
+            throw new Error('Incompatible matrices for subtraction');
+        }
+        const result = new Matrix(a.rows, a.cols);
+        for (let i = 0; i < result.rows; i++) {
+            for (let j = 0; j < result.cols; j++) {
+                result.data[i][j] = a.data[i][j] - b.data[i][j];
+            }
+        }
+        return result;
+    }
+    /**
+     * Element-wise multiplication (Hadamard product). Returns a new Matrix.
+     */
+    static multiply(a, b) {
+        if (a.rows !== b.rows || a.cols !== b.cols) {
+            throw new Error('Incompatible matrices for element-wise multiplication');
+        }
+        const result = new Matrix(a.rows, a.cols);
+        for (let i = 0; i < result.rows; i++) {
+            for (let j = 0; j < result.cols; j++) {
+                result.data[i][j] = a.data[i][j] * b.data[i][j];
+            }
+        }
+        return result;
+    }
+    /**
+     * Scalar multiplication.
+     */
+    multiply(n) {
+        for (let i = 0; i < this.rows; i++) {
+            for (let j = 0; j < this.cols; j++) {
+                this.data[i][j] *= n;
+            }
+        }
+    }
+    /**
+     * Applies a function to every element in the matrix.
+     * Used for Activation Functions (e.g., Sigmoid, ReLU) and their derivatives.
+     */
+    map(func) {
+        for (let i = 0; i < this.rows; i++) {
+            for (let j = 0; j < this.cols; j++) {
+                const val = this.data[i][j];
+                this.data[i][j] = func(val, i, j);
+            }
+        }
+    }
+    /**
+     * Static version of map, returns a new Matrix.
+     */
+    static map(matrix, func) {
+        const result = new Matrix(matrix.rows, matrix.cols);
+        for (let i = 0; i < matrix.rows; i++) {
+            for (let j = 0; j < matrix.cols; j++) {
+                const val = matrix.data[i][j];
+                result.data[i][j] = func(val, i, j);
+            }
+        }
+        return result;
+    }
+    /**
+     * Transposes the matrix (flips rows and columns).
+     * Crucial for calculating gradients during Backpropagation.
+     */
+    static transpose(matrix) {
+        const result = new Matrix(matrix.cols, matrix.rows);
+        for (let i = 0; i < matrix.rows; i++) {
+            for (let j = 0; j < matrix.cols; j++) {
+                result.data[j][i] = matrix.data[i][j];
+            }
+        }
+        return result;
+    }
+    /**
+     * Converts a 1D array to a Matrix (Column vector).
+     */
+    static from1DArray(arr) {
+        return Matrix.fromArray(arr.map(x => [x]));
+    }
+    /**
+     * Converts the Matrix back to a 1D array.
+     */
+    toArray() {
+        const arr = [];
+        for (let i = 0; i < this.rows; i++) {
+            for (let j = 0; j < this.cols; j++) {
+                arr.push(this.data[i][j]);
+            }
+        }
+        return arr;
+    }
+}
+exports.Matrix = Matrix;

package/dist/micro-benchmark.d.ts

@@ -0,0 +1 @@
+export {};