@digitaldefiance/node-accelerate 1.0.7 → 2.0.0

package/examples/data-processing.js

@@ -0,0 +1,123 @@
+/**
+ * Data Processing Examples
+ * Demonstrates clipping, thresholding, interpolation, and matrix operations
+ */
+
+const accelerate = require('..');
+
+console.log('=== Data Processing ===\n');
+
+// 1. Clipping
+console.log('--- Clipping ---');
+const data = new Float64Array(10);
+for (let i = 0; i < 10; i++) {
+  data[i] = (i - 5) * 10; // -50 to 40
+}
+
+const clipped = new Float64Array(10);
+accelerate.vclip(data, clipped, -20, 20);
+
+console.log('Original:', Array.from(data));
+console.log('Clipped [-20, 20]:', Array.from(clipped));
+
+// 2. Thresholding
+console.log('\n--- Thresholding ---');
+const signal = new Float64Array(10);
+for (let i = 0; i < 10; i++) {
+  signal[i] = Math.random() * 100;
+}
+
+const thresholded = new Float64Array(10);
+accelerate.vthreshold(signal, thresholded, 50);
+
+console.log('Original:', Array.from(signal).map(x => x.toFixed(1)));
+console.log('Threshold > 50:', Array.from(thresholded).map(x => x.toFixed(1)));
+
+// 3. Vector Reversal
+console.log('\n--- Vector Reversal ---');
+const sequence = new Float64Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+const reversed = new Float64Array(10);
+
+accelerate.vreverse(sequence, reversed);
+
+console.log('Original:', Array.from(sequence));
+console.log('Reversed:', Array.from(reversed));
+
+// 4. Matrix Transpose
+console.log('\n--- Matrix Transpose ---');
+const rows = 3, cols = 4;
+const matrix = new Float64Array(rows * cols);
+
+// Fill matrix
+for (let i = 0; i < rows; i++) {
+  for (let j = 0; j < cols; j++) {
+    matrix[i * cols + j] = i * cols + j + 1;
+  }
+}
+
+const transposed = new Float64Array(rows * cols);
+accelerate.transpose(matrix, transposed, rows, cols);
+
+console.log('Original matrix (3×4):');
+for (let i = 0; i < rows; i++) {
+  const row = [];
+  for (let j = 0; j < cols; j++) {
+    row.push(matrix[i * cols + j].toFixed(0).padStart(3));
+  }
+  console.log('  [' + row.join(' ') + ']');
+}
+
+console.log('Transposed matrix (4×3):');
+for (let i = 0; i < cols; i++) {
+  const row = [];
+  for (let j = 0; j < rows; j++) {
+    row.push(transposed[i * rows + j].toFixed(0).padStart(3));
+  }
+  console.log('  [' + row.join(' ') + ']');
+}
+
+// 5. Linear Interpolation
+console.log('\n--- Linear Interpolation ---');
+const xData = new Float64Array([0, 1, 2, 3, 4]);
+const yData = new Float64Array([0, 1, 4, 9, 16]); // y = x²
+
+const xiData = new Float64Array([0.5, 1.5, 2.5, 3.5]);
+const yiData = new Float64Array(4);
+
+accelerate.interp1d(xData, yData, xiData, yiData);
+
+console.log('Known points (x, y):');
+for (let i = 0; i < xData.length; i++) {
+  console.log(`  (${xData[i]}, ${yData[i]})`);
+}
+
+console.log('Interpolated points:');
+for (let i = 0; i < xiData.length; i++) {
+  console.log(`  x=${xiData[i]} → y=${yiData[i].toFixed(2)}`);
+}
+
+// 6. Data Normalization Pipeline
+console.log('\n--- Data Normalization Pipeline ---');
+const rawData = new Float64Array(100);
+for (let i = 0; i < 100; i++) {
+  rawData[i] = Math.random() * 200 - 100; // -100 to 100
+}
+
+// Step 1: Clip outliers
+const clippedData = new Float64Array(100);
+accelerate.vclip(rawData, clippedData, -50, 50);
+
+// Step 2: Take absolute value
+const absData = new Float64Array(100);
+accelerate.vabs(clippedData, absData);
+
+// Step 3: Normalize to [0, 1]
+const maxVal = accelerate.max(absData);
+const normalized = new Float64Array(100);
+accelerate.vscale(absData, 1.0 / maxVal, normalized);
+
+console.log('Pipeline statistics:');
+console.log('  Raw data range:', [accelerate.min(rawData).toFixed(2), accelerate.max(rawData).toFixed(2)]);
+console.log('  After clipping:', [accelerate.min(clippedData).toFixed(2), accelerate.max(clippedData).toFixed(2)]);
+console.log('  After abs:', [accelerate.min(absData).toFixed(2), accelerate.max(absData).toFixed(2)]);
+console.log('  After normalization:', [accelerate.min(normalized).toFixed(2), accelerate.max(normalized).toFixed(2)]);

