numz 0.8.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.8.0",
+  "version": "0.10.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

@@ -3,6 +3,8 @@ 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/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 {

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

@@ -1,5 +1,6 @@
-import { mapfun, nthr, pow } from "ziko/math/functions";
-import { Matrix } from 'ziko/math/matrix'
+import { mapfun } from "ziko/math/mapfun";
+import { nthr, pow } from '../../../ufunc/index.js'
+import { Matrix } from '../../../matrix/index.js'
 
 export const zeros = (n, m, d) => {
     if(m) return Matrix.zeros(n, m);

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

@@ -5,7 +5,7 @@ import {
     lerp,
     clamp,
     norm,
-} from 'ziko/math/functions'
+} from 'ziko/math/utils'
 export class AbstractFloatMatrix extends AbstractIntMatrix{
     constructor(rows, cols, data, type){
         super(rows, cols, data, type)

package/src/ufunc/index.d.ts

@@ -0,0 +1,96 @@
+import { mapfun, MapFunResult } from 'ziko/math/mapfun'
+import { complex } from '../complex/index'
+
+// --- Standard Unary / Multi-Argument Math Functions ---
+
+export function abs<T>(x: T): MapFunResult<T, any>;
+export function abs<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sqrt<T>(x: T): MapFunResult<T, any>;
+export function sqrt<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function cbrt<T>(x: T): MapFunResult<T, any>;
+export function cbrt<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function exp<T>(x: T): MapFunResult<T, any>;
+export function exp<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function ln<T>(x: T): MapFunResult<T, any>;
+export function ln<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sign<T>(x: T): MapFunResult<T, any>;
+export function sign<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function floor<T>(x: T): MapFunResult<T, any>;
+export function floor<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function ceil<T>(x: T): MapFunResult<T, any>;
+export function ceil<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function round<T>(x: T): MapFunResult<T, any>;
+export function round<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function trunc<T>(x: T): MapFunResult<T, any>;
+export function trunc<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function fract<T>(x: T): MapFunResult<T, any>;
+export function fract<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function cos<T>(x: T): MapFunResult<T, any>;
+export function cos<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sin<T>(x: T): MapFunResult<T, any>;
+export function sin<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function tan<T>(x: T): MapFunResult<T, any>;
+export function tan<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sec<T>(x: T): MapFunResult<T, any>;
+export function sec<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function acos<T>(x: T): MapFunResult<T, any>;
+export function acos<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function asin<T>(x: T): MapFunResult<T, any>;
+export function asin<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function atan<T>(x: T): MapFunResult<T, any>;
+export function atan<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function acot<T>(x: T): MapFunResult<T, any>;
+export function acot<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function cosh<T>(x: T): MapFunResult<T, any>;
+export function cosh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sinh<T>(x: T): MapFunResult<T, any>;
+export function sinh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function tanh<T>(x: T): MapFunResult<T, any>;
+export function tanh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function coth<T>(x: T): MapFunResult<T, any>;
+export function coth<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function acosh<T>(x: T): MapFunResult<T, any>;
+export function acosh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function asinh<T>(x: T): MapFunResult<T, any>;
+export function asinh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function atanh<T>(x: T): MapFunResult<T, any>;
+export function atanh<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function sig<T>(x: T): MapFunResult<T, any>;
+export function sig<T extends any[]>(...x: T): { [K in keyof T]: MapFunResult<T[K], any> };
+
+// --- Functions that pop parameters from the end (pow, nthr, croot) ---
+
+export function pow<T, N>(base: T, n: N): MapFunResult<T, any>;
+export function pow<T extends any[], N>(...args: [...T, N]): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function nthr<T, N extends number>(base: T, n: N): MapFunResult<T, any>;
+export function nthr<T extends any[], N extends number>(...args: [...T, N]): { [K in keyof T]: MapFunResult<T[K], any> };
+
+export function croot<T, C>(base: T, root: C): MapFunResult<T, any>;
+export function croot<T extends any[], C>(...args: [...T, C]): { [K in keyof T]: MapFunResult<T[K], any> };

package/src/ufunc/index.js

@@ -1 +1,372 @@
-export * from 'ziko/math/functions'
+import { mapfun } from 'ziko/math/mapfun';
+import { complex } from '../complex/index.js'
+
+const PRECESION = 8
+
+export const abs = (...x) => mapfun(
+    x =>{
+        if(x.isComplex?.()) return x.z;
+        return Math.abs(x)
+    },
+    ...x
+)
+
+export const pow = (...x) => {
+    const n = x.pop();
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) {
+                if(n.isComplex?.()) return new x.constructor({
+                    z: Math.exp(n.a * Math.log(x.z) - n.b * x.phi),
+                    phi: n.b * Math.log(x.z) + n.a * x.phi
+                })
+                return new x.constructor({z: x.z ** n, phi: x.phi * n});
+            }
+            if(n.isComplex?.()) return new x.constructor({
+                    z: Math.exp(n.a * Math.log(x)),
+                    phi: n.b * Math.log(x)
+            })
+            return Math.pow(x, n)
+        },
+        ...x
+    )
+}
+
+export const sqrt = (...x) => mapfun(
+    x=>{
+        if(x.isComplex?.()) 
+            return new x.constructor({z: x.z**(1/2), phi: x.phi/2});
+        if(x < 0) return complex(0, Math.sqrt(-x)).toFixed(PRECESION)
+        return + Math.sqrt(x).toFixed(PRECESION);
+    },
+    ...x
+);
+
+export const cbrt = (...x) => mapfun(
+    x=>{
+        if(x.isComplex?.()) 
+            return new x.constructor({z: x.z**(1/3), phi: x.phi/3}).toFixed(PRECESION)
+        return + Math.cbrt(x).toFixed(PRECESION);
+    },
+    ...x
+);
+
+export const nthr = (...x) => {
+    const n = x.pop();
+    if(typeof n !== 'number') throw Error('nthr expects a real number n');
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) return new x.constructor({z: x.z ** (1/n), phi: x.phi / n});
+            if(x<0) return n %2 ===2 
+                ? complex(0, (-x)**(1/n)).toFixed(PRECESION)
+                : + (-1 * (-x)**(1/n)).toFixed(PRECESION)                
+            return + (x**(1/n)).toFixed(PRECESION)
+        },
+        ...x
+    )
+}
+
+export const croot = (...x) =>{
+    const c = x.pop()
+    if(!c.isComplex?.()) throw Error('croot expect Complex number as root')
+    return mapfun(
+        x => {
+            if(typeof x === 'number') x = new c.constructor(x, 0);
+            const {a : c_a, b : c_b} = c;
+            const {z, phi} = x;
+            const D = Math.hypot(c_a, c_b);
+            const A = Math.exp((Math.log(z)*c_a + phi*c_b)/D);
+            const B = (phi*c_a - Math.log(z)*c_b)/D
+            return new c.constructor(
+                A * Math.cos(B),
+                A * Math.sin(B)
+            ).toFixed(PRECESION)
+        },
+        ...x
+    )
+}
+
+export const exp = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.exp(x.a) * Math.cos(x.b),
+            Math.exp(x.a) * Math.sin(x.b)
+        ).toFixed(PRECESION);
+        return + Math.exp(x).toFixed(PRECESION)
+    }
+    ,...x
+);
+
+export const ln = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.log(x.z),
+            x.phi
+        ).toFixed(PRECESION);
+        return + Math.log(x).toFixed(PRECESION)
+    }
+    ,...x
+);
+
+export const sign = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()){
+            const {z, phi} = x;
+            if(z===0) return new x.constructor(0, 0);
+            return new x.constructor({z:1, phi})
+        }
+        return Math.sign(x)
+    }
+    ,...x
+);
+
+export const floor = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.floor(x.a),
+            Math.floor(x.b)
+        )
+        return Math.floor(x)
+    },
+    ...x
+)
+export const ceil = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.ceil(x.a),
+            Math.ceil(x.b)
+        )
+        return Math.ceil(x)
+    },
+    ...x
+)
+export const round = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.round(x.a),
+            Math.round(x.b)
+        )
+        return Math.round(x)
+    },
+    ...x
+)
+
+export const trunc = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.trunc(x.a),
+            Math.trunc(x.b)
+        )
+        return Math.trunc(x)
+    },
+    ...x
+)
+
+export const fract = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            x.a - Math.trunc(x.a),
+            x.b - Math.trunc(x.b)
+        )
+        return x - Math.trunc(x)
+    },
+    ...x
+)
+
+export const cos = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.cos(x.a) * Math.cosh(x.b),
+            -Math.sin(x.a) * Math.sinh(x.b)
+        ).toFixed(PRECESION);
+        return + Math.cos(x).toFixed(PRECESION)
+    }
+    ,...x
+);
+
+export const sin = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            Math.sin(x.a) * Math.cosh(x.b),
+            Math.cos(x.a) * Math.sinh(x.b)
+        ).toFixed(PRECESION);
+        return + Math.sin(x).toFixed(PRECESION)
+    }
+    , ...x
+);
+
+export const tan = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const D = Math.cos(2*x.a) + Math.cosh(2*x.b);
+            return new x.constructor(
+                Math.sin(2*x.a) / D,
+                Math.sinh(2*x.b) / D
+            ).toFixed(PRECESION);
+        } 
+        return + Math.tan(x).toFixed(PRECESION)
+    },
+    ...x
+);
+
+export const sec = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) {
+
+        }
+        return + (1 / Math.cos(x)).toFixed(PRECESION)
+    }
+    ,...x
+);
+
+export const acos = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const { a, b } = x;
+            const Rp = Math.hypot(a + 1, b);
+            const Rm = Math.hypot(a - 1, b);
+            globalThis.Rp = Rp
+            globalThis.Rm = Rm
+            return new x.constructor(
+                Math.acos((Rp - Rm) / 2),
+                -Math.acosh((Rp + Rm) / 2),
+            ).toFixed(PRECESION)
+        } 
+        return + Math.acos(x).toFixed(PRECESION) 
+    },
+    ...x
+);
+
+export const asin = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            const Rp = Math.hypot(a + 1, b);
+            const Rm = Math.hypot(a - 1, b);
+            return new x.constructor(
+                Math.asin((Rp - Rm) / 2), 
+                Math.acosh((Rp + Rm) / 2)
+            ).toFixed(PRECESION);
+        }
+        return + Math.asin(x).toFixed(PRECESION);
+    },
+    ...x
+);
+
+export const atan = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            return new x.constructor(
+                Math.atan((a*2/(1-a**2-b**2)))/2,
+                Math.log((a**2 + (1+b)**2)/(a**2 + (1-b)**2))/4
+            ).toFixed(PRECESION)
+        }
+        return + Math.atan(x).toFixed(PRECESION);
+    },
+    ...x
+);
+
+export const acot = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            return new x.constructor(
+                Math.atan(2*a/(a**2+(b-1)*(b+1)))/2,
+                Math.log((a**2 + (b-1)**2)/(a**2 + (b+1)**2))/4   
+            ).toFixed(PRECESION)
+        }
+        return + (Math.PI/2 - Math.atan(x)).toFixed(PRECESION);
+    },
+    ...x
+);
+
+
+export const cosh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            Math.cosh(x.a) * Math.cos(x.b),
+            Math.sinh(x.a) * Math.sin(x.b)
+        ).toFixed(PRECESION); 
+        return + Math.cosh(x).toFixed(PRECESION)
+    },
+    ...x
+)
+export const sinh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            Math.sinh(x.a) * Math.cos(x.b),
+            Math.cosh(x.a) * Math.sin(x.b)
+        ).toFixed(PRECESION); 
+        return + Math.sinh(x).toFixed(PRECESION)
+    },
+    ...x
+)
+export const tanh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const D = Math.cosh(2*a) + Math.cos(2*b);
+            return new x.constructor(
+                Math.sinh(2*a) / D,
+                Math.sin(2*b) / D
+            ).toFixed(PRECESION)
+        } 
+        return + Math.tanh(x).toFixed(PRECESION)
+    },
+    ...x
+)
+
+export const coth = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const {a, b} = x
+            const D = (Math.sinh(a)**2)*(Math.cos(b)**2) + (Math.cosh(a)**2)*(Math.sin(b)**2) 
+            return new x.constructor(
+                Math.cosh(a) * Math.sinh(a) / D,
+                - Math.sin(b) * Math.cos(b) / D
+            ).toFixed(PRECESION)
+        } 
+        return + (1 / Math.tanh(x)).toFixed(PRECESION)
+    },
+    ...x
+)
+
+export const acosh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).sub(1))))
+        } 
+        return + Math.acosh(x).toFixed(PRECESION)
+    },
+    ...x
+)
+
+export const asinh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).add(1))))
+        } 
+        return + Math.asinh(x).toFixed(PRECESION)
+    },
+    ...x
+)
+
+export const atanh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+
+        } 
+        return + Math.atanh(x).toFixed(PRECESION)
+    },
+    ...x
+)
+
+export const sig = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+
+        } 
+        return + 1/(1 + Math.exp(-x)).toFixed(PRECESION)
+    },
+    ...x
+)