numz 0.4.0 → 0.6.0

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.4.0",
+  "version": "0.6.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.63.0"
   },
   "dependencies": {
-    "ziko": "^0.57.0"
+    "ziko": "^1.10.0"
   }
 }

package/src/complex/helpers/constructor.js

@@ -0,0 +1,38 @@
+export const complex_constructor = (Complex, a, b) => {
+    let _a, _b;
+  if (a instanceof Complex) {
+    _a = a.a;
+    _b = a.b;
+  } 
+  else if (typeof a === "object") {
+    if ("a" in a && "b" in a) {
+      _a = a.a;
+      _b = a.b;
+    } 
+    else if ("a" in a && "z" in a) {
+      _a = a.a;
+      _b = Math.sqrt(a.z ** 2 - a.a ** 2);
+    } 
+    else if ("a" in a && "phi" in a) {
+      _a = a.a;
+      _b = a.a * Math.tan(a.phi);
+    } 
+    else if ("b" in a && "z" in a) {
+      _b = a.b;
+      _a = Math.sqrt(a.z ** 2 - a.b ** 2);
+    } 
+    else if ("b" in a && "phi" in a) {
+      _b = b;
+      _a = a.b / Math.tan(a.phi);
+    } 
+    else if ("z" in a && "phi" in a) {
+      _a = +a.z * Math.cos(a.phi).toFixed(15);
+      _b = +a.z * Math.sin(a.phi).toFixed(15);
+    }
+  } 
+  else if (typeof a === "number" && typeof b === "number") {
+    _a = +a.toFixed(32);
+    _b = +b.toFixed(32);
+  }
+  return [_a, _b]
+};

package/src/complex/helpers/index.js

@@ -0,0 +1 @@
+export * from './constructor.js'

package/src/complex/index.d.ts