package/examples/mathematical-functions.js

@@ -0,0 +1,101 @@
+/**
+ * Mathematical Functions Examples
+ * Demonstrates exp, log, power, and other math operations
+ */
+
+const accelerate = require('..');
+
+console.log('=== Mathematical Functions ===\n');
+
+const n = 1000;
+
+// 1. Exponential and Logarithm
+console.log('--- Exponential and Logarithm ---');
+const x = new Float64Array(n);
+const expX = new Float64Array(n);
+const logExpX = new Float64Array(n);
+
+for (let i = 0; i < n; i++) {
+  x[i] = i / 100; // 0 to 10
+}
+
+accelerate.vexp(x, expX);
+accelerate.vlog(expX, logExpX);
+
+// Verify log(exp(x)) = x
+let maxError = 0;
+for (let i = 0; i < n; i++) {
+  const error = Math.abs(x[i] - logExpX[i]);
+  if (error > maxError) maxError = error;
+}
+
+console.log('log(exp(x)) = x verification');
+console.log('Max error:', maxError.toFixed(10));
+
+// 2. Power functions
+console.log('\n--- Power Functions ---');
+const base = new Float64Array(100);
+const exponent = new Float64Array(100);
+const result = new Float64Array(100);
+
+for (let i = 0; i < 100; i++) {
+  base[i] = i / 10 + 1; // 1 to 11
+  exponent[i] = 2; // Square everything
+}
+
+accelerate.vpow(base, exponent, result);
+
+console.log('First 5 values squared:');
+for (let i = 0; i < 5; i++) {
+  console.log(`  ${base[i].toFixed(1)}^2 = ${result[i].toFixed(2)}`);
+}
+
+// 3. Square root verification
+console.log('\n--- Square Root ---');
+const squares = new Float64Array(100);
+const sqrtResult = new Float64Array(100);
+
+for (let i = 0; i < 100; i++) {
+  squares[i] = i * i;
+}
+
+accelerate.vsqrt(squares, sqrtResult);
+
+console.log('sqrt(x²) = x verification:');
+console.log('  sqrt(25) =', sqrtResult[5].toFixed(4));
+console.log('  sqrt(100) =', sqrtResult[10].toFixed(4));
+console.log('  sqrt(10000) =', sqrtResult[100-1].toFixed(4));
+
+// 4. Log base 10
+console.log('\n--- Logarithm Base 10 ---');
+const powers10 = new Float64Array([1, 10, 100, 1000, 10000]);
+const log10Result = new Float64Array(5);
+
+accelerate.vlog10(powers10, log10Result);
+
+console.log('log10 of powers of 10:');
+for (let i = 0; i < 5; i++) {
+  console.log(`  log10(${powers10[i]}) = ${log10Result[i].toFixed(4)}`);
+}
+
+// 5. Absolute value
+console.log('\n--- Absolute Value ---');
+const mixed = new Float64Array([-5, -3, -1, 0, 1, 3, 5]);
+const absResult = new Float64Array(7);
+
+accelerate.vabs(mixed, absResult);
+
+console.log('Absolute values:');
+console.log('  Input:', Array.from(mixed));
+console.log('  Output:', Array.from(absResult));
+
+// 6. Negation
+console.log('\n--- Negation ---');
+const positive = new Float64Array([1, 2, 3, 4, 5]);
+const negative = new Float64Array(5);
+
+accelerate.vneg(positive, negative);
+
+console.log('Negation:');
+console.log('  Input:', Array.from(positive));
+console.log('  Output:', Array.from(negative));

package/examples/ml-pipeline.js

