numz 0.3.0 → 0.5.0

package/README.md

@@ -1,6 +1,27 @@
 # Numz
 Scientific computing in [zikojs](https://github.com/zakarialaoui10/zikojs)
 
+## API Reference
+
+### Typed Matrix 
+- Class Constructors : `I8Matrix`, `I16Matrix`, `I32Matrix`,`U8Matrix`, `U16Matrix`, `U32Matrix`, `F16Matrix`, `F32Matrix`, `F64Matrix`, `BI64Matrix`, `BU64Matrix`
+- Functional Constrcuctors : `matrix_i8`, `matrix_i16`, `matrix_i32`, `matrix_u8`, `matrix_u16`, `matrix_u32`, `matrix_f16`, `matrix_f32`, `matrix_f64`, `matrix_bi64`, `matrix_bu64`,
+
+### Signal
+
+- Sequence functions : `zeros`, `ones`, `nums`, `arange`, `linspace`, `logspace`, `geomspace`.
+
+- Pulse functions : `signum`, `ramp`, `rect`, `tri`, `dirac`, `lorentz`, `sinc`, `gaussian_pulse`, `exp_pulse`, `trapezoid`.
+
+- Periodic functions : `square`, `tri_wave`, `sawtooth_wave`, `pulse_train`, `pwm`, `sinusoid`
+
+- Window functions : `hamming_window`, `hanning_window`, `kaiser_window`, `blackman_window`, `bartlett_window`, `blackman_harris_window`, `nuttall_window`, `flat_top_window`, `tukey_window`, `gaussian_window`, `lanczos_window`, `poisson_window`, `rect_window`, `tri_window`.
+
+- conv : `conv`, `conv2`,
+
+- fft : `fft`, `ifft`, `fft2`, `ifft2`
+
+
 <!-- 
 wasm ?
 golang? 

package/docs/astro.config.mjs

@@ -6,8 +6,9 @@ import starlightThemeObsidian from 'starlight-theme-obsidian'
 
 
 const referenceModules = [
+	'typed-matrix',
 	'functions', 
-	'matrix',
+	// 'matrix',
 	'complex',
 	'signal', 
 	'stats',
@@ -36,12 +37,12 @@ export default defineConfig({
 					href: 'https://github.com/zakarialaoui10/numz.git' 
 				}],
 			sidebar: [
-				{
-					label: 'Guides',
-					items: [
-						{ label: 'Example Guide', slug: 'guides/example' },
-					],
-				},
+				// {
+				// 	label: 'Guides',
+				// 	items: [
+				// 		{ label: 'Example Guide', slug: 'guides/example' },
+				// 	],
+				// },
 				{
 					label : 'philosophy',
 					slug : 'philosophy'

package/docs/src/content/docs/index.mdx

@@ -5,9 +5,9 @@ template: splash # Remove or comment out this line to display the site sidebar o
 hero:
   tagline: Scientific computation with zikojs
   image:
-    file: ../../assets/houston.webp
+    file: ../../assets/logo.png
   actions:
-    - text: Example Guide
+    - text: Read the docs
       link: /guides/example/
       icon: right-arrow
     - text: Read Zikojs docs
@@ -18,23 +18,49 @@ hero:
 
 import { Card, CardGrid } from '@astrojs/starlight/components';
 
-## Next steps
+## Features overview
 
 <CardGrid stagger>
-	<Card title="Update content" icon="pencil">
-		Edit `src/content/docs/index.mdx` to see this page change.
+	<Card title="Extended Array Programming">
+		Numz brings NumPy-like array programming to JavaScript with native, flexible data structures.
+		- Preserves original structure and types
+		- No manual loops or recursion required
 	</Card>
-	<Card title="Change page layout" icon="document">
-		Delete `template: splash` in `src/content/docs/index.mdx` to display a
-		sidebar on this page.
+	<Card title="Built on the top of zikojs">
+	    Numz fully supports and extends core **ZikoJS data types**.
+		- Extend mathematical utilities and functions
+		- Supoorts : 
+			- Complex numbers
+			- Matrices
+			- ...
 	</Card>
-	<Card title="Add new content" icon="add-document">
-		Add Markdown or MDX files to `src/content/docs` to create new pages.
+	<Card title="Typed Matrices">
+		High-performance matrix types backed by TypedArrays.
+		- Arithmetic operations 
+		- Reshape
+		- Serialization / deserialization
+		- ...
 	</Card>
-	<Card title="Configure your site" icon="setting">
-		Edit your `sidebar` and other config in `astro.config.mjs`.
+	<Card title="Signal Processing">
+	Built-in tools for discrete signals and DSP :
+	- Sequences
+	- Pulses
+	- Windows
+	- Convolution
+	- FFT
+	- ...
 	</Card>
-	<Card title="Read the docs" icon="open-book">
-		Learn more in [the Starlight Docs](https://starlight.astro.build/).
+	  <Card title="Advanced Statistics Utilities">
+    A comprehensive statistics toolbox designed for large datasets and numerical analysis.
+
+    - Descriptive statistics (mean, median, mode, variance, std)  
+    - Reductions (min, max, sum, product)  
+    - Percentiles and quantiles  
+    - Covariance and correlation  
+	- Distributions
+  </Card>
+	<Card title="Modular & Composable">
+	- Tree-shakable modules
+	- Easy integration with other libraries
 	</Card>
 </CardGrid>

package/docs/src/content/docs/philosophy.md

@@ -11,5 +11,3 @@ It is inspired by:
 - **MATLAB**
 
 Numz guarantees a **layered, shape-safe, function-first numerical computing model**, designed to scale naturally from scalars to tensors while preserving mathematical correctness and clarity.
-
-<!-- Numz is a layered, shape-safe, function-first numerical computing library that brings true array programming and scientific mathematics to JavaScript, built on the top of [Zikojs](). -->

package/docs/src/content/docs/reference/typed-matrix/0-intro.md

@@ -0,0 +1,74 @@
+---
+title: Introduction
+description: Typed matrices overview
+tableOfContents: false
+---
+
+**Typed Matrices** in **Numz** are an extension of **Zikojs Matrix**, designed to provide
+**high-performance**, **memory-efficient**, and **type-safe** matrix operations.
+
+Unlike regular matrices that rely on standard JavaScript arrays, Typed Matrices are
+backed by **TypedArray** structures, enabling contiguous memory layout and faster
+numerical computation.
+
+---
+
+## TypedMatrix Variants
+
+Numz provides multiple TypedMatrix classes, each mapped to a specific
+JavaScript `TypedArray` implementation.
+
+### Floating-Point Matrices
+
+| Class       | Backing Type  | Precision | Use case |
+|-------------|---------------|-----------|----------|
+| `F16Matrix` | `Float16Array`| 16-bit    | ML, GPU-style data |
+| `F32Matrix` | `Float32Array`| 32-bit    | GPU, graphics, signals |
+| `F64Matrix` | `Float64Array`| 64-bit    | Scientific computing |
+
+### Integer Matrices
+
+| Class       | Backing Type       | Range | Use case |
+|-------------|--------------------|-------|----------|
+| `I8Matrix`  | `Int8Array`        | −128 → 127 | Compact data |
+| `U8Matrix`  | `Uint8Array`       | 0 → 255 | Images, buffers |
+| `I16Matrix` | `Int16Array`       | −32K → 32K | DSP, audio |
+| `U16Matrix` | `Uint16Array`      | 0 → 65K | Indexing |
+| `I32Matrix` | `Int32Array`       | 32-bit | General integers |
+| `U32Matrix` | `Uint32Array`      | 32-bit | Large indices |
+
+### Big Integer Matrices
+
+| Class         | Backing Type         | Notes |
+|--------------|----------------------|-------|
+| `BI64Matrix`  | `BigInt64Array`      | Requires `BigInt` |
+| `BU64Matrix`  | `BigUint64Array`     | Large integer arithmetic |
+
+---
+
+## Example
+
+```js
+import { F64Matrix } from 'numz';
+
+const A = new F64Matrix(2, 2, [
+  1, 2,
+  3, 4
+]);
+
+A.add(2).mul(3);
+
+```
+
+
+### Note
+> During the construction phase, the provided data is accepted as a regular
+JavaScript array only as a temporary input.
+Internally, Numz copies the values into a TypedArray (``Float64Array`` in this case),
+and the original array is discarded and no longer used.
+
+> This guarantees:
+- contiguous memory layout
+- predictable numeric type
+- better performance for subsequent operations
+

package/docs/src/content/docs/reference/typed-matrix/1-declaration.mdx

@@ -0,0 +1,65 @@
+---
+title: declaration
+description: about
+tableOfContents: false
+---
+
+import { Tabs, TabItem } from '@astrojs/starlight/components';
+
+## Matrix Constructor
+
+<Tabs>
+  <TabItem label="Class Constructor">
+    - `new [Type]Matrix(r, c, arr: (number)[])` : Creates an `r × c` matrix using the provided **array of numbers**.
+    - `new [Type]Matrix(m : [Type]Matrix)` :  Creates a **copy** of an existing `[Type]Matrix`.
+    - `new [Type]Matrix(arr : (number)[][])` : Creates a matrix from a **2-dimensional array**. The number of rows and columns
+      is inferred from the array shape.
+    ### Example
+    ```js
+    const M1 = new I8Matrix(3, 3, [1, 2, 3, -4, -5, 6, 7, 8, 9])
+    const M2 = new I8Matrix(M1)
+    const M3 = new F32Matrix([
+                  [1.3, 1.2], 
+                  [-3.7, 2.75]
+                ])
+    ```
+  </TabItem>
+  <TabItem label="Functional Constructors">
+    - `matrix_[type](r, c, arr: (number)[])` : Functional version of the constructor that creates an `r × c` matrix from a flat array.
+
+    - `matrix_[type](m : [Type]Matrix)` : Functional copy of an existing `[Type]Matrix`.
+    - `matrix_[type](arr : (number)[])` : Functional constructor that creates a matrix from a **2-dimensional array**.
+    ### Example
+    ```js
+    const M1 = matrix_i8(3, 3, [1, 2, 3, -4, -5, 6, 7, 8, 9])
+    const M2 = matrix_i8(M1)
+    const M3 = matrix_f32([
+                  [1.3, 1.2], 
+                  [-3.7, 2.75]
+                ])
+    ```
+  </TabItem>
+</Tabs>
+
+## Static Factory Methods
+
+All TypedMatrix classes (`F16Matrix`, `F32Matrix`, `F64Matrix`, `I8Matrix`, etc.) provide
+the following **static factory methods** for convenient construction:
+
+- `[Type]Matrix.zeros(r, c)` : Creates an `r × c` matrix filled with zeros.
+- `[Type]Matrix.ones(r, c)` : Creates an `r × c` matrix filled with ones.
+- `[Type]Matrix.eye(n)` : Creates an `n × n` identity matrix (ones on the diagonal, zeros elsewhere).  
+- `[Type]Matrix.nums(r, c, num : number)` : Creates an r × c matrix filled with the specified value num
+- `Matrix.random.int(min, max)`
+- `Matrix.random.float(min, max)`
+
+### Example
+
+```js
+ const M1 = F64Matrix.zeros(2,7)
+ const M2 = U32Matrix.ones(4,5)
+ const M3 = I32Matrix.eye(4)
+ const M4 = F32Matrix.nums(3, 3, -1.25)
+ const M5 = I16Matrix.random.int(-7, 7)
+ const M6 = F32Matrix.random.float(-7, 7)
+```

package/docs/src/content/docs/reference/typed-matrix/accessors.md

@@ -0,0 +1,5 @@
+---
+title: accessors 
+description: about
+tableOfContents: false
+---

package/docs/src/content/docs/reference/typed-matrix/arithmetic.md

@@ -0,0 +1,12 @@
+---
+title: arithmetic 
+description: about
+tableOfContents: false
+---
+
+- `.add(...m: (Matrix | number)[])` : Element-wise addition with one or more matrices or scalars.
+- `.sub(...m: (Matrix | number)[])` : Element-wise subtraction with one or more matrices or scalars.
+- `.mul(...m: (Matrix | number)[])` : Element-wise multiplication with one or more matrices or scalars.
+- `.div(...m: (Matrix | number)[])` : Element-wise division with one or more matrices or scalars.
+- `.modulo(...m: (Matrix | number)[])` : Element-wise modulo operation with one or more matrices or scalars.
+- `.dot(m: Matrix)` : Matrix multiplication (linear algebra dot product).

package/docs/src/content/docs/reference/typed-matrix/checkers.md

@@ -0,0 +1,11 @@
+---
+title: checkers
+description: checkers
+# sidebar:
+#     order : 0
+tableOfContents: false
+---
+
+Hello world;
+
+My name is Zakaria ELALAOUI, There’s nothing impressive here, just skip this part and go straight to the documentation.

package/docs/src/content/docs/reference/typed-matrix/float-only.md

@@ -0,0 +1,5 @@
+---
+title: float only 
+description: about
+tableOfContents: false
+---

package/docs/src/content/docs/reference/typed-matrix/rehsape.md

@@ -0,0 +1,12 @@
+---
+title: reshape
+description: reshape
+tableOfContents: false
+---
+
+- `.reshape(r, c)` : Reshapes the matrix to `(r × c)` without changing the total number of elements.
+- `.reshape(r0, c0, r1, c1)` : 
+- `.hstack(...matrices: Matrix[])` : Horizontally stacks matrices by columns (same number of rows required).
+- `.vstack(...matrices: Matrix[])` : Vertically stacks matrices by rows (same number of columns required).
+- `.hqueue(...matrices: Matrix[])` : Appends matrices horizontally, preserving row order (row-wise concatenation).
+- `.vqueue(...matrices: Matrix[])` : Appends matrices vertically, preserving column order (column-wise concatenation).

package/docs/src/styles/custom.css

@@ -2,13 +2,20 @@
   --sl-content-width: 50rem;
   --sl-text-5xl: 3.5rem;
 }
-
 h1{
-    color : darkblue;
-    /* text-decoration: 2px underline blueviolet;
-    text-decoration-skip-ink: auto; */
-    /* border-bottom: 1px red solid; */
+    color : var(--sl-color-accent-high);
+}
+h2{
+    color : var(--slsg-node-color-7);
+}
+h3{
+    color : var(--slsg-node-color-8);  
+
 }
+
+/* a, summary span{
+    color: var(--sl-color-accent-lows);
+} */
 p a{
     color: blueviolet;
     text-decoration: none;
@@ -16,6 +23,10 @@ p a{
         text-decoration: underline;
     }
 }
-/* strong{
-    color: blueviolet;
+strong{
+    color: var(--slsg-node-color-8);
+}
+
+/* #starlight__sidebar li, .group-label span{
+    color: gray;
 } */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "scientific computing with zikojs",
   "main": "index.js",
   "type": "module",
@@ -18,17 +18,17 @@
   "author": "zakaria elalaoui",
   "keywords": [
     "zikojs",
-    "zikojs-addons"
+    "math"
   ],
   "license": "MIT",
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^28.0.0",
-    "@rollup/plugin-node-resolve": "^15.3.0",
-    "@rollup/plugin-terser": "^0.4.4",
-    "cross-env": "^7.0.3",
-    "rollup": "^4.24.0"
+    "@rollup/plugin-commonjs": "^29.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^1.0.0",
+    "cross-env": "^10.1.0",
+    "rollup": "^4.62.5"
   },
   "dependencies": {
-    "ziko": "^0.57.0"
+    "ziko": "^1.8.0"
   }
 }

package/src/signal/functions/periodic/index.js

@@ -13,7 +13,7 @@ export const square = (t, T = 1, A = 1, duty = 0.5, t0 = 0) => {
 };
 
 // Triangle wave: amplitude A, period T, duty cycle, centered at t0
-export const triangle = (t, T = 1, A = 1, duty = 0.5, t0 = 0) => {
+export const tri_wave = (t, T = 1, A = 1, duty = 0.5, t0 = 0) => {
     const f = (v) => {
         const phase = ((v - t0) % T + T) % T;
         if (phase < duty * T) {
@@ -27,7 +27,7 @@ export const triangle = (t, T = 1, A = 1, duty = 0.5, t0 = 0) => {
 };
 
 // Sawtooth wave: amplitude A, period T, duty cycle, centered at t0
-export const sawtoothPeriodic = (t, T = 1, A = 1, duty = 1, t0 = 0) => {
+export const sawtooth_wave = (t, T = 1, A = 1, duty = 1, t0 = 0) => {
     const f = (v) => {
         const phase = ((v - t0) % T + T) % T;
         if (phase < duty * T) {
@@ -41,7 +41,7 @@ export const sawtoothPeriodic = (t, T = 1, A = 1, duty = 1, t0 = 0) => {
 };
 
 // Pulse train: amplitude A, period T, pulse width, centered at t0
-export const pulseTrain = (t, T = 1, width = 0.5, A = 1, t0 = 0) => {
+export const pulse_train = (t, T = 1, width = 0.5, A = 1, t0 = 0) => {
     const f = (v) => {
         const phase = ((v - t0) % T + T) % T;
         return phase < width ? A : 0;

package/src/signal/functions/pulse/index.js

@@ -6,7 +6,7 @@ export const signum = (t, t0 = 0, A = 1) => {
 };
 
 // Ramp function
-export const rampe = (t, t0 = 0, A = 1) => {
+export const ramp = (t, t0 = 0, A = 1) => {
     if (Array.isArray(t)) return t.map(v => v < t0 ? 0 : A * (v - t0));
     return t < t0 ? 0 : A * (t - t0);
 };
@@ -59,14 +59,14 @@ export const sinc = (t, t0 = 0, A = 1) => {
 
 
 // Gaussian pulse
-export const gaussian = (t, t0 = 0, sigma = 1, A = 1) => {
+export const gaussian_pulse = (t, t0 = 0, sigma = 1, A = 1) => {
     const f = (v) => A * Math.exp(-((v - t0) ** 2) / (2 * sigma ** 2));
     if (Array.isArray(t)) return t.map(f);
     return f(t);
 };
 
 // Exponential pulse (causal)
-export const expPulse = (t, t0 = 0, alpha = 1, A = 1) => {
+export const exp_pulse = (t, t0 = 0, alpha = 1, A = 1) => {
     const f = (v) => (v >= t0 ? A * Math.exp(-alpha * (v - t0)) : 0);
     if (Array.isArray(t)) return t.map(f);
     return f(t);

package/src/signal/functions/window/index.js

@@ -109,7 +109,6 @@ export const gaussian_window = (N, sigma = 0.4, ArrayType = Float64Array) => {
   return w;
 };
 
-
 const sinc = (x) => x === 0 ? 1 : sin(PI * x) / (PI * x);
 export const lanczos_window = (N, ArrayType = Float64Array) => {
   const w = new ArrayType(N);

package/src/typed-matrix/abstract/AbstractFloatMatrix.js

@@ -0,0 +1,43 @@
+import { AbstractIntMatrix } from "./AbstractIntMatrix.js";
+import { typed_matrix_inv } from './helpers/index.js'
+import {
+    map,
+    lerp,
+    clamp,
+    norm,
+} from 'ziko/math/functions'
+export class AbstractFloatMatrix extends AbstractIntMatrix{
+    constructor(rows, cols, data, type){
+        super(rows, cols, data, type)
+    }
+    get inv(){
+        return typed_matrix_inv(this)
+    }
+    get range(){
+        return {
+            map : (xmin, xmax, ymin, ymax) => {
+                // To Do
+                return this;
+            },
+            norm : (min, max) => {
+                this.data = this.data.map(
+                    n => min !== max ? (n - min) / ( max - min) : 0 
+                )
+                return this;
+            },
+            lerp : (min, max) => {
+                this.data = this.data.map(
+                    n => min !== max ? (max - min) * n + min : 0 
+                )
+                return this;
+            },
+            clamp : (min, max) => {
+                this.data = this.data.map(
+                    n => Math.min(Math.max(n, min), max)
+                );
+                return this;
+            },
+
+        }
+    }
+}

package/src/typed-matrix/abstract/AbstractIntMatrix.js

@@ -0,0 +1,6 @@
+import { AbstractTypedMatrix } from "./AbstractTypedMatrix.js";
+export class AbstractIntMatrix extends AbstractTypedMatrix{
+    constructor(rows, cols, data, type){
+        super(rows, cols, data, type)
+    }
+}

package/src/typed-matrix/abstract/AbstractTypedMatrix.js

@@ -0,0 +1,230 @@
+import { 
+    typed_matrix_constructor,
+    maintain_indexes,
+    maintain_arr,
+    hstack,
+    vstack,
+    arithmetic,
+    typed_matrix_dot,
+    typed_matrix_det,
+    typed_matrix_rank,
+} from './helpers/index.js'
+export class AbstractTypedMatrix{
+    constructor(rows, cols, arr, type){
+        [
+            this.rows,
+            this.cols,
+            this.data,
+            this.type
+        ] = typed_matrix_constructor(rows, cols, arr, type);
+        maintain_indexes(this)
+    }
+    isMatrix(){
+        return true;
+    }
+    isTypedMatrix(){
+        return true;
+    }
+    clone(){
+        return new this.constructor(this.rows, this.cols, this.data, this.type);
+    }
+    get size(){
+        return this.rows * this.cols;
+    }
+    get shape(){
+        return [this.rows, this.cols]
+    }
+    get arr(){
+        const arr = new Array(this.rows);
+        for(let i = 0; i < this.rows; i++){
+            const arr_col = new this.type(this.cols);
+            for(let j = 0; j < this.cols; j++)
+                arr_col[j] = this.data[i * this.cols + j]
+            arr[i] = arr_col
+        }
+        return arr;
+    }
+    at(i, j){
+        if(i < 0) i += this.rows;
+        if(i < 0 || i >= this.rows) throw new Error('Row index out of bounds');
+        if(j === undefined) 
+            return this.data.slice(i * this.cols, (i + 1) * this.cols);
+        if(j < 0) j += this.cols;
+        if(j < 0 || j >= this.cols) throw new Error('Column index out of bounds');
+        return this.data[i * this.cols + j];
+    }
+    [Symbol.iterator](){
+        return this.arr[Symbol.iterator]
+    }
+    serialize(){
+        return JSON.stringify({
+            type : 'TypedMatrix',
+            data : {
+                rows : this.rows,
+                cols : this.cols,
+                t : this.type.name,
+                arr : [...this.data]
+            }
+        })
+    }
+    static deserialize(json){
+        const {type, data} = JSON.parse(json);
+        const {rows, cols, arr, t} = data
+        return new this(rows, cols, arr, globalThis[t])
+    }
+    reshape(newRows, newCols){
+        if(!(newRows * newCols === this.rows * this.cols)) throw Error('size not matched');
+        const oldRows = this.rows;
+        this.rows = newRows;
+        this.cols = newCols;
+        maintain_indexes(this, oldRows)
+        return this;
+    }
+    get T(){
+        let transpose = new this.data.constructor(this.size);
+        let i, j;
+        for (i = 0; i < this.cols; i++) {
+            for (j = 0; j < this.rows; j++)
+                transpose[i * this.rows + j] = this.data[j * this.rows + i]
+        }
+        [this.cols, this.rows] = this.shape;
+        return this
+    }
+    get det(){
+        return + typed_matrix_det(this).toFixed(14)
+    }
+    get rank(){
+        return typed_matrix_rank(this)
+    }
+    static zeros(rows, cols){
+        return new this(rows, cols, new Array(rows * cols).fill(0), this.type)
+    }
+    static ones(rows, cols){
+        return new this(rows, cols, new Array(rows * cols).fill(1), this.type)
+    }
+    static nums(rows, cols, num){
+        return new this(rows, cols, new Array(rows * cols).fill(num), this.type)
+    }
+    static eye(n){
+        const data = new this.type(n * n);
+        let i, j;
+        for(i = 0; i < n; i++)
+            for(j = 0; j <n; j++)
+                data[i * n + j] = i === j ? 1 : 0
+        return new this(n, n, data);
+    }
+    toPrecesion(p){
+        this.data = this.data.map(n => n.toPrecesion(p));
+        return this;
+    }
+    toFixed(p){
+        this.data = this.data.map(n => n.toFixed(p));
+        return this;
+    }
+    hstack(...matrices){
+        Object.assign(
+            this,
+            [this, ...matrices].reduce((a, b) => hstack(a, b))
+        );
+        maintain_arr(this);
+        return this;
+    }
+    vstack(...matrices){
+        Object.assign(
+            this, 
+            [this, ...matrices].reduce((a, b) => vstack(a, b))
+        );
+        maintain_arr(this);
+        maintain_indexes(this, this.rows);
+        return this;
+    }
+    hqueue(...matrices){
+        Object.assign(
+            this,
+            [this, ...matrices].reverse().reduce((a,b)=>hstack(a, b))
+        );
+        maintain_arr(this);
+        return this;
+    }
+    vqueue(...matrices){
+        Object.assign(
+            this,
+            [this, ...matrices].reverse().reduce((a,b)=>vstack(a, b))
+        );
+        maintain_arr(this);
+        maintain_indexes(this, this.rows);
+        return this;
+    }
+    forEach(fn){
+        this.data.forEach(fn);
+        return this;
+    }
+    forEachRow(fn){
+
+    }
+    map(fn){
+        this.data = this.data.map(fn);
+        return this;
+    }
+    sort(fn){
+        this.data = this.data.sort(fn);
+        return this;
+    }
+    shuffle(){
+        return this.sort(() => 0.5-Math.random())
+    }
+    reduce(fn, initialValue){
+        return this.data.reduce(fn, initialValue);
+    }
+    every(fn){
+        return this.data.every(fn);
+    }
+    some(fn){
+        return this.data.some(fn)
+    }
+
+    get isSquare(){
+        return this.rows === this.cols;
+    }
+
+    add(...M){
+        return arithmetic.call(
+            this,
+            (a, b) => a + b,
+            ...M 
+        )
+    }
+    sub(...M){
+        return arithmetic.call(
+            this,
+            (a, b) => a - b,
+            ...M 
+        )
+    }
+    mul(...M){
+        return arithmetic.call(
+            this,
+            (a, b) => a * b,
+            ...M 
+        )
+    }
+    div(...M){
+        return arithmetic.call(
+            this,
+            (a, b) => a / b,
+            ...M 
+        )
+    }
+    modulo(...M){
+        return arithmetic.call(
+            this,
+            (a, b) => a % b,
+            ...M 
+        )
+    }
+    dot(...M){
+       typed_matrix_dot(this, ...M)
+       return this
+    }
+
+}

package/src/typed-matrix/abstract/helpers/arithmetic.js

@@ -0,0 +1,33 @@
+import { maintain_arr } from "./maintain.js";
+export function arithmetic(fn, ...M){
+    let i, j, k;
+    for(k = 0; k < M.length; k++)
+        for(i = 0; i < this.rows; i++)
+            for(j = 0; j < this.cols; j++)
+                this.data[i * this.cols + j] = fn(this.data[i * this.cols + j], M[k].data[i * this.cols + j])
+    maintain_arr(this)
+    return this;
+}
+
+export function typed_matrix_dot(M1, ...Ms) {
+  for (const M2 of Ms) {
+    if (M1.cols !== M2.rows)
+      throw new Error("Matrix shape mismatch");
+    const {rows, cols} = M1
+    const outCols = M2.cols;
+    const out = new M1.type(rows * outCols);
+    for (let i = 0; i < rows; i++) {
+      const aRowOffset = i * cols;
+      const outRowOffset = i * outCols;
+      for (let j = 0; j < outCols; j++) {
+        let sum = 0;
+        for (let k = 0; k < cols; k++)
+          sum += M1.data[aRowOffset + k] * M2.data[k * outCols + j];
+        out[outRowOffset + j] = sum;
+      }
+    }
+    M1.data = out;
+    M1.cols = outCols;
+  }
+  return M1;
+}

package/src/typed-matrix/abstract/helpers/constructor.js

@@ -0,0 +1,37 @@
+export const typed_matrix_constructor = (rows, cols, arr, type = Float32Array) => {
+  if(typeof rows === 'number' && typeof cols === 'number'){
+    if(arr instanceof Array){
+      let typed_arr = new type(rows * cols), i;
+      for(i = 0; i < rows * cols ; i++)
+        typed_arr[i] = arr[i]
+      arr = typed_arr
+    }
+    return [
+        rows,
+        cols, 
+        arr,
+        type
+    ]
+  }
+  if(rows instanceof Array){
+    const r = rows.length;
+    const c = rows[0].length;
+    let i;
+    arr = new type(r * c);
+    for(i = 0; i < r*c ; i++){
+      arr[i] = rows.flat(1)[i]
+    }
+    return [
+      r,
+      c,
+      arr,
+      type
+    ]
+  }
+};
+
+
+
+// const [r,c, arr]= typed_matrix_constructor([[1,2],[3,4]], null, null, Float64Array)
+
+// console.log(r,c, arr)

package/src/typed-matrix/abstract/helpers/det.js

@@ -0,0 +1,41 @@
+export const typed_matrix_det = M => {
+    if (!M.isSquare)
+        throw new Error("Determinant is defined only for square matrices");
+
+    const n = M.rows;
+    const A = new M.data.constructor(M.data); // clone data
+    let det = 1;
+    let sign = 1;
+
+    for (let i = 0; i < n; i++) {
+        // Find pivot
+        let pivot = i;
+        for (let r = i + 1; r < n; r++) {
+            if (Math.abs(A[r * n + i]) > Math.abs(A[pivot * n + i]))
+                pivot = r;
+        }
+        // Zero pivot → det = 0
+        if (A[pivot * n + i] === 0)
+            return 0;
+        // Row swap
+        if (pivot !== i) {
+            for (let c = 0; c < n; c++) {
+                const tmp = A[i * n + c];
+                A[i * n + c] = A[pivot * n + c];
+                A[pivot * n + c] = tmp;
+            }
+            sign *= -1;
+        }
+
+        const pivotVal = A[i * n + i];
+        det *= pivotVal;
+        // Eliminate below
+        for (let r = i + 1; r < n; r++) {
+            const factor = A[r * n + i] / pivotVal;
+            for (let c = i; c < n; c++) {
+                A[r * n + c] -= factor * A[i * n + c];
+            }
+        }
+    }
+    return det * sign;
+}

package/src/typed-matrix/abstract/helpers/index.js

@@ -0,0 +1,7 @@
+export * from './constructor.js'
+export * from './maintain.js'
+export * from './stack.js'
+export * from './arithmetic.js'
+export * from './det.js'
+export * from './inv.js'
+export * from './rank.js'

package/src/typed-matrix/abstract/helpers/inv.js

@@ -0,0 +1,66 @@
+export const typed_matrix_inv = M =>{
+    if (!M.isSquare)
+        throw new Error("Inverse is defined only for square matrices");
+    if(M.det === 0) return NaN
+
+    const n = M.rows;
+    const Type = M.type;
+
+    // Copy of A
+    const A = new Type(M.data);
+
+    // Identity matrix
+    const I = new Type(n * n);
+    for (let i = 0; i < n; i++)
+        I[i * n + i] = 1;
+
+    for (let i = 0; i < n; i++) {
+        // Find pivot
+        let pivot = i;
+        let max = Math.abs(A[i * n + i]);
+
+        for (let r = i + 1; r < n; r++) {
+            const v = Math.abs(A[r * n + i]);
+            if (v > max) {
+                max = v;
+                pivot = r;
+            }
+        }
+
+        if (A[pivot * n + i] === 0)
+            throw new Error("Matrix is singular and cannot be inverted");
+
+        // Swap rows in A and I
+        if (pivot !== i) {
+            for (let c = 0; c < n; c++) {
+                let tmp = A[i * n + c];
+                A[i * n + c] = A[pivot * n + c];
+                A[pivot * n + c] = tmp;
+
+                tmp = I[i * n + c];
+                I[i * n + c] = I[pivot * n + c];
+                I[pivot * n + c] = tmp;
+            }
+        }
+
+        // Normalize pivot row
+        const pivotVal = A[i * n + i];
+        for (let c = 0; c < n; c++) {
+            A[i * n + c] /= pivotVal;
+            I[i * n + c] /= pivotVal;
+        }
+
+        // Eliminate other rows
+        for (let r = 0; r < n; r++) {
+            if (r === i) continue;
+            const factor = A[r * n + i];
+            if (factor === 0) continue;
+            for (let c = 0; c < n; c++) {
+                A[r * n + c] -= factor * A[i * n + c];
+                I[r * n + c] -= factor * I[i * n + c];
+            }
+        }
+    }
+
+    return new M.constructor(n, n, I, Type);
+}

package/src/typed-matrix/abstract/helpers/maintain.js

@@ -0,0 +1,24 @@
+export const maintain_arr = (Matrix) =>{
+    const arr = new Array(Matrix.rows);
+        for(let i = 0; i < Matrix.rows; i++){
+            const arr_col = new Matrix.type(Matrix.cols);
+            for(let j = 0; j < Matrix.cols; j++)
+                arr_col[j] = Matrix.data[i * Matrix.cols + j]
+            arr[i] = arr_col
+        }
+    Matrix.arr = arr
+}
+export const maintain_indexes = (Matrix, oldRows) =>{
+    for (let i = 0; i < Matrix.arr.length; i++) {
+        Object.defineProperty(Matrix, i, {
+            value: Matrix.arr[i],
+            writable: true,
+            configurable: true,
+            enumerable: false
+        });
+    }
+    for (let i = Matrix.arr.length; i < oldRows; i++) {
+        delete Matrix[i];
+    }
+}
+

package/src/typed-matrix/abstract/helpers/rank.js

@@ -0,0 +1,49 @@
+export const typed_matrix_rank = M =>{
+    const m = M.rows;
+    const n = M.cols;
+    const A = M.clone();
+    const eps = 1e-12;
+
+    let rank = 0;
+    let row = 0;
+
+    for (let col = 0; col < n && row < m; col++) {
+        // Find pivot
+        let pivot = row;
+        let max = Math.abs(A[row * n + col]);
+
+        for (let r = row + 1; r < m; r++) {
+            const v = Math.abs(A[r * n + col]);
+            if (v > max) {
+                max = v;
+                pivot = r;
+            }
+        }
+
+        // No pivot in this column
+        if (max < eps) continue;
+
+        // Swap rows
+        if (pivot !== row) {
+            for (let c = col; c < n; c++) {
+                const tmp = A[row * n + c];
+                A[row * n + c] = A[pivot * n + c];
+                A[pivot * n + c] = tmp;
+            }
+        }
+
+        // Eliminate below
+        const pivotVal = A[row * n + col];
+        for (let r = row + 1; r < m; r++) {
+            const factor = A[r * n + col] / pivotVal;
+            if (Math.abs(factor) < eps) continue;
+            for (let c = col; c < n; c++)
+                A[r * n + c] -= factor * A[row * n + c];
+        }
+
+        rank++;
+        row++;
+    }
+
+    return rank;
+}

package/src/typed-matrix/abstract/helpers/stack.js

@@ -0,0 +1,14 @@
+export function hstack(M1, M2){
+    M1 = M1.clone();
+    M2 = M2.clone();
+    if (M1.rows !== M2.rows) return;
+    if (M1.type !== M2.type) return;
+    const data = new M1.type(M1.size + M2.size)
+    data.set(M1.data, 0)
+    data.set(M2.data, M1.data.length)
+    return new M1.constructor(M1.rows, M1.cols + M2.cols, data);
+}
+
+export function vstack(M1, M2){
+    return hstack(M1.T, M2.T).T
+}

package/src/typed-matrix/abstract/index.js

@@ -0,0 +1,2 @@
+export * from './AbstractIntMatrix.js'
+export * from './AbstractFloatMatrix.js'

package/src/typed-matrix/index.js

@@ -0,0 +1,91 @@
+import { 
+    AbstractIntMatrix,
+    AbstractFloatMatrix
+} from "./abstract/index.js";
+export class I8Matrix extends AbstractIntMatrix{
+    constructor(rows, cols, data){
+        super(rows, cols, data, Int8Array)
+    }
+}
+export class I16Matrix extends AbstractIntMatrix{
+    constructor(rows, cols, data){
+        super(rows, cols, data, Int16Array)
+    }
+}
+export class I32Matrix extends AbstractIntMatrix{
+    constructor(rows, cols, data){
+        super(rows, cols, data, Int32Array)
+    }
+}
+// export class I64Matrix extends AbstractIntMatrix{
+//     constructor(rows, cols, data){
+//         super(rows, cols, data, Int64Array)
+//     }
+// }
+
+export class U8Matrix extends AbstractIntMatrix{
+    constructor(rows, cols, data){
+        super(rows, cols, data, Uint8Array)
+    }
+}
+export class U16Matrix extends AbstractIntMatrix{
+    constructor(rows, cols, data){
+        super(rows, cols, data, Uint16Array)
+    }
+}
+export class U32Matrix extends AbstractIntMatrix{
+    constructor(rows, cols, data){
+        super(rows, cols, data, Uint32Array)
+    }
+}
+// export class U64Matrix extends AbstractTypedMatrix{
+//     constructor(rows, cols, data){
+//         super(rows, cols, data, Uint64Array)
+//     }
+// }
+
+export class F16Matrix extends AbstractFloatMatrix{
+    constructor(rows, cols, data){
+        super(rows, cols, data, Float16Array)
+    }
+}
+export class F32Matrix extends AbstractFloatMatrix{
+    constructor(rows, cols, data){
+        super(rows, cols, data, Float32Array)
+    }
+}
+export class F64Matrix extends AbstractFloatMatrix{
+    static type = Float64Array
+    constructor(rows, cols, data){
+        super(rows, cols, data, Float64Array)
+    }
+}
+
+export class BI64Matrix extends AbstractIntMatrix{
+    constructor(rows, cols, data){
+        super(rows, cols, data, BigInt64Array)
+    }
+}
+
+export class BU64Matrix extends AbstractIntMatrix{
+    constructor(rows, cols, data){
+        super(rows, cols, data, BigUint64Array)
+    }
+}
+
+export const matrix_i8 = (rows, cols, data) => new I8Matrix(rows, cols, data)
+export const matrix_i16 = (rows, cols, data) => new I16Matrix(rows, cols, data)
+export const matrix_i32 = (rows, cols, data) => new I32Matrix(rows, cols, data)
+export const matrix_i64 = (rows, cols, data) => new I16Matrix(rows, cols, data)
+
+export const matrix_u8 = (rows, cols, data) => new U8Matrix(rows, cols, data)
+export const matrix_u16 = (rows, cols, data) => new U16Matrix(rows, cols, data)
+export const matrix_u32 = (rows, cols, data) => new U32Matrix(rows, cols, data)
+export const matrix_u64 = (rows, cols, data) => new U16Matrix(rows, cols, data)
+
+export const matrix_f16 = (rows, cols, data) => new F16Matrix(rows, cols, data)
+export const matrix_f32 = (rows, cols, data) => new F32Matrix(rows, cols, data)
+export const matrix_f64 = (rows, cols, data) => new F16Matrix(rows, cols, data)
+
+export const matrix_bi64 = (rows, cols, data) => new BI64Matrix(rows, cols, data)
+export const matrix_bu64 = (rows, cols, data) => new BI64Matrix(rows, cols, data)

package/src/typed-matrix/test.js

@@ -0,0 +1,29 @@
+import { F64Matrix } from "./index.js";
+
+const M = new F64Matrix(3,3, [1,2,3,4,5,6,7,8,9], Int16Array)
+const M1 = M.clone()
+// const M2 = new AbstractTypedMatrix()
+
+// console.log(M.data)
+// console.log(M.at(0))
+// console.log(M.T.at(0))
+
+// console.log(M.hstack(M).arr)
+
+// console.log(M.arr)
+
+// M.arr[0][0] = 17
+
+
+// console.log(M.mul(M).T)
+
+// console.log(M.range.norm(0, 10).rank)
+
+// console.log(F64Matrix.ones(3,3).rank)
+
+// console.log(F64Matrix.eye(3).reshape(1,)[0])
+
+const S = M.serialize()
+console.log(S)
+
+console.log(F64Matrix.deserialize(S))