@digitaldefiance/node-accelerate 1.0.7 → 2.0.0

package/index.js

@@ -351,14 +351,589 @@ function rms(a) {
   return accelerate.rms(a);
 }
 
+/**
+ * Variance of vector elements
+ * @param {Float64Array} a - Input vector
+ * @returns {number} Variance
+ */
+function variance(a) {
+  return accelerate.variance(a);
+}
+
+/**
+ * Standard deviation of vector elements
+ * @param {Float64Array} a - Input vector
+ * @returns {number} Standard deviation
+ */
+function stddev(a) {
+  return accelerate.stddev(a);
+}
+
+/**
+ * Min and max of vector elements
+ * @param {Float64Array} a - Input vector
+ * @returns {{min: number, max: number}} Object with min and max
+ */
+function minmax(a) {
+  return accelerate.minmax(a);
+}
+
+/**
+ * Vector sine: b = sin(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vsin(a, b) {
+  return accelerate.vsin(a, b);
+}
+
+/**
+ * Vector cosine: b = cos(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vcos(a, b) {
+  return accelerate.vcos(a, b);
+}
+
+/**
+ * Vector tangent: b = tan(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vtan(a, b) {
+  return accelerate.vtan(a, b);
+}
+
+/**
+ * Vector exponential: b = exp(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vexp(a, b) {
+  return accelerate.vexp(a, b);
+}
+
+/**
+ * Vector natural logarithm: b = log(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vlog(a, b) {
+  return accelerate.vlog(a, b);
+}
+
+/**
+ * Vector base-10 logarithm: b = log10(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vlog10(a, b) {
+  return accelerate.vlog10(a, b);
+}
+
+/**
+ * Vector power: c = a^b (element-wise)
+ * @param {Float64Array} a - Base vector
+ * @param {Float64Array} b - Exponent vector
+ * @param {Float64Array} c - Output vector
+ * @returns {Float64Array} c
+ */
+function vpow(a, b, c) {
+  return accelerate.vpow(a, b, c);
+}
+
+/**
+ * Vector clip: b = clip(a, min, max)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @param {number} min - Minimum value
+ * @param {number} max - Maximum value
+ * @returns {Float64Array} b
+ */
+function vclip(a, b, min, max) {
+  return accelerate.vclip(a, b, min, max);
+}
+
+/**
+ * Vector threshold: b = a where a > threshold, else 0
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @param {number} threshold - Threshold value
+ * @returns {Float64Array} b
+ */
+function vthreshold(a, b, threshold) {
+  return accelerate.vthreshold(a, b, threshold);
+}
+
+/**
+ * Convolution: result = signal * kernel
+ * @param {Float64Array} signal - Input signal
+ * @param {Float64Array} kernel - Convolution kernel
+ * @param {Float64Array} result - Output (length = signal.length - kernel.length + 1)
+ * @returns {Float64Array} result
+ */
+function conv(signal, kernel, result) {
+  return accelerate.conv(signal, kernel, result);
+}
+
+/**
+ * Cross-correlation: result = correlate(a, b)
+ * @param {Float64Array} a - First signal
+ * @param {Float64Array} b - Second signal
+ * @param {Float64Array} result - Output (length = a.length + b.length - 1)
+ * @returns {Float64Array} result
+ */
+function xcorr(a, b, result) {
+  return accelerate.xcorr(a, b, result);
+}
+
+/**
+ * Generate Hamming window
+ * @param {number} length - Window length
+ * @returns {Float64Array} Window coefficients
+ */
+function hamming(length) {
+  return accelerate.hamming(length);
+}
+
+/**
+ * Generate Hanning window
+ * @param {number} length - Window length
+ * @returns {Float64Array} Window coefficients
+ */
+function hanning(length) {
+  return accelerate.hanning(length);
+}
+
+/**
+ * Generate Blackman window
+ * @param {number} length - Window length
+ * @returns {Float64Array} Window coefficients
+ */
+function blackman(length) {
+  return accelerate.blackman(length);
+}
+
+/**
+ * Matrix transpose: B = A^T
+ * @param {Float64Array} A - Input matrix (rows × cols, row-major)
+ * @param {Float64Array} B - Output matrix (cols × rows, row-major)
+ * @param {number} rows - Number of rows in A
+ * @param {number} cols - Number of columns in A
+ * @returns {Float64Array} B
+ */
+function transpose(A, B, rows, cols) {
+  return accelerate.transpose(A, B, rows, cols);
+}
+
+/**
+ * Inverse Fast Fourier Transform
+ * @param {Float64Array} real - Real part of frequency domain
+ * @param {Float64Array} imag - Imaginary part of frequency domain
+ * @returns {Float64Array} Time domain signal
+ */
+function ifft(real, imag) {
+  if (!(real instanceof Float64Array) || !(imag instanceof Float64Array)) {
+    throw new TypeError('Arguments must be Float64Arrays');
+  }
+  if (real.length !== imag.length) {
+    throw new RangeError('Real and imaginary arrays must have same length');
+  }
+  
+  return accelerate.ifft(real, imag);
+}
+
+/**
+ * Linear interpolation
+ * @param {Float64Array} x - X coordinates of data points
+ * @param {Float64Array} y - Y coordinates of data points
+ * @param {Float64Array} xi - X coordinates to interpolate at
+ * @param {Float64Array} yi - Output interpolated Y values
+ * @returns {Float64Array} yi
+ */
+function interp1d(x, y, xi, yi) {
+  return accelerate.interp1d(x, y, xi, yi);
+}
+
+/**
+ * Vector reverse: b = reverse(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vreverse(a, b) {
+  return accelerate.vreverse(a, b);
+}
+
+/**
+ * Vector negate: b = -a
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vneg(a, b) {
+  return accelerate.vneg(a, b);
+}
+
+/**
+ * Sum of squares: sum(a[i]^2)
+ * @param {Float64Array} a - Input vector
+ * @returns {number} Sum of squares
+ */
+function sumOfSquares(a) {
+  return accelerate.sumOfSquares(a);
+}
+
+/**
+ * Mean magnitude: mean(|a[i]|)
+ * @param {Float64Array} a - Input vector
+ * @returns {number} Mean magnitude
+ */
+function meanMagnitude(a) {
+  return accelerate.meanMagnitude(a);
+}
+
+/**
+ * Mean square: mean(a[i]^2)
+ * @param {Float64Array} a - Input vector
+ * @returns {number} Mean square
+ */
+function meanSquare(a) {
+  return accelerate.meanSquare(a);
+}
+
+// ============================================================================
+// ADDITIONAL BLAS OPERATIONS
+// ============================================================================
+
+/**
+ * Vector copy: y = x
+ * @param {Float64Array} x - Source vector
+ * @param {Float64Array} y - Destination vector
+ * @returns {Float64Array} y
+ */
+function copy(x, y) {
+  return accelerate.copy(x, y);
+}
+
+/**
+ * Vector swap: exchange x and y
+ * @param {Float64Array} x - First vector
+ * @param {Float64Array} y - Second vector
+ * @returns {Float64Array} x
+ */
+function swap(x, y) {
+  return accelerate.swap(x, y);
+}
+
+/**
+ * Vector norm (L2 norm / Euclidean length): ||x||
+ * @param {Float64Array} x - Input vector
+ * @returns {number} L2 norm
+ */
+function norm(x) {
+  return accelerate.norm(x);
+}
+
+/**
+ * Sum of absolute values: sum(|x[i]|)
+ * @param {Float64Array} x - Input vector
+ * @returns {number} Sum of absolute values
+ */
+function abssum(x) {
+  return accelerate.abssum(x);
+}
+
+/**
+ * Index of maximum absolute value
+ * @param {Float64Array} x - Input vector
+ * @returns {number} Index of element with maximum absolute value
+ */
+function maxAbsIndex(x) {
+  return accelerate.maxAbsIndex(x);
+}
+
+/**
+ * Apply Givens rotation
+ * @param {Float64Array} x - First vector
+ * @param {Float64Array} y - Second vector
+ * @param {number} c - Cosine of rotation angle
+ * @param {number} s - Sine of rotation angle
+ * @returns {Float64Array} x
+ */
+function rot(x, y, c, s) {
+  return accelerate.rot(x, y, c, s);
+}
+
+// ============================================================================
+// ADDITIONAL vDSP OPERATIONS
+// ============================================================================
+
+/**
+ * Fill vector with scalar value
+ * @param {number} scalar - Value to fill with
+ * @param {Float64Array} vec - Output vector
+ * @returns {Float64Array} vec
+ */
+function vfill(scalar, vec) {
+  return accelerate.vfill(scalar, vec);
+}
+
+/**
+ * Generate linear ramp: vec[i] = start + i * step
+ * @param {number} start - Starting value
+ * @param {number} step - Step size
+ * @param {Float64Array} vec - Output vector
+ * @returns {Float64Array} vec
+ */
+function vramp(start, step, vec) {
+  return accelerate.vramp(start, step, vec);
+}
+
+/**
+ * Add scalar to vector: c = a + scalar
+ * @param {Float64Array} a - Input vector
+ * @param {number} scalar - Scalar to add
+ * @param {Float64Array} c - Output vector
+ * @returns {Float64Array} c
+ */
+function vaddScalar(a, scalar, c) {
+  return accelerate.vaddScalar(a, scalar, c);
+}
+
+/**
+ * Multiply and add: d = (a * b) + c
+ * @param {Float64Array} a - First vector
+ * @param {Float64Array} b - Second vector
+ * @param {Float64Array} c - Third vector
+ * @param {Float64Array} d - Output vector
+ * @returns {Float64Array} d
+ */
+function vma(a, b, c, d) {
+  return accelerate.vma(a, b, c, d);
+}
+
+/**
+ * Multiply and scalar add: d = (a * b) + c (scalar)
+ * @param {Float64Array} a - First vector
+ * @param {Float64Array} b - Second vector
+ * @param {number} c - Scalar to add
+ * @param {Float64Array} d - Output vector
+ * @returns {Float64Array} d
+ */
+function vmsa(a, b, c, d) {
+  return accelerate.vmsa(a, b, c, d);
+}
+
+/**
+ * Linear interpolation between vectors: c = a + t * (b - a)
+ * @param {Float64Array} a - Start vector
+ * @param {Float64Array} b - End vector
+ * @param {number} t - Interpolation parameter (0 to 1)
+ * @param {Float64Array} c - Output vector
+ * @returns {Float64Array} c
+ */
+function vlerp(a, b, t, c) {
+  return accelerate.vlerp(a, b, t, c);
+}
+
+/**
+ * Clear vector (set to zero)
+ * @param {Float64Array} vec - Vector to clear
+ * @returns {Float64Array} vec
+ */
+function vclear(vec) {
+  return accelerate.vclear(vec);
+}
+
+/**
+ * Limit vector values (saturate): c = limit(a, low, high)
+ * @param {Float64Array} a - Input vector
+ * @param {number} low - Lower limit
+ * @param {number} high - Upper limit
+ * @param {Float64Array} c - Output vector
+ * @returns {Float64Array} c
+ */
+function vlimit(a, low, high, c) {
+  return accelerate.vlimit(a, low, high, c);
+}
+
+/**
+ * Maximum magnitude in vector: max(|a[i]|)
+ * @param {Float64Array} a - Input vector
+ * @returns {number} Maximum magnitude
+ */
+function maxMagnitude(a) {
+  return accelerate.maxMagnitude(a);
+}
+
+/**
+ * Minimum magnitude in vector: min(|a[i]|)
+ * @param {Float64Array} a - Input vector
+ * @returns {number} Minimum magnitude
+ */
+function minMagnitude(a) {
+  return accelerate.minMagnitude(a);
+}
+
+// ============================================================================
+// MORE MATH FUNCTIONS
+// ============================================================================
+
+/**
+ * Reciprocal: b = 1/a
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vreciprocal(a, b) {
+  return accelerate.vreciprocal(a, b);
+}
+
+/**
+ * Inverse square root: b = 1/sqrt(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vrsqrt(a, b) {
+  return accelerate.vrsqrt(a, b);
+}
+
+/**
+ * Hyperbolic sine: b = sinh(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vsinh(a, b) {
+  return accelerate.vsinh(a, b);
+}
+
+/**
+ * Hyperbolic cosine: b = cosh(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vcosh(a, b) {
+  return accelerate.vcosh(a, b);
+}
+
+/**
+ * Hyperbolic tangent: b = tanh(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vtanh(a, b) {
+  return accelerate.vtanh(a, b);
+}
+
+/**
+ * Inverse sine: b = asin(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vasin(a, b) {
+  return accelerate.vasin(a, b);
+}
+
+/**
+ * Inverse cosine: b = acos(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vacos(a, b) {
+  return accelerate.vacos(a, b);
+}
+
+/**
+ * Inverse tangent: b = atan(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vatan(a, b) {
+  return accelerate.vatan(a, b);
+}
+
+/**
+ * Two-argument inverse tangent: c = atan2(a, b)
+ * @param {Float64Array} a - Y coordinates
+ * @param {Float64Array} b - X coordinates
+ * @param {Float64Array} c - Output vector (angles)
+ * @returns {Float64Array} c
+ */
+function vatan2(a, b, c) {
+  return accelerate.vatan2(a, b, c);
+}
+
+/**
+ * Ceiling: b = ceil(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vceil(a, b) {
+  return accelerate.vceil(a, b);
+}
+
+/**
+ * Floor: b = floor(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vfloor(a, b) {
+  return accelerate.vfloor(a, b);
+}
+
+/**
+ * Truncate (round toward zero): b = trunc(a)
+ * @param {Float64Array} a - Input vector
+ * @param {Float64Array} b - Output vector
+ * @returns {Float64Array} b
+ */
+function vtrunc(a, b) {
+  return accelerate.vtrunc(a, b);
+}
+
+/**
+ * Copy sign: c = copysign(a, b) - magnitude of a with sign of b
+ * @param {Float64Array} a - Magnitude source
+ * @param {Float64Array} b - Sign source
+ * @param {Float64Array} c - Output vector
+ * @returns {Float64Array} c
+ */
+function vcopysign(a, b, c) {
+  return accelerate.vcopysign(a, b, c);
+}
+
 module.exports = {
   // Matrix operations
   matmul,
   matmulFloat,
   matvec,
+  transpose,
   
   // BLAS operations
   axpy,
+  copy,
+  swap,
+  norm,
+  abssum,
+  maxAbsIndex,
+  rot,
   
   // Vector arithmetic
   dot,
@@ -367,25 +942,86 @@ module.exports = {
   vmul,
   vdiv,
   vscale,
+  vneg,
+  vaddScalar,
+  vma,
+  vmsa,
   
   // Vector functions
   vabs,
   vsquare,
   vsqrt,
   normalize,
+  vreverse,
+  vfill,
+  vramp,
+  vlerp,
+  vclear,
+  vlimit,
+  
+  // Trigonometric
+  vsin,
+  vcos,
+  vtan,
+  vasin,
+  vacos,
+  vatan,
+  vatan2,
+  
+  // Hyperbolic
+  vsinh,
+  vcosh,
+  vtanh,
+  
+  // Exponential/Logarithmic
+  vexp,
+  vlog,
+  vlog10,
+  vpow,
+  vreciprocal,
+  vrsqrt,
+  
+  // Rounding
+  vceil,
+  vfloor,
+  vtrunc,
+  vcopysign,
+  
+  // Clipping/Thresholding
+  vclip,
+  vthreshold,
   
   // Reductions
   sum,
   mean,
   max,
   min,
+  minmax,
   rms,
+  variance,
+  stddev,
+  sumOfSquares,
+  meanMagnitude,
+  meanSquare,
+  maxMagnitude,
+  minMagnitude,
   
   // Distance metrics
   euclidean,
   
   // Signal processing
   fft,
+  ifft,
+  conv,
+  xcorr,
+  
+  // Window functions
+  hamming,
+  hanning,
+  blackman,
+  
+  // Interpolation
+  interp1d,
   
   // Raw native bindings (for advanced use)
   _native: accelerate

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@digitaldefiance/node-accelerate",
-  "version": "1.0.7",
-  "description": "High-performance Apple Accelerate framework bindings for Node.js - 283x faster matrix operations on Apple Silicon",
+  "version": "2.0.0",
+  "description": "High-performance Apple Accelerate framework bindings for Node.js - 80+ optimized functions including BLAS, vDSP, and vForce",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
@@ -9,7 +9,8 @@
     "install": "node-gyp rebuild",
     "build": "node-gyp rebuild",
     "test": "node test.js",
-    "benchmark": "node benchmark.js",
+    "benchmark": "node benchmark-comprehensive.js",
+    "benchmark:simple": "node benchmark.js",
     "compare": "node compare.js",
     "prepublishOnly": "npm test",
     "publish:public": "npm publish --access public"
@@ -27,6 +28,14 @@
     "matrix",
     "vector",
     "fft",
+    "ifft",
+    "convolution",
+    "correlation",
+    "trigonometry",
+    "statistics",
+    "signal-processing",
+    "window-functions",
+    "interpolation",
     "performance",
     "native",
     "addon",