@cloudglides/nox 1.1.5 → 2.0.0

package/src/rng.js

@@ -28,17 +28,16 @@ export class RNG {
   }
 
   int(min, max) {
-     if (typeof min !== 'number' || typeof max !== 'number') {
-       throw new TypeError('int() requires two number arguments');
-     }
-     if (!Number.isInteger(min) || !Number.isInteger(max)) {
-       throw new TypeError('int() arguments must be integers');
-     }
-     if (min > max) [min, max] = [max, min];
-     const range = max - min + 1;
-     let val = Math.floor(this.nextFloat() * range);
-     return val + min;
-   }
+    if (typeof min !== 'number' || typeof max !== 'number') {
+      throw new TypeError('int() requires two number arguments');
+    }
+    if (!Number.isInteger(min) || !Number.isInteger(max)) {
+      throw new TypeError('int() arguments must be integers');
+    }
+    if (min > max) [min, max] = [max, min];
+    const range = max - min + 1;
+    return min + this.nextInt(range);
+  }
 
   bool(probability = 0.5) {
     if (typeof probability !== 'number') {
@@ -55,13 +54,13 @@ export class RNG {
       throw new TypeError('min, max, and step must be numbers');
     }
     if (!Number.isInteger(min) || !Number.isInteger(max) || !Number.isInteger(step)) {
-      throw new Error('min, max, and step must be integers');
+      throw new TypeError('min, max, and step must be integers');
     }
     if (step <= 0) {
-      throw new Error('step must be positive');
+      throw new RangeError('step must be positive');
     }
     if (min > max) {
-      throw new Error('min must be less than or equal to max');
+      throw new RangeError('min must be less than or equal to max');
     }
 
     const count = Math.floor((max - min) / step) + 1;
@@ -70,79 +69,93 @@ export class RNG {
   }
 
   choice(arr) {
-     if (!Array.isArray(arr)) {
-       throw new TypeError('choice() requires array');
-     }
-     const len = arr.length;
-     if (len === 0) {
-       throw new TypeError('choice() requires non-empty array');
-     }
-     return arr[this.nextInt(len)];
-   }
+    if (!Array.isArray(arr)) {
+      throw new TypeError('choice() requires array');
+    }
+    const len = arr.length;
+    if (len === 0) {
+      throw new RangeError('choice() requires non-empty array');
+    }
+    return arr[this.nextInt(len)];
+  }
 
   batch(count, fn) {
-     if (typeof count !== 'number' || !Number.isInteger(count)) {
-       throw new TypeError('count must be an integer');
-     }
-     if (count <= 0) {
-       return [];
-     }
-     if (typeof fn !== 'function') {
-       throw new TypeError('fn must be a function');
-     }
-
-     const result = new Array(count);
-     for (let i = 0; i < count; i++) {
-       result[i] = fn(this, i);
-     }
-     return result;
-   }
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+    if (count === 0) {
+      return [];
+    }
+    if (typeof fn !== 'function') {
+      throw new TypeError('fn must be a function');
+    }
+
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = fn(this, i);
+    }
+    return result;
+  }
 
   floats(count) {
-     if (typeof count !== 'number' || !Number.isInteger(count)) {
-       throw new TypeError('count must be an integer');
-     }
-     if (count <= 0) {
-       return [];
-     }
-
-     const result = new Array(count);
-     for (let i = 0; i < count; i++) {
-       result[i] = this.nextFloat();
-     }
-     return result;
-   }
-
-   ints(count, max = 2147483647) {
-     if (typeof count !== 'number' || !Number.isInteger(count)) {
-       throw new TypeError('count must be an integer');
-     }
-     if (count <= 0) {
-       return [];
-     }
-
-     const result = new Array(count);
-     for (let i = 0; i < count; i++) {
-       result[i] = this.nextInt(max);
-     }
-     return result;
-   }
-
-   bools(count, probability = 0.5) {
-     if (typeof count !== 'number' || !Number.isInteger(count)) {
-       throw new TypeError('count must be an integer');
-     }
-     if (count <= 0) {
-       return [];
-     }
-
-     const result = new Array(count);
-     for (let i = 0; i < count; i++) {
-       result[i] = this.bool(probability);
-     }
-     return result;
-   }
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+    if (count === 0) {
+      return [];
+    }
+
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = this.nextFloat();
+    }
+    return result;
+  }
+
+  ints(count, max = 2147483647) {
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+    if (count === 0) {
+      return [];
+    }
+
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = this.nextInt(max);
+    }
+    return result;
+  }
+
+  bools(count, probability = 0.5) {
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+    if (count === 0) {
+      return [];
+    }
+
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = this.bool(probability);
+    }
+    return result;
+  }
 }
 
 export const rng = () => new RNG();
 