@@ -0,0 +1,317 @@
+/**
+ * Complete Machine Learning Pipeline Example
+ * Demonstrates data preprocessing, neural network inference, and evaluation
+ */
+
+const accelerate = require('..');
+
+console.log('=== Machine Learning Pipeline ===\n');
+
+// ============================================================================
+// 1. DATA PREPROCESSING
+// ============================================================================
+
+console.log('--- Step 1: Data Preprocessing ---');
+
+// Generate synthetic dataset
+const numSamples = 1000;
+const numFeatures = 10;
+const rawData = new Float64Array(numSamples * numFeatures);
+
+for (let i = 0; i < rawData.length; i++) {
+  rawData[i] = Math.random() * 200 - 100; // Range: -100 to 100
+}
+
+console.log('Raw data shape:', [numSamples, numFeatures]);
+console.log('Raw data range:', [
+  accelerate.min(rawData).toFixed(2),
+  accelerate.max(rawData).toFixed(2)
+]);
+
+// Step 1a: Clip outliers
+const clipped = new Float64Array(rawData.length);
+accelerate.vclip(rawData, clipped, -50, 50);
+
+// Step 1b: Standardization (z-score normalization)
+function standardize(data, output) {
+  const mean = accelerate.mean(data);
+  const std = accelerate.stddev(data);
+  
+  for (let i = 0; i < data.length; i++) {
+    output[i] = (data[i] - mean) / std;
+  }
+  
+  return output;
+}
+
+const normalized = new Float64Array(clipped.length);
+standardize(clipped, normalized);
+
+console.log('After preprocessing:');
+console.log('  Mean:', accelerate.mean(normalized).toFixed(6));
+console.log('  Std Dev:', accelerate.stddev(normalized).toFixed(6));
+console.log('  Range:', [
+  accelerate.min(normalized).toFixed(2),
+  accelerate.max(normalized).toFixed(2)
+]);
+
+// ============================================================================
+// 2. NEURAL NETWORK INFERENCE
+// ============================================================================
+
+console.log('\n--- Step 2: Neural Network Inference ---');
+
+// Network architecture: 10 -> 64 -> 32 -> 3 (classification)
+const layer1Weights = new Float64Array(10 * 64);
+const layer1Bias = new Float64Array(64);
+const layer2Weights = new Float64Array(64 * 32);
+const layer2Bias = new Float64Array(32);
+const layer3Weights = new Float64Array(32 * 3);
+const layer3Bias = new Float64Array(3);
+
+// Initialize with random weights (Xavier initialization)
+function initializeWeights(weights, fanIn, fanOut) {
+  const limit = Math.sqrt(6.0 / (fanIn + fanOut));
+  for (let i = 0; i < weights.length; i++) {
+    weights[i] = (Math.random() * 2 - 1) * limit;
+  }
+}
+
+initializeWeights(layer1Weights, 10, 64);
+initializeWeights(layer2Weights, 64, 32);
+initializeWeights(layer3Weights, 32, 3);
+
+// ReLU activation
+function relu(input, output) {
+  accelerate.vclip(input, output, 0, Infinity);
+  return output;
+}
+
+// Softmax activation
+function softmax(logits, output) {
+  // Subtract max for numerical stability
+  const maxVal = accelerate.max(logits);
+  const shifted = new Float64Array(logits.length);
+  
+  for (let i = 0; i < logits.length; i++) {
+    shifted[i] = logits[i] - maxVal;
+  }
+  
+  // Compute exp
+  accelerate.vexp(shifted, output);
+  
+  // Normalize
+  const sum = accelerate.sum(output);
+  accelerate.vscale(output, 1.0 / sum, output);
+  
+  return output;
+}
+
+// Forward pass for one sample
+function forward(input) {
+  // Layer 1: input (10) -> hidden1 (64)
+  const hidden1 = new Float64Array(64);
+  accelerate.matvec(layer1Weights, input, hidden1, 64, 10);
+  accelerate.vadd(hidden1, layer1Bias, hidden1);
+  relu(hidden1, hidden1);
+  
+  // Layer 2: hidden1 (64) -> hidden2 (32)
+  const hidden2 = new Float64Array(32);
+  accelerate.matvec(layer2Weights, hidden1, hidden2, 32, 64);
+  accelerate.vadd(hidden2, layer2Bias, hidden2);
+  relu(hidden2, hidden2);
+  
+  // Layer 3: hidden2 (32) -> output (3)
+  const logits = new Float64Array(3);
+  accelerate.matvec(layer3Weights, hidden2, logits, 3, 32);
+  accelerate.vadd(logits, layer3Bias, logits);
+  
+  // Softmax
+  const probs = new Float64Array(3);
+  softmax(logits, probs);
+  
+  return probs;
+}
+
+// Run inference on first sample
+const sampleInput = normalized.subarray(0, 10);
+const predictions = forward(sampleInput);
+
+console.log('Network architecture: 10 -> 64 -> 32 -> 3');
+console.log('Sample prediction:', Array.from(predictions).map(x => x.toFixed(4)));
+console.log('Predicted class:', predictions.indexOf(accelerate.max(predictions)));
+
+// Batch inference
+console.log('\nRunning batch inference...');
+console.time('Batch inference (1000 samples)');
+
+const allPredictions = [];
+for (let i = 0; i < numSamples; i++) {
+  const input = normalized.subarray(i * numFeatures, (i + 1) * numFeatures);
+  const pred = forward(input);
+  allPredictions.push(Array.from(pred));
+}
+
+console.timeEnd('Batch inference (1000 samples)');
+
+// ============================================================================
+// 3. FEATURE ENGINEERING
+// ============================================================================
+
+console.log('\n--- Step 3: Feature Engineering ---');
+
+// Compute polynomial features (x^2)
+const squaredFeatures = new Float64Array(normalized.length);
+accelerate.vsquare(normalized, squaredFeatures);
+
+// Compute interaction features (for first two features)
+const feature1 = normalized.subarray(0, numSamples);
+const feature2 = normalized.subarray(numSamples, numSamples * 2);
+const interaction = new Float64Array(numSamples);
+accelerate.vmul(feature1, feature2, interaction);
+
+console.log('Original features:', numFeatures);
+console.log('Added squared features:', numFeatures);
+console.log('Added interaction features: 1');
+console.log('Total features:', numFeatures * 2 + 1);
+
+// ============================================================================
+// 4. DISTANCE-BASED METHODS
+// ============================================================================
+
+console.log('\n--- Step 4: Distance Computations ---');
+
+// K-nearest neighbors: find distance to first sample
+const query = normalized.subarray(0, numFeatures);
+const distances = [];
+
+for (let i = 1; i < Math.min(100, numSamples); i++) {
+  const sample = normalized.subarray(i * numFeatures, (i + 1) * numFeatures);
+  const dist = accelerate.euclidean(query, sample);
+  distances.push({ index: i, distance: dist });
+}
+
+// Sort by distance
+distances.sort((a, b) => a.distance - b.distance);
+
+console.log('K-Nearest Neighbors (k=5):');
+for (let i = 0; i < 5; i++) {
+  console.log(`  Neighbor ${i + 1}: sample ${distances[i].index}, distance ${distances[i].distance.toFixed(4)}`);
+}
+
+// ============================================================================
+// 5. DIMENSIONALITY REDUCTION (PCA-like projection)
+// ============================================================================
+
+console.log('\n--- Step 5: Dimensionality Reduction ---');
+
+// Simple random projection (approximates PCA)
+const projectionMatrix = new Float64Array(numFeatures * 2); // Project to 2D
+initializeWeights(projectionMatrix, numFeatures, 2);
+
+// Normalize projection matrix columns
+for (let col = 0; col < 2; col++) {
+  const column = new Float64Array(numFeatures);
+  for (let row = 0; row < numFeatures; row++) {
+    column[row] = projectionMatrix[row * 2 + col];
+  }
+  
+  const normalized = new Float64Array(numFeatures);
+  accelerate.normalize(column, normalized);
+  
+  for (let row = 0; row < numFeatures; row++) {
+    projectionMatrix[row * 2 + col] = normalized[row];
+  }
+}
+
+// Project first sample
+const projected = new Float64Array(2);
+accelerate.matvec(projectionMatrix, sampleInput, projected, 2, numFeatures);
+
+console.log('Original dimensions:', numFeatures);
+console.log('Reduced dimensions: 2');
+console.log('Sample projection:', Array.from(projected).map(x => x.toFixed(4)));
+
+// ============================================================================
+// 6. SIGNAL PROCESSING FOR TIME SERIES
+// ============================================================================
+
+console.log('\n--- Step 6: Time Series Analysis ---');
+
+// Generate synthetic time series
+const timeSeriesLength = 1024;
+const timeSeries = new Float64Array(timeSeriesLength);
+
+for (let i = 0; i < timeSeriesLength; i++) {
+  // Mix of frequencies
+  timeSeries[i] = 
+    Math.sin(2 * Math.PI * 5 * i / timeSeriesLength) +
+    0.5 * Math.sin(2 * Math.PI * 10 * i / timeSeriesLength) +
+    0.3 * Math.sin(2 * Math.PI * 20 * i / timeSeriesLength);
+}
+
+// Apply Hanning window
+const window = accelerate.hanning(timeSeriesLength);
+const windowed = new Float64Array(timeSeriesLength);
+accelerate.vmul(timeSeries, window, windowed);
+
+// Compute FFT
+const spectrum = accelerate.fft(windowed);
+
+// Find dominant frequencies
+const magnitudes = new Float64Array(spectrum.real.length);
+for (let i = 0; i < magnitudes.length; i++) {
+  magnitudes[i] = Math.sqrt(spectrum.real[i]**2 + spectrum.imag[i]**2);
+}
+
+// Find peaks
+const peaks = [];
+for (let i = 1; i < magnitudes.length - 1; i++) {
+  if (magnitudes[i] > magnitudes[i-1] && magnitudes[i] > magnitudes[i+1] && magnitudes[i] > 10) {
+    peaks.push({ bin: i, magnitude: magnitudes[i] });
+  }
+}
+
+peaks.sort((a, b) => b.magnitude - a.magnitude);
+
+console.log('Time series length:', timeSeriesLength);
+console.log('Dominant frequency bins:', peaks.slice(0, 3).map(p => p.bin));
+
+// ============================================================================
+// 7. PERFORMANCE SUMMARY
+// ============================================================================
+
+console.log('\n--- Performance Summary ---');
+
+// Benchmark key operations
+const benchSize = 10000;
+const benchVec1 = new Float64Array(benchSize);
+const benchVec2 = new Float64Array(benchSize);
+const benchResult = new Float64Array(benchSize);
+
+for (let i = 0; i < benchSize; i++) {
+  benchVec1[i] = Math.random();
+  benchVec2[i] = Math.random();
+}
+
+console.time('Vector addition (10k elements)');
+for (let i = 0; i < 100; i++) {
+  accelerate.vadd(benchVec1, benchVec2, benchResult);
+}
+console.timeEnd('Vector addition (10k elements)');
+
+console.time('Dot product (10k elements)');
+for (let i = 0; i < 100; i++) {
+  accelerate.dot(benchVec1, benchVec2);
+}
+console.timeEnd('Dot product (10k elements)');
+
+console.time('Statistical operations (10k elements)');
+for (let i = 0; i < 100; i++) {
+  accelerate.mean(benchVec1);
+  accelerate.stddev(benchVec1);
+  accelerate.minmax(benchVec1);
+}
+console.timeEnd('Statistical operations (10k elements)');
+
+console.log('\n✓ ML Pipeline Complete!');

