numz 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "scientific computing with zikojs",
   "main": "index.js",
   "type": "module",
@@ -26,9 +26,9 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^1.0.0",
     "cross-env": "^10.1.0",
-    "rollup": "^4.63.0"
+    "rollup": "^4.63.1"
   },
   "dependencies": {
-    "ziko": "^1.10.0"
+    "ziko": "^2.0.0-alpha.0"
   }
 }

package/src/discret/bitwise/algorithms/index.js

@@ -0,0 +1,34 @@
+
+
+export const bitmasks = (n) => {
+  const res = [];
+  for (let i = 0; i < 1 << n; i++) {
+    const mask = [];
+    for (let j = 0; j < n; j++) mask.push((i >> j) & 1);
+    res.push(mask);
+  }
+  return res;
+};
+export const subsets_by_mask = (arr) => {
+  const n = arr.length,
+    res = [];
+  for (let i = 0; i < 1 << n; i++) {
+    const subset = [];
+    for (let j = 0; j < n; j++) if ((i >> j) & 1) subset.push(arr[j]);
+    res.push(subset);
+  }
+  return res;
+};
+export const gray_code = (n) => {
+  if (n === 0) return [0];
+  const prev = gray_code(n - 1);
+  return [...prev, ...prev.map((x) => x | (1 << (n - 1)))];
+};
+export const hamming_weight = (x) => {
+  let count = 0;
+  while (x) {
+    x &= x - 1;
+    count++;
+  }
+  return count;
+};