+
+

package/src/utils/arrays.js

@@ -0,0 +1,149 @@
+export function sum(arr) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('arr must be array');
+  }
+  let total = 0;
+  for (let i = 0; i < arr.length; i++) {
+    total += arr[i];
+  }
+  return total;
+}
+
+export function mean(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    throw new TypeError('arr must be non-empty array');
+  }
+  return sum(arr) / arr.length;
+}
+
+export function min(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    throw new TypeError('arr must be non-empty array');
+  }
+  let minVal = arr[0];
+  for (let i = 1; i < arr.length; i++) {
+    if (arr[i] < minVal) minVal = arr[i];
+  }
+  return minVal;
+}
+
+export function max(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    throw new TypeError('arr must be non-empty array');
+  }
+  let maxVal = arr[0];
+  for (let i = 1; i < arr.length; i++) {
+    if (arr[i] > maxVal) maxVal = arr[i];
+  }
+  return maxVal;
+}
+
+export function unique(arr) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('arr must be array');
+  }
+  const seen = new Set();
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (!seen.has(arr[i])) {
+      seen.add(arr[i]);
+      result.push(arr[i]);
+    }
+  }
+  return result;
+}
+
+export function chunk(arr, size) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('arr must be array');
+  }
+  if (typeof size !== 'number' || size < 1) {
+    throw new RangeError('size must be positive integer');
+  }
+
+  const result = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+}
+
+export function flatten(arr, depth = Infinity) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('arr must be array');
+  }
+  if (typeof depth !== 'number' || depth < 0) {
+    throw new RangeError('depth must be non-negative number');
+  }
+
+  if (depth === 0) return arr;
+
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (Array.isArray(arr[i]) && depth > 0) {
+      result.push(...flatten(arr[i], depth - 1));
+    } else {
+      result.push(arr[i]);
+    }
+  }
+  return result;
+}
+
+export function zip(...arrays) {
+  if (arrays.length === 0) {
+    throw new TypeError('at least one array required');
+  }
+
+  for (let i = 0; i < arrays.length; i++) {
+    if (!Array.isArray(arrays[i])) {
+      throw new TypeError(`argument ${i} must be array`);
+    }
+  }
+
+  const minLen = Math.min(...arrays.map(a => a.length));
+  const result = new Array(minLen);
+
+  for (let i = 0; i < minLen; i++) {
+    result[i] = arrays.map(a => a[i]);
+  }
+  return result;
+}
+
+export function transpose(matrix) {
+  if (!Array.isArray(matrix) || matrix.length === 0) {
+    throw new TypeError('matrix must be non-empty 2D array');
+  }
+
+  const cols = matrix[0].length;
+  const result = new Array(cols);
+
+  for (let j = 0; j < cols; j++) {
+    result[j] = new Array(matrix.length);
+    for (let i = 0; i < matrix.length; i++) {
+      result[j][i] = matrix[i][j];
+    }
+  }
+  return result;
+}
+
+export function partition(arr, predicate) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('arr must be array');
+  }
+  if (typeof predicate !== 'function') {
+    throw new TypeError('predicate must be function');
+  }
+
+  const truthy = [];
+  const falsy = [];
+
+  for (let i = 0; i < arr.length; i++) {
+    if (predicate(arr[i], i)) {
+      truthy.push(arr[i]);
+    } else {
+      falsy.push(arr[i]);
+    }
+  }
+
+  return [truthy, falsy];
+}

package/src/utils/bits.js