package/examples/signal-processing-advanced.js

@@ -0,0 +1,98 @@
+/**
+ * Advanced Signal Processing Examples
+ * Demonstrates convolution, correlation, windowing, and FFT/IFFT
+ */
+
+const accelerate = require('..');
+
+console.log('=== Advanced Signal Processing ===\n');
+
+// 1. Convolution Example
+console.log('--- Convolution ---');
+const signal = new Float64Array([1, 2, 3, 4, 5, 6, 7, 8]);
+const kernel = new Float64Array([0.25, 0.5, 0.25]); // Moving average
+const convResult = new Float64Array(signal.length - kernel.length + 1);
+
+accelerate.conv(signal, kernel, convResult);
+console.log('Signal:', Array.from(signal));
+console.log('Kernel (moving avg):', Array.from(kernel));
+console.log('Convolution result:', Array.from(convResult).map(x => x.toFixed(2)));
+
+// 2. Cross-correlation Example
+console.log('\n--- Cross-Correlation ---');
+const sig1 = new Float64Array(100);
+const sig2 = new Float64Array(100);
+
+// Create two similar signals with a delay
+for (let i = 0; i < 100; i++) {
+  sig1[i] = Math.sin(2 * Math.PI * i / 20);
+  sig2[i] = i >= 10 ? Math.sin(2 * Math.PI * (i - 10) / 20) : 0;
+}
+
+const xcorrResult = new Float64Array(sig1.length + sig2.length - 1);
+accelerate.xcorr(sig1, sig2, xcorrResult);
+
+// Find peak (indicates delay)
+const peakIdx = xcorrResult.indexOf(accelerate.max(xcorrResult));
+console.log('Detected delay:', Math.abs(peakIdx - sig1.length + 1), 'samples');
+
+// 3. Window Functions
+console.log('\n--- Window Functions ---');
+const windowSize = 64;
+
+const hammingWin = accelerate.hamming(windowSize);
+const hanningWin = accelerate.hanning(windowSize);
+const blackmanWin = accelerate.blackman(windowSize);
+
+console.log('Hamming window center value:', hammingWin[windowSize/2].toFixed(4));
+console.log('Hanning window center value:', hanningWin[windowSize/2].toFixed(4));
+console.log('Blackman window center value:', blackmanWin[windowSize/2].toFixed(4));
+
+// 4. FFT and IFFT Round-trip
+console.log('\n--- FFT/IFFT Round-trip ---');
+const fftSize = 256;
+const testSignal = new Float64Array(fftSize);
+
+// Create test signal: sum of two sine waves
+for (let i = 0; i < fftSize; i++) {
+  testSignal[i] = Math.sin(2 * Math.PI * 5 * i / fftSize) + 
+                  0.5 * Math.sin(2 * Math.PI * 10 * i / fftSize);
+}
+
+// Forward FFT
+const spectrum = accelerate.fft(testSignal);
+console.log('FFT output size:', spectrum.real.length, 'bins');
+
+// Find dominant frequencies
+const magnitudes = new Float64Array(spectrum.real.length);
+for (let i = 0; i < magnitudes.length; i++) {
+  magnitudes[i] = Math.sqrt(spectrum.real[i]**2 + spectrum.imag[i]**2);
+}
+
+const peak1 = magnitudes.indexOf(accelerate.max(magnitudes));
+console.log('Dominant frequency bin:', peak1);
+
+// Inverse FFT
+const reconstructed = accelerate.ifft(spectrum.real, spectrum.imag);
+
+// Check reconstruction error
+let maxError = 0;
+for (let i = 0; i < fftSize; i++) {
+  const error = Math.abs(testSignal[i] - reconstructed[i]);
+  if (error > maxError) maxError = error;
+}
+
+console.log('Max reconstruction error:', maxError.toFixed(10));
+console.log('Reconstruction successful:', maxError < 1e-10 ? 'YES' : 'NO');
+
+// 5. Windowed FFT (for spectral analysis)
+console.log('\n--- Windowed FFT ---');
+const windowedSignal = new Float64Array(fftSize);
+const window = accelerate.hanning(fftSize);
+
+accelerate.vmul(testSignal, window, windowedSignal);
+const windowedSpectrum = accelerate.fft(windowedSignal);
+
+console.log('Windowed FFT reduces spectral leakage');
+console.log('Original signal energy:', accelerate.sumOfSquares(testSignal).toFixed(2));
+console.log('Windowed signal energy:', accelerate.sumOfSquares(windowedSignal).toFixed(2));