@@ -0,0 +1,231 @@
+import type { Matrix } from "../matrix/index.js";
+
+/**
+ * Represents a complex number.
+ *
+ * A complex number is represented as:
+ * a + bi
+ */
+export declare class Complex {
+    a: number;
+    b: number;
+
+    constructor(a?: number, b?: number);
+    constructor(c: Complex);
+    constructor(value:
+        | { a: number; b: number }
+        | { a: number; z: number }
+        | { a: number; phi: number }
+        | { b: number; z: number }
+        | { b: number; phi: number }
+        | { z: number; phi: number }
+    );
+
+    /**
+     * Used by mapfun to identify complex values.
+     */
+    readonly __mapfun__: boolean;
+
+    /**
+     * Checks whether this value is a Complex instance.
+     */
+    isComplex(): true;
+
+    /**
+     * Converts the complex number to a string.
+     */
+    toString(): string;
+
+    /**
+     * Serializes the complex number.
+     */
+    serialize(): string;
+
+    /**
+     * Deserializes a serialized complex number.
+     */
+    static deserialize(json: string | object): Complex | TypeError;
+
+    /**
+     * Rounds real and imaginary parts.
+     *
+     * @param n Number of decimal digits.
+     */
+    toFixed(n: number): this;
+
+    /**
+     * Formats real and imaginary parts with precision.
+     *
+     * @param n Number of significant digits.
+     */
+    toPrecision(n: number): this;
+
+    /**
+     * Creates a copy of this complex number.
+     */
+    clone(): Complex;
+
+    /**
+     * Magnitude of the complex number.
+     */
+    readonly z: number;
+
+    /**
+     * Phase angle in radians.
+     */
+    readonly phi: number;
+
+    /**
+     * Complex conjugate.
+     */
+    readonly conj: Complex;
+
+    /**
+     * Multiplicative inverse.
+     */
+    readonly inv: Complex;
+
+    /**
+     * Exponential representation [magnitude, phase].
+     */
+    readonly expo: [number, number];
+
+    /**
+     * Adds complex numbers.
+     */
+    add(...c: (number | Complex)[]): this;
+
+    /**
+     * Subtracts complex numbers.
+     */
+    sub(...c: (number | Complex)[]): this;
+
+    /**
+     * Multiplies complex numbers.
+     */
+    mul(...c: (number | Complex)[]): this;
+
+    /**
+     * Divides complex numbers.
+     */
+    div(...c: (number | Complex)[]): this;
+
+    /**
+     * Computes modulo.
+     */
+    modulo(...c: (number | Complex)[]): this;
+
+    /**
+     * Raises the complex number to a power.
+     */
+    pow(...c: (number | Complex)[]): this;
+
+    /**
+     * Calculates the nth root.
+     */
+    nthr(n?: number): Complex;
+
+    /**
+     * Square root.
+     */
+    readonly sqrt: Complex;
+
+    /**
+     * Cube root.
+     */
+    readonly cbrt: Complex;
+
+    /**
+     * Complex logarithm.
+     */
+    readonly log: Complex;
+
+    /**
+     * Complex cosine.
+     */
+    readonly cos: Complex;
+
+    /**
+     * Complex sine.
+     */
+    readonly sin: Complex;
+
+    /**
+     * Complex tangent.
+     */
+    readonly tan: Complex;
+
+    /**
+     * Returns zero complex.
+     */
+    static zero(): Complex;
+
+    /**
+     * Creates a complex number from polar coordinates.
+     *
+     * @param z Magnitude.
+     * @param phi Angle in radians.
+     */
+    static fromPolar(
+        z: number,
+        phi: number
+    ): Complex;
+
+    /**
+     * Creates FFT twiddle factor.
+     */
+    static twiddle(
+        K: number,
+        N: number
+    ): Complex;
+
+    /**
+     * Generates random complex numbers.
+     */
+    static readonly random: {
+        int(
+            a?: number,
+            b?: number
+        ): Complex;
+
+        float(
+            a?: number,
+            b?: number
+        ): Complex;
+    };
+}
+
+
+/**
+ * Creates a complex number.
+ */
+export declare function complex(
+    a?: number,
+    b?: number
+): Complex;
+
+export declare function complex(
+    a: Complex
+): Complex;
+
+export declare function complex(
+    a: object
+): Complex;
+
+
+/**
+ * Creates arrays of complex numbers from two arrays.
+ */
+export declare function complex(
+    a: number[] | ArrayLike<number>,
+    b: number[] | ArrayLike<number>
+): Complex[];
+
+
+/**
+ * Creates a complex matrix by combining two matrices.
+ */
+export declare function complex(
+    a: Matrix,
+    b: Matrix
+): Matrix;

package/src/complex/index.js

