numz 0.8.0 → 0.9.0

package/package.json

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

@@ -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 {