package/examples/statistical-operations.js

@@ -0,0 +1,44 @@
+/**
+ * Statistical Operations Examples
+ * Demonstrates statistical functions using Apple Accelerate
+ */
+
+const accelerate = require('..');
+
+console.log('=== Statistical Operations ===\n');
+
+// Create sample data
+const data = new Float64Array(1000);
+for (let i = 0; i < data.length; i++) {
+  data[i] = Math.random() * 100;
+}
+
+console.log('Sample size:', data.length);
+
+// Basic statistics
+console.log('\n--- Basic Statistics ---');
+console.log('Mean:', accelerate.mean(data).toFixed(2));
+console.log('Variance:', accelerate.variance(data).toFixed(2));
+console.log('Standard Deviation:', accelerate.stddev(data).toFixed(2));
+console.log('RMS:', accelerate.rms(data).toFixed(2));
+
+// Min/Max
+const { min, max } = accelerate.minmax(data);
+console.log('\n--- Range ---');
+console.log('Min:', min.toFixed(2));
+console.log('Max:', max.toFixed(2));
+console.log('Range:', (max - min).toFixed(2));
+
+// Magnitude statistics
+console.log('\n--- Magnitude Statistics ---');
+console.log('Sum:', accelerate.sum(data).toFixed(2));
+console.log('Sum of Squares:', accelerate.sumOfSquares(data).toFixed(2));
+console.log('Mean Magnitude:', accelerate.meanMagnitude(data).toFixed(2));
+console.log('Mean Square:', accelerate.meanSquare(data).toFixed(2));
+
+// Normalized data
+const normalized = new Float64Array(data.length);
+accelerate.normalize(data, normalized);
+console.log('\n--- Normalized Data ---');
+console.log('Normalized mean:', accelerate.mean(normalized).toFixed(6));
+console.log('Normalized magnitude:', Math.sqrt(accelerate.sumOfSquares(normalized)).toFixed(6));