package/src/discret/bitwise/conversions/index.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Converts a value from one numerical base to another.
+ *
+ * Supported bases are between 2 and 36.
+ *
+ * @param value Value to convert.
+ * @param fromBase Source base.
+ * @param toBase Target base.
+ *
+ * @example
+ * base2base("1010", 2, 10) // "10"
+ */
+export declare function base2base(
+    value: string | number,
+    fromBase: number,
+    toBase: number
+): string;
+
+/**
+ * Converts binary values to octal.
+ */
+export declare function bin2oct(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts binary values to decimal.
+ */
+export declare function bin2dec(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts binary values to hexadecimal.
+ */
+export declare function bin2hex(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts octal values to binary.
+ */
+export declare function oct2bin(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts octal values to decimal.
+ */
+export declare function oct2dec(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts octal values to hexadecimal.
+ */
+export declare function oct2hex(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts decimal values to binary.
+ */
+export declare function dec2bin(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts decimal values to octal.
+ */
+export declare function dec2oct(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts decimal values to hexadecimal.
+ */
+export declare function dec2hex(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts hexadecimal values to binary.
+ */
+export declare function hex2bin(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts hexadecimal values to octal.
+ */
+export declare function hex2oct(
+    ...x: (string | number)[]
+): string[];
+
+/**
+ * Converts hexadecimal values to decimal.
+ */
+export declare function hex2dec(
+    ...x: (string | number)[]
+): string[];

package/src/discret/bitwise/conversions/index.js

@@ -0,0 +1,61 @@
+export const base2base = (value, fromBase, toBase) => {
+    if (fromBase < 2 || fromBase > 36 || toBase < 2 || toBase > 36)
+        throw new TypeError('Base must be between 2 and 36');
+
+    const dec = parseInt(value, fromBase);
+    if (Number.isNaN(dec)) throw new TypeError('Invalid value for the given base');
+
+    return dec.toString(toBase);
+};
+
+export const bin2oct = (...x) => mapfun(
+    n => base2base(n, 2, 8),
+    ...x
+)
+export const bin2dec = (...x) => mapfun(
+    n => base2base(n, 2, 10),
+    ...x
+)
+export const bin2hex = (...x) => mapfun(
+    n => base2base(n, 2, 16),
+    ...x
+)
+
+export const oct2bin = (...x) => mapfun(
+    n => base2base(n, 8, 2),
+    ...x
+)
+export const oct2dec = (...x) => mapfun(
+    n => base2base(n, 8, 10),
+    ...x
+)
+export const oct2hex = (...x) => mapfun(
+    n => base2base(n, 8, 16),
+    ...x
+)
+
+export const dec2bin = (...x) => mapfun(
+    n => base2base(n, 10, 2),
+    ...x
+)
+export const dec2oct = (...x) => mapfun(
+    n => base2base(n, 10, 8),
+    ...x
+)
+export const dec2hex = (...x) => mapfun(
+    n => base2base(n, 10, 16),
+    ...x
+)
+
+export const hex2bin = (...x) => mapfun(
+    n => base2base(n, 16, 2),
+    ...x
+)
+export const hex2oct = (...x) => mapfun(
+    n => base2base(n, 16, 8),
+    ...x
+)
+export const hex2dec = (...x) => mapfun(
+    n => base2base(n, 16, 10),
+    ...x
+)

package/src/discret/bitwise/index.js

@@ -1,34 +1,3 @@
-
-
-export const bitmasks = (n) => {
-  const res = [];
-  for (let i = 0; i < 1 << n; i++) {
-    const mask = [];
-    for (let j = 0; j < n; j++) mask.push((i >> j) & 1);
-    res.push(mask);
-  }
-  return res;
-};
-export const subsets_by_mask = (arr) => {
-  const n = arr.length,
-    res = [];
-  for (let i = 0; i < 1 << n; i++) {
-    const subset = [];
-    for (let j = 0; j < n; j++) if ((i >> j) & 1) subset.push(arr[j]);
-    res.push(subset);
-  }
-  return res;
-};
-export const gray_code = (n) => {
-  if (n === 0) return [0];
-  const prev = gray_code(n - 1);
-  return [...prev, ...prev.map((x) => x | (1 << (n - 1)))];
-};
-export const hamming_weight = (x) => {
-  let count = 0;
-  while (x) {
-    x &= x - 1;
-    count++;
-  }
-  return count;
-};
+export * from './operations/index.js'
+export * from './conversions/index.js'
+export * from './algorithms/index.js'

package/src/discret/bitwise/operations/index.d.ts

@@ -0,0 +1,53 @@
+import type { Complex } from "../../complex/indexxx
+import { Matrix } from '../../matrix/index.jsssss
+
+export type LogicValue = 0 | 1 | Complex | Matrix;
+
+/**
+ * Logical NOT operation.
+ */
+export declare const not: (
+    x: LogicValue
+) => LogicValue;
+
+/**
+ * Logical AND operation.
+ */
+export declare const and: (
+    ...x: LogicValue[]
+) => LogicValue;
+
+/**
+ * Logical OR operation.
+ */
+export declare const or: (
+    ...x: LogicValue[]
+) => LogicValue;
+
+/**
+ * Logical XOR operation.
+ */
+export declare const xor: (
+    ...x: LogicValue[]
+) => LogicValue;
+
+/**
+ * Logical NAND operation.
+ */
+export declare const nand: (
+    ...x: LogicValue[]
+) => LogicValue;
+
+/**
+ * Logical NOR operation.
+ */
+export declare const nor: (
+    ...x: LogicValue[]
+) => LogicValue;
+
+/**
+ * Logical XNOR operation.
+ */
+export declare const xnor: (
+    ...x: LogicValue[]
+) => LogicValue;

package/src/discret/bitwise/operations/index.js

@@ -0,0 +1,54 @@
+export const not = x => {
+    if(x.isComplex?.()) return new x.constructor(not(x.a), not(x.b))
+    if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, x.arr.flat(1).map(not))
+    return + !x;
+}
+const handle_complex_and_matrix = (x, operation) => {
+    if (x.every(n => n.isComplex?.())) {
+        const Re = x.map(n => n.a);
+        const Im = x.map(n => n.b);
+        return new x[0].constructor(
+            operation(...Re),
+            operation(...Im)
+        );
+    }
+
+    if (x.every(n => n.isMatrix?.())) {
+        if (!x.every(mat => mat.rows === x[0].rows && mat.cols === x[0].cols)) {
+            return TypeError('All matrices must have the same shape');
+        }
+
+        const { rows, cols } = x[0];
+        const Y = Array.from({ length: rows }, (_, i) =>
+            Array.from({ length: cols }, (_, j) =>
+                operation(...x.map(mat => mat.arr[i][j]))
+            )
+        );
+        return new x[0].constructor(Y);
+    }
+
+    return null;  // Return null if no Complex or Matrix found
+};
+
+export const and = (...x) => {
+    const result = handle_complex_and_matrix(x, and);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n &= m), 1);
+};
+
+export const or = (...x) => {
+    const result = handle_complex_and_matrix(x, or);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n |= m), 0);
+};
+
+export const xor = (...x) => {
+    const result = handle_complex_and_matrix(x, xor);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n ^= m), 0);
+};
+
+export const nand = (...x) => not(and(...x));
+export const nor = (...x) => not(or(...x));
+export const xnor = (...x) => not(xor(...x));
+

package/src/discret/index.js

@@ -1,4 +1,4 @@
+export * from './bitwise/index.js'
 export * from './combination/index.js'
 export * from './permutation/index.js'
-export * from './sequences'
-export * from './bitwise'
+export * from './sequences/index.js'

package/src/index.js

@@ -1,6 +1,10 @@
 export * from './ufunc/index.js'
 export * from './random/index.js'
 export * from './complex/index.js'
+export * from './matrix/index.js'
+export * from './typed-matrix/index.js'
+export * from './discret/bitwise/index.js'
 export * from './calculus/index.js'
 export * from './signal/index.js'
 export * from './stats/index.js'
+

package/src/matrix/helpers/constructor.js

@@ -0,0 +1,31 @@
+export const matrix_constructor = (Matrix, rows, cols, element) => {
+  if (rows instanceof Matrix) {
+    arr = rows.arr;
+    rows = rows.rows;
+    cols = rows.cols;
+  } 
+  else {
+    let arr = [], i, j;
+    if (rows instanceof Array) {
+        arr = rows;
+        rows = arr.length;
+        cols = arr[0].length;
+    } 
+    else {
+      for (i = 0; i < rows; i++) {
+        arr.push([]);
+        arr[i].push(new Array(cols));
+        for (j = 0; j < cols; j++) {
+          arr[i][j] = element[i * cols + j];
+          if (element[i * cols + j] == undefined) arr[i][j] = 0;
+        }
+      }
+    }
+    return [
+        rows,
+        cols,
+        arr
+    ]
+  }
+};
+

package/src/matrix/helpers/det.js

@@ -0,0 +1,36 @@
+import { add, sub, mul } from "ziko/math/arithmetic";
+import { pow } from "../../functions/index.js";
+export function matrix_det(M) {
+    if (!M.isSquare) return new Error("is not square matrix");
+    if (M.rows == 1) return M.arr[0][0];
+    function determinat(M) {
+        if (M.length == 2) {
+            if (M.flat(1).some((n) => n?.isMatrix?.())) {
+                console.warn("Tensors are not completely supported yet ...");
+                return;
+            }
+            return sub(mul(M[0][0],M[1][1]),mul(M[0][1],M[1][0]))
+        }
+        var answer = 0;
+        for (var i = 0; i < M.length; i++) {
+            //console.log(M[0][i]);
+            /*answer = answer.add(
+                pow(-1, i)
+                    .mul(M[0][i])
+                    .mul(determinat(deleteRowAndColumn(M, i)))
+            );*/
+            //const to_be_added=add(mul(pow(-1, i),mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
+            const to_be_added=add(mul(pow(-1, i),mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
+            answer=add(answer,to_be_added)
+        }
+        return answer;
+    }
+    return determinat(M.arr);
+}
+function deleteRowAndColumn(M, index) {
+    var temp = [];
+    for (let i = 0; i < M.length; i++) temp.push(M[i].slice(0));
+    temp.splice(0, 1);
+    for (let i = 0; i < temp.length; i++) temp[i].splice(index, 1);
+    return temp;
+}

package/src/matrix/helpers/index.js

@@ -0,0 +1,5 @@
+export * from './constructor.js'
+export * from './maintain.js'
+export * from './inverse.js'
+export * from './det.js'
+export * from './stack.js'

package/src/matrix/helpers/inverse.js

@@ -0,0 +1,52 @@
+export function matrix_inverse(M) {
+    if(M.row !== M.cols) throw Error('is not a square matrix"')
+    if (M.det === 0) throw Error("determinant should not equal 0");
+    const { arr } = M
+    if (arr.length !== arr[0].length) return;
+    var i = 0, ii = 0, j = 0, dim = arr.length, e = 0;
+    var I = [], C = [];
+    for (i = 0; i < dim; i += 1) {
+        I[I.length] = [];
+        C[C.length] = [];
+        for (j = 0; j < dim; j += 1) {
+            if (i == j) I[i][j] = 1;
+            else I[i][j] = 0;
+            C[i][j] = arr[i][j];
+        }
+    }
+    for (i = 0; i < dim; i += 1) {
+        e = C[i][i];
+        if (e == 0) {
+            for (ii = i + 1; ii < dim; ii += 1) {
+                if (C[ii][i] != 0) {
+                    for (j = 0; j < dim; j++) {
+                        e = C[i][j];
+                        C[i][j] = C[ii][j];
+                        C[ii][j] = e;
+                        e = I[i][j];
+                        I[i][j] = I[ii][j];
+                        I[ii][j] = e;
+                    }
+                    break;
+                }
+            }
+            e = C[i][i];
+            if (e == 0) return;
+        }
+        for (j = 0; j < dim; j++) {
+            C[i][j] = C[i][j] / e;
+            I[i][j] = I[i][j] / e;
+        }
+        for (ii = 0; ii < dim; ii++) {
+            if (ii == i) {
+                continue;
+            }
+            e = C[ii][i];
+            for (j = 0; j < dim; j++) {
+                C[ii][j] -= e * C[i][j];
+                I[ii][j] -= e * I[i][j];
+            }
+        }
+    }
+    return new M.constructor(I);
+}

package/src/matrix/helpers/maintain.js

@@ -0,0 +1,13 @@
+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/matrix/helpers/stack.js

@@ -0,0 +1,24 @@
+export function hstack(M1, M2){
+    M1 = M1.clone()
+    M2 = M2.clone()
+    if (M1.rows !== M2.rows) return;
+    let newArr = M1.arr;
+    for (let i = 0; i < M1.rows; i++) 
+        for (let j = M1.cols; j < M1.cols + M2.cols; j++) 
+            newArr[i][j] = M2.arr[i][j - M1.cols];
+    M1.cols += M2.cols;
+    return new M1.constructor(M1.rows, M1.cols, newArr.flat(1));
+}
+
+export function vstack(M1, M2){
+    M1 = M1.clone()
+    M2 = M2.clone()
+    if (M1.cols !== M2.cols) return;
+    let newArr = M1.arr;
+    for (let i = M1.rows; i < M1.rows + M2.rows; i++) {
+        newArr[i] = [];
+        for (let j = 0; j < M1.cols; j++) newArr[i][j] = M2.arr[i - M1.rows][j];
+    }
+    M1.rows += M2.rows;
+    return new M1.constructor(M1.rows, M1.cols, newArr.flat(1));
+}

package/src/matrix/index.js

@@ -0,0 +1,557 @@
+import {
+    add,
+    sub, 
+    mul, 
+    div,
+    modulo
+} from 'ziko/math/arithmetic'
+import {
+    map,
+    lerp, 
+    clamp, 
+    norm 
+} from 'ziko/math/utils'
+import { Complex } from "../complex/index.js";
+// import { arr2str } from "../../data/index.js";
+import { 
+    matrix_constructor,
+    maintain_indexes,
+    matrix_inverse,
+    matrix_det,
+    hstack,
+    vstack
+} from "./helpers/index.js";
+import { mapfun } from 'ziko/math/mapfun';
+import { Random } from '../random/index.js';
+class Matrix{
+    constructor(rows, cols, element = [] ) {
+        [
+            this.rows, 
+            this.cols, 
+            this.arr
+        ] = matrix_constructor(Matrix, rows, cols, element);
+        maintain_indexes(this)
+    }
+    isMatrix(){
+        return true
+    }
+    clone() {
+        return new Matrix(this.rows, this.cols, this.arr.flat(1));
+    }
+    toComplex(){
+        this.arr = mapfun(
+            x => x?.isComplex?.() ? x : new Complex(x, 0),
+            ...this.arr
+        )
+        maintain_indexes(this)
+        return this;
+    }
+    [Symbol.iterator]() {
+      return this.arr[Symbol.iterator]();
+    }
+    get size() {
+        return this.rows * this.cols;
+    } 
+    get shape() {
+        return [this.rows, this.cols];
+    }
+    // toString(){
+    //     return arr2str(this.arr,false);
+    // }
+    at(i = 0, j = undefined) {
+        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.arr[i];
+        if(j < 0) j += this.cols;
+        if(j < 0 || j >= this.cols) throw new Error('Column index out of bounds');
+        return this.arr[i][j];
+    }
+    slice(r0=0, c0=0, r1 = this.rows-1, c1 = this.cols-1) {
+        if(r1 < 0) r1 = this.rows + r1
+        if(c1 < 0 ) c1 = this.cols + c1
+        let newRow = r1 - r0,
+            newCol = c1 - c0;
+        let newArr = new Array(newCol);
+        for (let i = 0; i < newRow; i++) {
+            newArr[i] = [];
+            for (let j = 0; j < newCol; j++) 
+                newArr[i][j] = this.arr[i + r0][j + c0];
+        }
+        this.arr = newArr;
+        maintain_indexes(this.rows)
+        this.rows = newRow;
+        this.cols = newCol;
+        return this;
+    }
+    reshape(newRows, newCols) {
+        if(!(newRows * newCols === this.rows * this.cols)) throw Error('size not matched');
+        const oldRows = this.rows;
+        Object.assign(this, new Matrix(newRows, newCols, this.arr.flat(1)));
+        maintain_indexes(oldRows);
+        return this;
+    }
+    get T() {
+        let transpose = [];
+        for (let i = 0; i < this.arr[0].length; i++) {
+            transpose[i] = [];
+            for (let j = 0; j < this.arr.length; j++) 
+                transpose[i][j] = this.arr[j][i];
+        }
+        return new Matrix(this.cols, this.rows, transpose.flat(1));
+    }
+    get det() {
+        return matrix_det(this)
+    }
+    get inv() {
+        return matrix_inverse(this)
+    }
+    // normalize names
+    static eye(size) {
+        let result = new Matrix(size, size);
+        for (let i = 0; i < size; i++) 
+            for (let j = 0; j < size; j++) i === j ? (result.arr[i][j] = 1) : (result.arr[i][j] = 0);
+        return result;
+    }
+    static zeros(rows, cols) {
+        let result = new Matrix(rows, cols);
+        for (let i = 0; i < rows; i++) 
+            for (var j = 0; j < cols; j++) result.arr[i][j] = 0;
+        return result;
+    }
+    static ones(rows, cols) {
+        let result = new Matrix(rows, cols);
+        for (let i = 0; i < rows; i++) 
+            for (let j = 0; j < cols; j++) result.arr[i][j] = 1;
+        return result;
+    }
+    static nums(rows, cols, number) {
+        let result = new Matrix(rows, cols);
+        for (let i = 0; i < rows; i++) 
+            for (let j = 0; j < cols; j++) result.arr[i][j] = number;
+        return result;
+    }
+    static get random(){
+        return {
+            int : (r, c, a, b)=> new Matrix(
+                r,
+                c,
+                Random.sample.int(r*c, a, b)
+            ),
+            float : (r, c, a,)=> new Matrix(
+                r,
+                c,
+                Random.sample.float(r*c, a, b)
+            ),
+        }
+    }
+    get range(){
+        return {
+            map : (xmin, xmax, ymin, ymax) => {
+                this.arr = map(this.arr, xmin, xmax, ymin, ymax);
+                return this;
+            },
+            norm : (min, max) => {
+                this.arr = norm(this.arr, min, max);
+                return this;
+            },
+            lerp : (min, max) => {
+                this.arr = lerp(this.arr, min, max);
+                return this;
+            },
+            clamp : (min, max) => {
+                this.arr = clamp(this.arr, min, max);
+                return this;
+            },
+
+        }
+    }
+    hstack(...matrices) {
+        const M=[this, ...matrices].reduce((a,b)=>hstack(a, b));
+        Object.assign(this, M);
+        maintain_indexes(this);
+        return this;
+    }
+    vstack(...matrices){
+        const M=[this, ...matrices].reduce((a,b)=>vstack(a, b));
+        Object.assign(this, M);
+        maintain_indexes(this);
+        return this;
+    }
+    hqueue(...matrices){
+        const M=[this, ...matrices].reverse().reduce((a,b)=>hstack(a, b));
+        Object.assign(this, M);
+        maintain_indexes(this);
+        return this;
+    }
+    vqueue(...matrices){
+        const M=[this,...matrices].reverse().reduce((a, b)=>vstack(a, b));
+        Object.assign(this, M);
+        maintain_indexes(this);
+        return this;
+    }
+    forEach(fn){
+        this.arr.flat(1).forEach(fn);
+        return this;
+    }
+    forEachRow(fn){
+        this.arr.forEach(fn);
+        return this;
+    }
+    forEachCol(fn){
+        this.clone().T.forEachRow(fn);
+        return this
+    }
+    map(fn){
+        const arr = this.arr.flat(1).map(fn)
+        return new Matrix(
+            this.rows, 
+            this.cols,
+            arr
+        )
+    }
+    mapRows(fn = ()=>{}){
+        this.arr = this.arr.map(fn)
+        return this;
+    }
+    mapCols(fn){
+        return this.clone().T.mapRows(fn).T;
+    }
+    sort(fn = ()=>{}){
+        const arr = this.arr.flat(1).sort(fn)
+        return new Matrix(
+            this.rows, 
+            this.cols,
+            arr
+        )  
+    }
+    shuffle(){
+        return this.sort(() => 0.5-Math.random())
+    }
+    sortRows(fn = ()=>{}){
+        this.arr = this.arr.map(row => row.sort(fn))
+        return this;
+    }
+    shuffleRows(){
+        return this.sortRows(() => 0.5-Math.random())
+    }
+    sortCols(fn){
+        return this.clone().T.sortRows(fn).T;
+    }
+    shuffleCols(){
+        return this.sortCols(() => 0.5-Math.random())
+    }
+    reduce(fn, initialValue){
+        const value = initialValue 
+            ? this.arr.flat(1).reduce(fn, initialValue) 
+            : this.arr.flat(1).reduce(fn);
+        return new Matrix([[value]])
+    }
+    reduceRows(fn, initialValue){
+        const values = initialValue 
+            ? this.arr.map(row => row.reduce(fn, initialValue)) 
+            : this.arr.map(row => row.reduce(fn)) 
+        return new Matrix(1, this.cols, values)
+    }
+    reduceCols(fn, initialValue){
+        return this.T.reduceRows(fn, initialValue).T
+    }
+    filterRows(fn){
+        const mask = this.arr.map(n => n.some(m => fn(m)));
+        const arr = [];
+        let i;
+        for(i = 0; i < mask.length; i++)
+            if(mask[i]) arr.push(this.arr[i])
+        return new Matrix(arr)
+    }
+    filterCols(fn){
+        const arr = this.T.filterRows(fn);
+        return new Matrix(arr).T
+    }
+    every(fn){
+        return this.arr.flat(1).every(fn)
+    }
+    everyRow(fn){
+        return this.arr.map(n => n.every(fn))
+    }
+    everyCol(fn){
+        return this.T.arr.map(n => n.every(fn))
+    }
+    some(fn){
+        return this.arr.flat(1).some(fn)
+    }
+    someRow(fn){
+        return this.arr.map(n => n.some(fn))
+    }
+    someCol(fn){
+        return this.T.arr.map(n => n.some(fn))
+    }
+    // Checkers
+    get isSquare() {
+        return this.rows === this.cols;
+    }
+    get isSym() {
+        if (!this.isSquare) return false;
+        for (let i = 0; i < this.rows; i++) {
+            for (let j = i + 1; j < this.cols; j++) {
+                if (this.arr[i][j] !== this.arr[j][i]) return false;
+            }
+        }
+        return true;
+    }
+    get isAntiSym() {
+        if (!this.isSquare) return false;
+        const n = this.rows;
+        for (let i = 0; i < n; i++) {
+            if (this.arr[i][i] !== 0) return false;
+            for (let j = i + 1; j < n; j++) {
+                if (this.arr[i][j] !== -this.arr[j][i]) return false;
+            }
+        }
+        return true;
+    }
+    get isDiag() {
+        if (!this.isSquare) return false;
+        const n = this.rows;
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                if (this.arr[i][j] !== 0 || this.arr[j][i] !== 0) return false;
+            }
+        }
+        return true;
+    }
+    get isOrtho() {
+        if (!this.isSquare) return false;
+        return this.isDiag && (this.det == 1 || this.det == -1);
+    }
+    get isIdemp() {
+        if (!this.isSquare) return false;
+        const n = this.rows;
+        const A = this.arr;
+        // Compute A * A
+        const MM = [];
+        for (let i = 0; i < n; i++) {
+            MM[i] = [];
+            for (let j = 0; j < n; j++) {
+                let sum = 0;
+                for (let k = 0; k < n; k++) {
+                    sum += A[i][k] * A[k][j];
+                }
+                MM[i][j] = sum;
+            }
+        }
+        // Check if A * A == A
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+                if (MM[i][j] !== A[i][j]) return false;
+            }
+        }
+        return true;
+    }
+
+    get isUpperTri() {
+        if (!this.isSquare) return false;
+        const n = this.rows;
+        for (let i = 1; i < n; i++) {
+            for (let j = 0; j < i; j++) {
+                if (this.arr[i][j] !== 0) return false;
+            }
+        }
+        return true;
+    }
+    get isLowerTri() {
+        if (!this.isSquare) return false;
+        const n = this.rows;
+        for (let i = 0; i < n - 1; i++) {
+            for (let j = i + 1; j < n; j++) {
+                if (this.arr[i][j] !== 0) return false;
+            }
+        }
+        return true;
+    }
+    toPrecision(p) {
+        for (let i = 0; i < this.cols; i++) 
+            for (let j = 0; j < this.rows; j++) 
+                this.arr[i][j] = +this.arr[i][j].toPrecision(p);
+        return this;
+    }
+    toFixed(p) {
+        for (let i = 0; i < this.cols; i++) 
+            for (let j = 0; j < this.rows; j++) 
+                this.arr[i][j] = +this.arr[i][j].toFixed(p);
+        return this;
+    }
+    // max2min() {
+    //     let newArr = this.arr.flat(1).max2min;
+    //     return new Matrix(this.rows, this.cols, newArr);
+    // }
+    // min2max() {
+    //     let newArr = this.arr.flat(1).min2max;
+    //     return new Matrix(this.rows, this.cols, newArr);
+    // }
+    // count(n) {
+    //     return this.arr.flat(1).count(n);
+    // }
+    splice(r0,c0,deleteCount,...items){
+        
+    }
+    getRows(ri, rf = ri + 1) {
+        return this.slice(ri, 0, rf, this.cols);
+    }
+    getCols(ci, cf = ci + 1) {
+        return this.slice(0, ci, this.rows, cf);
+    }
+    #arithmetic(fn, ...matr){
+        for (let k = 0; k < matr.length; k++) {
+            if (typeof matr[k] == "number" || matr[k]?.isComplex?.()) matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+            for (let i = 0; i < this.rows; i++) 
+                for (var j = 0; j < this.cols; j++) 
+                    this.arr[i][j] = fn(this.arr[i][j], matr[k].arr[i][j]);
+        }
+        return new Matrix(this.rows, this.cols, this.arr.flat(1));  
+    }
+    add(...matr) {
+        return this.#arithmetic(add, ...matr)
+    }
+    sub(...matr) {
+        return this.#arithmetic(sub, ...matr)
+    }
+    mul(...matr) {
+        return this.#arithmetic(mul, ...matr)
+    }
+    div(...matr) {
+        return this.#arithmetic(div, ...matr)
+    }
+    modulo(...matr) {
+        return this.#arithmetic(modulo, ...matr)
+    }
+    dot(matrix) {
+        var res = [];
+        for (var i = 0; i < this.arr.length; i++) {
+            res[i] = [];
+            for (var j = 0; j < matrix.arr[0].length; j++) {
+                res[i][j] = 0;
+                for (var k = 0; k < this.arr[0].length; k++) {
+                    res[i][j] = add(
+                        res[i][j],
+                        mul(this.arr[i][k],matrix.arr[k][j])
+                        )
+                }
+            }
+        }
+        return new Matrix(this.arr.length, matrix.arr[0].length, res.flat(1));
+    }
+    pow(n) {
+        let a = this.clone(),
+            p = this.clone();
+        for (let i = 0; i < n - 1; i++) p = p.dot(a);
+        return p;
+    }
+    sum(){
+        let S = 0;
+        for (let i = 0; i < this.rows; i++) 
+            for (let j = 0; j < this.cols; j++) 
+                S = add(S, this.arr[i][j]);
+        return S;
+    }
+    prod(){
+        let S = 1;
+        for (let i = 0; i < this.rows; i++) 
+            for (let j = 0; j < this.cols; j++) 
+                S = mul(S, this.arr[i][j]);
+        return S;
+    }
+    hasComplex(){
+        return this.arr.flat(Infinity).some((n) => n instanceof Complex);
+    }
+    get min() {
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
+        let minRow = [];
+        for (let i = 0; i < this.rows; i++) 
+            minRow.push(Math.min(...this.arr[i]));
+        return Math.min(...minRow);
+    }
+    get max() {
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
+        let maxRow = [];
+        for (let i = 0; i < this.rows; i++) 
+            maxRow.push(Math.max(...this.arr[i]));
+        return Math.max(...maxRow);
+    }
+    get minRows() {
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
+        let minRow = [];
+        for (let i = 0; i < this.rows; i++) 
+            minRow.push(Math.min(...this.arr[i]));
+        return minRow;
+    }
+    get maxRows() {
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
+        let maxRow = [];
+        for (let i = 0; i < this.rows; i++) 
+            maxRow.push(Math.max(...this.arr[i]));
+        return maxRow;
+    }
+    get minCols() {
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
+        return this.T.minRows;
+    }
+    get maxCols() {
+        if (this.hasComplex()) console.error("Complex numbers are not comparable");
+        return this.T.maxRows;
+    }
+    static fromVector(v) {
+        return new Matrix(v.length, 1, v);
+    }
+    serialize() {
+        const arr = mapfun(x => x.serialize?.() || x, ...this.arr)
+        return JSON.stringify({
+            type : 'matrix',
+            data : {
+                rows : this.rows,
+                cols : this.cols,
+                arr,
+            }
+        });
+    }
+    static deserialize(json) {
+        if (typeof json == "string") json = JSON.parse(json);
+        const {type, data} = json;
+        if(type !== 'matrix') return TypeError('Not a valid Matrix')
+        let {arr} = data;
+        arr = mapfun(x => {
+            if(typeof x === 'string') {
+                const x_obj = JSON.parse(x);
+                const {type} = x_obj
+                if(type === 'complex') return Complex.deserialize(x_obj)
+            }
+            return x
+        }, ...arr)
+        return new Matrix(arr)
+    }
+    flip(){
+        return this.flipeH().flipeV()
+    }
+    flipeH(){
+        this.arr = this.arr.map(row => [...row].reverse());
+        maintain_indexes(this);
+        return this;
+    }
+    flipeV(){
+        this.arr = this.arr.reverse();
+        maintain_indexes(this);
+        return this;
+    }
+}
+
+
+const matrix=(r, c, element)=>new Matrix(r, c, element);
+const matrix2=(...element)=>new Matrix(2, 2, element);
+const matrix3=(...element)=>new Matrix(3, 3, element);
+const matrix4=(...element)=>new Matrix(4, 4, element);
+export{
+    Matrix,
+    matrix,
+    matrix2,
+    matrix3,
+    matrix4
+}

package/src/random/index.js

@@ -1,4 +1,4 @@
-// import { base2base } from "../../../dep/--from-ziko/functions/conversions/index.js";
+import { base2base } from "../discret/bitwise/conversions/index.js";
 import { accum_sum } from "../stats";
 
 export class Random {