@@ -1,25 +1,150 @@
 export const rotateBits = (val, shift) => {
-  const mask = BigInt(64);
-  shift = BigInt(shift) % mask;
-  return (val << shift) | (val >> (mask - shift));
-};
+   if (typeof val !== 'bigint') {
+     throw new TypeError('val must be bigint');
+   }
+   if (typeof shift !== 'number' && typeof shift !== 'bigint') {
+     throw new TypeError('shift must be number or bigint');
+   }
+   const mask = BigInt(64);
+   shift = BigInt(shift) % mask;
+   return (val << shift) | (val >> (mask - shift));
+ };
+ 
+ export const extractBits = (val, start, length) => {
+   if (typeof val !== 'bigint') {
+     throw new TypeError('val must be bigint');
+   }
+   if (typeof start !== 'number' || !Number.isInteger(start)) {
+     throw new TypeError('start must be an integer');
+   }
+   if (start < 0) {
+     throw new RangeError('start must be non-negative');
+   }
+   if (typeof length !== 'number' || !Number.isInteger(length)) {
+     throw new TypeError('length must be an integer');
+   }
+   if (length <= 0) {
+     throw new RangeError('length must be positive');
+   }
+   const mask = (BigInt(1) << BigInt(length)) - BigInt(1);
+   return (val >> BigInt(start)) & mask;
+ };
+ 
+ export const hammingWeight = (val) => {
+   if (typeof val !== 'bigint') {
+     throw new TypeError('val must be bigint');
+   }
+   let count = 0;
+   let v = val < 0n ? -val : val;
+   while (v > 0n) {
+     v = v & (v - 1n);
+     count++;
+   }
+   return count;
+ };
+ 
+ export const bitRange = (val, min, max) => {
+   if (typeof val !== 'bigint') {
+     throw new TypeError('val must be bigint');
+   }
+   if (typeof min !== 'number' || !Number.isInteger(min)) {
+     throw new TypeError('min must be an integer');
+   }
+   if (min < 0) {
+     throw new RangeError('min must be non-negative');
+   }
+   if (typeof max !== 'number' || !Number.isInteger(max)) {
+     throw new TypeError('max must be an integer');
+   }
+   if (max <= min) {
+     throw new RangeError('max must be greater than min');
+   }
+   const shift = BigInt(min);
+   const mask = (BigInt(1) << BigInt(max - min)) - BigInt(1);
+   return (val >> shift) & mask;
+ };
 
-export const extractBits = (val, start, length) => {
-  const mask = (BigInt(1) << BigInt(length)) - BigInt(1);
-  return (val >> BigInt(start)) & mask;
-};
+ export const popcountNum = (val) => {
+ if (typeof val !== 'number' || !Number.isInteger(val) || val < 0) {
+   throw new TypeError('val must be a non-negative integer');
+ }
+ let count = 0;
+ let v = val >>> 0;
+ while (v) {
+   count += v & 1;
+   v >>>= 1;
+ }
+ return count;
+ };
 
-export const hammingWeight = (val) => {
-  let count = 0;
-  while (val > 0n) {
-    count += val & 1n ? 1 : 0;
-    val >>= 1n;
-  }
-  return count;
-};
+ export const clz = (val) => {
+ if (typeof val !== 'bigint') {
+   throw new TypeError('val must be bigint');
+ }
+ if (val === 0n) return 64;
+ let count = 0;
+ let mask = 1n << 63n;
+ while ((val & mask) === 0n) {
+   count++;
+   mask >>= 1n;
+ }
+ return count;
+ };
 
-export const bitRange = (val, min, max) => {
-  const shift = BigInt(min);
-  const mask = (BigInt(1) << BigInt(max - min)) - BigInt(1);
-  return (val >> shift) & mask;
-};
+ export const ctz = (val) => {
+ if (typeof val !== 'bigint') {
+   throw new TypeError('val must be bigint');
+ }
+ if (val === 0n) return 64;
+ let count = 0;
+ let mask = 1n;
+ while ((val & mask) === 0n) {
+   count++;
+   mask <<= 1n;
+ }
+ return count;
+ };
+
+ export const reverseBits = (val, width = 64) => {
+ if (typeof val !== 'bigint') {
+   throw new TypeError('val must be bigint');
+ }
+ if (typeof width !== 'number' || !Number.isInteger(width) || width <= 0) {
+   throw new TypeError('width must be a positive integer');
+ }
+ let result = 0n;
+ for (let i = 0; i < width; i++) {
+   result = (result << 1n) | ((val >> BigInt(i)) & 1n);
+ }
+ return result;
+ };
+
+ export const setBit = (val, pos) => {
+ if (typeof val !== 'bigint') {
+   throw new TypeError('val must be bigint');
+ }
+ if (typeof pos !== 'number' || !Number.isInteger(pos) || pos < 0) {
+   throw new TypeError('pos must be a non-negative integer');
+ }
+ return val | (1n << BigInt(pos));
+ };
+
+ export const clearBit = (val, pos) => {
+ if (typeof val !== 'bigint') {
+   throw new TypeError('val must be bigint');
+ }
+ if (typeof pos !== 'number' || !Number.isInteger(pos) || pos < 0) {
+   throw new TypeError('pos must be a non-negative integer');
+ }
+ return val & ~(1n << BigInt(pos));
+ };
+
+ export const toggleBit = (val, pos) => {
+ if (typeof val !== 'bigint') {
+   throw new TypeError('val must be bigint');
+ }
+ if (typeof pos !== 'number' || !Number.isInteger(pos) || pos < 0) {
+   throw new TypeError('pos must be a non-negative integer');
+ }
+ return val ^ (1n << BigInt(pos));
+ };