@@ -0,0 +1,193 @@
+import { Random } from "../random/index.js";
+import { complex_constructor } from "./helpers/index.js";
+class Complex{
+    constructor(a = 0, b = 0) {
+        [
+            this.a,
+            this.b
+        ] = complex_constructor(Complex, a, b)
+    }
+    get __mapfun__(){
+        return true
+    }
+    isComplex(){
+        return true
+    }
+    toString(){
+        let str = "";
+        if (this.a !== 0)
+          this.b >= 0
+            ? (str = `${this.a}+${this.b}*i`)
+            : (str = `${this.a}-${Math.abs(this.b)}*i`);
+        else
+          this.b >= 0
+            ? (str = `${this.b}*i`)
+            : (str = `-${Math.abs(this.b)}*i`);
+        return str;
+    }
+    serialize() {
+        return JSON.stringify({
+            type : 'complex',
+            data : this
+        });
+    }
+    static deserialize(json){
+        if(typeof json === 'string') json = JSON.parse(json);
+        let {data, type} = json;
+        return (type === 'complex' && ('a' in data) && ('b' in data))
+            ? new Complex(data.a, data.b)
+            : TypeError('Not a valid complex')
+    } 
+    toFixed(n){
+        this.a = + this.a.toFixed(n);
+        this.b = + this.b.toFixed(n);
+        return this; 
+    }  
+    toPrecision(n){
+        this.a = + this.a.toPrecision(n);
+        this.b = + this.b.toPrecision(n);
+        return this; 
+    }  
+    clone() {
+        return new Complex(this.a, this.b);
+    }
+    get z(){
+        return Math.hypot(this.a,this.b);    
+    }
+    get phi(){
+        return Math.atan2(this.b , this.a);        
+    }
+    static zero() {
+        return new Complex(0, 0);
+    }
+    static fromPolar(z, phi) {
+        return new Complex(
+            +(z * cos(phi)).toFixed(13), 
+            +(z * sin(phi)).toFixed(13)
+        );
+    }
+    
+    static get random(){
+        return {
+            int : (a, b)=> new Complex(...Random.sample.int(2, a, b) ),
+            float : (a, b)=> new Complex(...Random.sample.float(2, a, b) ),
+        }
+    }
+    static twiddle(K, N){
+        const phi = -2 * Math.PI * K / N;
+        return new Complex(
+            Math.cos(phi), 
+            Math.sin(phi)
+        );
+    }
+    get conj() {
+        return new Complex(this.a, -this.b);
+    }
+    get inv() {
+        return new Complex(
+            this.a / Math.hypot(this.a, this.b),
+            -this.b / Math.hypot(this.a, this.b)
+        );
+    }
+    add(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a += c[i].a;
+            this.b += c[i].b;
+        }
+        return this;
+    }
+    sub(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a -= c[i].a;
+            this.b -= c[i].b;
+        }
+        return this;
+    }
+    mul(...c){
+        let {z, phi} = this;
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            z *= c[i].z;
+            phi += c[i].phi;
+        }
+        this.a = z * Math.cos(phi)
+        this.b = z * Math.sin(phi)  
+        return this.toFixed(8);
+    }
+    div(...c){
+        let {z, phi} = this;
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            z /= c[i].z;
+            phi -= c[i].phi;
+        }
+        this.a = z * Math.cos(phi)
+        this.b = z * Math.sin(phi)  
+        return this.toFixed(8);;
+    }
+    modulo(...c) {
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            this.a %= c[i].a;
+            this.b %= c[i].b;
+        }
+        return this;
+    }
+    pow(...c){
+        let {z, phi} = this;
+        for (let i = 0; i < c.length; i++) {
+            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
+            z *= Math.exp(c[i].a * Math.log(z) - c[i].b * phi);
+            phi += c[i].b * Math.log(z) + c[i].a * phi;
+        }
+        this.a = z * Math.cos(phi)
+        this.b = z * Math.sin(phi)  
+        return this;
+    }
+    get expo() {
+        return [this.z, this.phi];
+    }
+    nthr(n=2){
+        return complex({z: this.z ** (1/n), phi: this.phi / n});
+    }
+    get sqrt(){
+        return this.nthr(2);
+    }
+    get cbrt(){
+        return this.nthr(3);
+    }
+    get log(){
+        return complex(this.z, this.phi);
+    }
+    get cos(){
+        return complex(
+            Math.cos(this.a) * Math.cosh(this.b),
+            Math.sin(this.a) * Math.sinh(this.b)
+        )
+    }
+    get sin(){
+        return complex(
+            Math.sin(this.a) * Math.cosh(this.b),
+            Math.cos(this.a) * Math.sinh(this.b)
+        )
+    }
+    get tan(){
+        const D=cos(this.a*2)+cosh(this.b*2);
+        return complex(
+            Math.sin(2 * this.a) / D,
+            Math.sinh(2 * this.b) / D
+        );
+    }
+}
+const complex=(a,b)=>{
+    if((a instanceof Array||ArrayBuffer.isView(a)) && (b instanceof Array||ArrayBuffer.isView(a)))return a.map((n,i)=>complex(a[i],b[i]));
+    if(a.isMatrix?.() && b.isMatrix?.()){
+        if((a.shape[0]!==b.shape[0])||(a.shape[1]!==b.shape[1]))return Error(0)
+        const arr=a.arr.map((n,i)=>complex(a.arr[i],b.arr[i]))
+        return new a.constructor(a.rows,a.cols,...arr)
+    }
+    return new Complex(a,b)
+}
+export{complex,Complex}

package/src/index.js

@@ -2,5 +2,5 @@ export * from './ufunc/index.js'
 export * from './calculus/index.js'
 export * from './signal/index.js'
 export * from './stats/index.js'
-
+export * from './complex/index.js'