@digitaldefiance/node-accelerate 1.0.6 → 2.0.0

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/signal-processing.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * Example: Signal Processing with FFT
+ * Demonstrates frequency analysis of audio signals
+ */
+
+const accelerate = require('../index');
+
+console.log('Signal Processing Example');
+console.log('='.repeat(50));
+console.log('');
+
+// Create a composite signal: 440 Hz (A4) + 880 Hz (A5)
+const sampleRate = 44100; // CD quality
+const duration = 1; // 1 second
+const fftSize = 16384; // Must be power of 2
+
+console.log(`Sample rate: ${sampleRate} Hz`);
+console.log(`FFT size: ${fftSize}`);
+console.log(`Frequency resolution: ${(sampleRate / fftSize).toFixed(2)} Hz`);
+console.log('');
+
+// Generate signal
+console.log('Generating signal (440 Hz + 880 Hz)...');
+const signal = new Float64Array(fftSize);
+for (let i = 0; i < fftSize; i++) {
+  const t = i / sampleRate;
+  signal[i] = 
+    Math.sin(2 * Math.PI * 440 * t) +  // A4
+    Math.sin(2 * Math.PI * 880 * t);   // A5
+}
+
+// Perform FFT
+console.log('Performing FFT...');
+const start = process.hrtime.bigint();
+const spectrum = accelerate.fft(signal);
+const end = process.hrtime.bigint();
+
+const timeMs = Number(end - start) / 1e6;
+console.log(`✓ Completed in ${timeMs.toFixed(3)}ms`);
+console.log('');
+
+// Calculate magnitudes
+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
+console.log('Finding frequency peaks...');
+const peaks = [];
+const threshold = Math.max(...magnitudes) * 0.5;
+
+for (let i = 1; i < magnitudes.length - 1; i++) {
+  if (magnitudes[i] > threshold &&
+      magnitudes[i] > magnitudes[i - 1] &&
+      magnitudes[i] > magnitudes[i + 1]) {
+    const frequency = i * sampleRate / fftSize;
+    peaks.push({ frequency, magnitude: magnitudes[i] });
+  }
+}
+
+peaks.sort((a, b) => b.magnitude - a.magnitude);
+
+console.log('Top frequency components:');
+peaks.slice(0, 5).forEach((peak, i) => {
+  console.log(`  ${i + 1}. ${peak.frequency.toFixed(1)} Hz (magnitude: ${peak.magnitude.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));

package/examples/trigonometric-functions.js

@@ -0,0 +1,52 @@
+/**
+ * Trigonometric Functions Examples
+ * Demonstrates vectorized trig operations using Apple Accelerate
+ */
+
+const accelerate = require('..');
+
+console.log('=== Trigonometric Functions ===\n');
+
+// Create angle array (0 to 2π)
+const n = 1000;
+const angles = new Float64Array(n);
+for (let i = 0; i < n; i++) {
+  angles[i] = (i / n) * 2 * Math.PI;
+}
+
+// Compute sin, cos, tan
+const sinValues = new Float64Array(n);
+const cosValues = new Float64Array(n);
+const tanValues = new Float64Array(n);
+
+console.time('Vectorized trig operations');
+accelerate.vsin(angles, sinValues);
+accelerate.vcos(angles, cosValues);
+accelerate.vtan(angles, tanValues);
+console.timeEnd('Vectorized trig operations');
+
+// Verify with known values
+console.log('\n--- Verification at key angles ---');
+const testIndices = [0, n/4, n/2, 3*n/4];
+const testAngles = ['0', 'π/2', 'π', '3π/2'];
+
+for (let i = 0; i < testIndices.length; i++) {
+  const idx = Math.floor(testIndices[i]);
+  console.log(`\nAngle: ${testAngles[i]}`);
+  console.log(`  sin: ${sinValues[idx].toFixed(4)}`);
+  console.log(`  cos: ${cosValues[idx].toFixed(4)}`);
+}
+
+// Compute sin²(x) + cos²(x) = 1 (identity check)
+const sinSquared = new Float64Array(n);
+const cosSquared = new Float64Array(n);
+const identity = new Float64Array(n);
+
+accelerate.vsquare(sinValues, sinSquared);
+accelerate.vsquare(cosValues, cosSquared);
+accelerate.vadd(sinSquared, cosSquared, identity);
+
+console.log('\n--- Pythagorean Identity Check ---');
+console.log('sin²(x) + cos²(x) should equal 1.0');
+console.log('Mean value:', accelerate.mean(identity).toFixed(10));
+console.log('Max deviation:', Math.abs(1.0 - accelerate.max(identity)).toFixed(10));

package/examples/vector-operations.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Example: Vector Operations
+ * Demonstrates hardware-accelerated vector math
+ */
+
+const accelerate = require('../index');
+
+console.log('Vector Operations Example');
+console.log('='.repeat(50));
+console.log('');
+
+// Create large vectors
+const size = 1000000;
+console.log(`Vector size: ${size.toLocaleString()} elements`);
+console.log('');
+
+const a = new Float64Array(size);
+const b = new Float64Array(size);
+const result = new Float64Array(size);
+
+// Fill with random data
+for (let i = 0; i < size; i++) {
+  a[i] = Math.random() * 100;
+  b[i] = Math.random() * 100;
+}
+
+// Dot product
+console.log('Computing dot product...');
+let start = process.hrtime.bigint();
+const dotProduct = accelerate.dot(a, b);
+let end = process.hrtime.bigint();
+console.log(`  Result: ${dotProduct.toFixed(2)}`);
+console.log(`  Time: ${(Number(end - start) / 1e6).toFixed(3)}ms`);
+console.log('');
+
+// Sum
+console.log('Computing sum...');
+start = process.hrtime.bigint();
+const sum = accelerate.sum(a);
+end = process.hrtime.bigint();
+console.log(`  Result: ${sum.toFixed(2)}`);
+console.log(`  Time: ${(Number(end - start) / 1e6).toFixed(3)}ms`);
+console.log('');
+
+// Mean
+console.log('Computing mean...');
+start = process.hrtime.bigint();
+const mean = accelerate.mean(a);
+end = process.hrtime.bigint();
+console.log(`  Result: ${mean.toFixed(2)}`);
+console.log(`  Time: ${(Number(end - start) / 1e6).toFixed(3)}ms`);
+console.log('');
+
+// Vector addition
+console.log('Computing vector addition...');
+start = process.hrtime.bigint();
+accelerate.vadd(a, b, result);
+end = process.hrtime.bigint();
+console.log(`  Sample: ${a[0].toFixed(2)} + ${b[0].toFixed(2)} = ${result[0].toFixed(2)}`);
+console.log(`  Time: ${(Number(end - start) / 1e6).toFixed(3)}ms`);
+console.log('');
+
+// Vector multiplication
+console.log('Computing vector multiplication...');
+start = process.hrtime.bigint();
+accelerate.vmul(a, b, result);
+end = process.hrtime.bigint();
+console.log(`  Sample: ${a[0].toFixed(2)} × ${b[0].toFixed(2)} = ${result[0].toFixed(2)}`);
+console.log(`  Time: ${(Number(end - start) / 1e6).toFixed(3)}ms`);
+console.log('');
+
+console.log('✓ All operations completed successfully!');