package/src/utils/categorical.js

@@ -1,12 +1,21 @@
 export const categorical = (rng, categories, probabilities) => {
-  if (!categories || !probabilities) throw new Error('Categories and probabilities required');
-  if (categories.length === 0) throw new Error('Categories cannot be empty');
-  if (probabilities.length !== categories.length) {
-    throw new Error('Probabilities and categories must have same length');
-  }
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('First argument must be RNG instance');
+    }
+    if (!Array.isArray(categories) || !Array.isArray(probabilities)) {
+      throw new TypeError('Categories and probabilities must be arrays');
+    }
+    if (categories.length === 0) {
+      throw new RangeError('Categories cannot be empty');
+    }
+    if (probabilities.length !== categories.length) {
+      throw new RangeError('Probabilities and categories must have same length');
+    }
 
-  const total = probabilities.reduce((a, b) => a + b, 0);
-  if (total <= 0) throw new Error('Probabilities must sum to positive value');
+    const total = probabilities.reduce((a, b) => a + b, 0);
+    if (total <= 0) {
+      throw new RangeError('Probabilities must sum to positive value');
+    }
   
   const normalized = probabilities.map(p => p / total);
 
@@ -24,34 +33,62 @@ export const categorical = (rng, categories, probabilities) => {
 };
 
 export const multinomial = (rng, n, categories, probabilities) => {
-  const result = {};
-  for (const cat of categories) {
-    result[cat] = 0;
-  }
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('First argument must be RNG instance');
+    }
+    if (typeof n !== 'number' || !Number.isInteger(n)) {
+      throw new TypeError('n must be an integer');
+    }
+    if (n <= 0) {
+      throw new RangeError('n must be positive');
+    }
+    if (!Array.isArray(categories) || categories.length === 0) {
+      throw new RangeError('categories must be a non-empty array');
+    }
+    if (!Array.isArray(probabilities) || probabilities.length === 0) {
+      throw new RangeError('probabilities must be a non-empty array');
+    }
+    if (probabilities.length !== categories.length) {
+      throw new RangeError('probabilities and categories must have same length');
+    }
+   const result = {};
+   for (const cat of categories) {
+     result[cat] = 0;
+   }
 
-  for (let i = 0; i < n; i++) {
-    const pick = categorical(rng, categories, probabilities);
-    result[pick]++;
-  }
+   for (let i = 0; i < n; i++) {
+     const pick = categorical(rng, categories, probabilities);
+     result[pick]++;
+   }
 
-  return result;
-};
+   return result;
+ };
 
 export const categorical2D = (rng, matrix) => {
-  const rows = matrix.length;
-  const cols = matrix[0].length;
-
-  const total = matrix.flat().reduce((a, b) => a + b, 0);
-  let rand = rng.nextFloat() * total;
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('First argument must be RNG instance');
+    }
+    if (!Array.isArray(matrix) || matrix.length === 0) {
+      throw new RangeError('matrix must be non-empty array');
+    }
+    const rows = matrix.length;
+    const cols = matrix[0].length;
 
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      rand -= matrix[i][j];
-      if (rand <= 0) {
-        return [i, j];
-      }
+    const flat = matrix.flat();
+    const total = flat.reduce((a, b) => a + b, 0);
+    if (total <= 0) {
+      throw new RangeError('Matrix values must sum to positive');
     }
-  }
+   
+   let cumsum = 0;
+   const rand = rng.nextFloat() * total;
 
-  return [rows - 1, cols - 1];
-};
+   for (let idx = 0; idx < flat.length; idx++) {
+     cumsum += flat[idx];
+     if (rand < cumsum) {
+       return [Math.floor(idx / cols), idx % cols];
+     }
+   }
+
+   return [rows - 1, cols - 1];
+ };