numz 0.2.0 → 0.4.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "scientific computing with zikojs",
   "main": "index.js",
   "type": "module",

package/src/signal/functions/index.js

@@ -1,3 +1,4 @@
 export * from './pulse/index.js'
 export * from './sequence/index.js'
-export * from './periodic/index.js'
+export * from './periodic/index.js'
+export * from './window/index.js'

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

@@ -0,0 +1,141 @@
+const {cos, sin, abs, sqrt, exp, PI} = Math
+export const hanning_window=(N, ArrayType = Float64Array)=>{
+  const w = new ArrayType(N);
+  const factor = 2 * PI / N;
+  for (let n = 0; n < N; n++) 
+    w[n] = 0.5 - 0.5 * cos(factor * n);
+  return w;
+}
+
+export const hamming_window=(N, ArrayType = Float64Array)=>{
+  const w = new ArrayType(N);
+  const factor = 2 * PI / N;
+  for (let n = 0; n < N; n++)
+    w[n] = 0.54 - 0.46 * cos(factor * n);
+  return w;
+}
+
+const I0 = (x) => {
+  let sum = 1;
+  let u = 1;
+  let k = 1;
+  const x2 = (x * x) / 4;
+  while (true) {
+    // const prev = u;
+    u *= x2 / (k * k);
+    sum += u;
+    if (u < 1e-10 * sum) break;
+    k++;
+  }
+  return sum;
+};
+
+export const kaiser_window = (N, beta = 5, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const denom = I0(beta);
+  for (let n = 0; n < N; n++) {
+    const r = (2 * n) / (N - 1) - 1;
+    w[n] = I0(beta * sqrt(1 - r * r)) / denom;
+  }
+  return w;
+};
+
+export const blackman_window = (N, beta = 0.16, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const factor = 2 * PI / N;
+  const a0 = (1 - beta) / 2;
+  const a1 = 0.5;
+  const a2 = beta / 2;
+  for (let n = 0; n < N; n++) 
+    w[n] = a0,- a1 * cos(factor * n) + a2 * cos(2 * factor * n);
+  return w;
+};
+
+export const bartlett_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  for (let n = 0; n < N; n++)
+    w[n] = 1 - abs((2 * n) / (N - 1) - 1);
+  return w;
+};
+
+export const blackman_harris_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const a0 = 0.35875;
+  const a1 = 0.48829;
+  const a2 = 0.14128;
+  const a3 = 0.01168;
+  const f = 2 * PI / N;
+  for (let n = 0; n < N; n++)
+    w[n] = a0 - a1 * cos(f * n) + a2 * cos(2 * f * n) - a3 * cos(3 * f * n);
+  return w;
+};
+
+export const nuttall_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const f = 2 * PI / N;
+  for (let n = 0; n < N; n++)
+    w[n] = 0.355768 - 0.487396 * cos(f * n) + 0.144232 * cos(2 * f * n) - 0.012604 * cos(3 * f * n);
+  return w;
+};
+
+export const flat_top_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const f = 2 * PI / N;
+  for (let n = 0; n < N; n++)
+    w[n] = 1 - 1.93 * cos(f * n) + 1.29 * cos(2 * f * n) - 0.388 * cos(3 * f * n) + 0.028 * cos(4 * f * n);
+  return w;
+};
+
+export const tukey_window = (N, alpha = 0.5, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const edge = alpha * (N - 1) / 2;
+  for (let n = 0; n < N; n++) {
+    if (n < edge)
+      w[n] = 0.5 * (1 + cos(PI * (2*n/(alpha*(N-1)) - 1)));
+    else if (n > (N - 1 - edge))
+      w[n] = 0.5 * (1 + cos(PI * (2*n/(alpha*(N-1)) - 2/alpha + 1)));
+    else 
+      w[n] = 1;
+  }
+  return w;
+};
+
+export const gaussian_window = (N, sigma = 0.4, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const m = (N - 1) / 2;
+  const s2 = sigma * m;
+  for (let n = 0; n < N; n++)
+    w[n] = exp(-0.5 * ((n - m) / s2) ** 2);
+  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);
+  for (let n = 0; n < N; n++)
+    w[n] = sinc(2 * n / (N - 1) - 1);
+  return w;
+};
+
+export const poisson_window = (N, alpha = 3, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const m = (N - 1) / 2;
+  for (let n = 0; n < N; n++)
+    w[n] = exp(-alpha * abs(n - m) / m);
+  return w;
+};
+
+export const rect_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  w.fill(1);
+  return w;
+};
+
+export const tri_window = (N, ArrayType = Float64Array) => {
+  const w = new ArrayType(N);
+  const M = (N - 1) / 2;
+  for (let n = 0; n < N; n++) {
+    w[n] = 1 - abs((n - M) / M);
+  }
+  return w;
+};

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

package/test/index.js

@@ -1,39 +1,52 @@
-import { fft, ifft } from "../src/signal/fft/index.js";
-import { conv, conv2 } from '../src/signal/conv/index.js'
-import { Complex } from "ziko/math/complex";
-// import { cos } from 'ziko/math/functions'
+// import { fft, ifft } from "../src/signal/fft/index.js";
+// import { conv, conv2 } from '../src/signal/conv/index.js'
+// import { Complex } from "ziko/math/complex";
+// // import { cos } from 'ziko/math/functions'
+
+// // const x = Array.from({ length: 100 }, (_, j)=> j/10)
+// // const y = cos(x)
+
+// // const ff = fft(x)
+// // // const ff = fft([1,2,3])
+// // // console.log(ff)
+
+// // // console.log(ifft(ff))
+// const signal = [1, 2, 3, 4, 5];
+// let kernel = [1, 0.5];
+// // kernel = [1, new Complex(0, 0.5)];
+// const result = conv(signal, kernel);
+// console.log(
+//    result
+// )
 
-// const x = Array.from({ length: 100 }, (_, j)=> j/10)
-// const y = cos(x)
-
-// const ff = fft(x)
-// // const ff = fft([1,2,3])
 // // console.log(ff)
+// // console.log(ifft(ff).map(n=>+ n.a.toFixed(7)))
+// // console.log(x)
+
+
+// // Example usage:
+// const image = [
+//     [1, 2, 3],
+//     [4, 5, 6],
+//     [7, 8, 9]
+// ];
+
+// const filter = [
+//     [1, 0],
+//     [0, 1]
+// ];
+
+// console.log(conv2(image, filter, 'full', 'fill'));
+
+function hanning(N, ArrayType = Float64Array) {
+  const w = new ArrayType(N);
+  const factor = 2 * Math.PI / N;
+
+  for (let n = 0; n < N; n++) {
+    w[n] = 0.5 - 0.5 * Math.cos(factor * n);
+  }
+  return w;
+}
+
+console.log(hanning(10).map(a=>a*20))
 
-// // console.log(ifft(ff))
-const signal = [1, 2, 3, 4, 5];
-let kernel = [1, 0.5];
-// kernel = [1, new Complex(0, 0.5)];
-const result = conv(signal, kernel);
-console.log(
-   result
-)
-
-// console.log(ff)
-// console.log(ifft(ff).map(n=>+ n.a.toFixed(7)))
-// console.log(x)
-
-
-// Example usage:
-const image = [
-    [1, 2, 3],
-    [4, 5, 6],
-    [7, 8, 9]
-];
-
-const filter = [
-    [1, 0],
-    [0, 1]
-];
-
-console.log(conv2(image, filter, 'full', 'fill'));