@digitaldefiance/node-accelerate 1.0.6 → 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/machine-learning.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * Example: Machine Learning Operations
+ * Demonstrates using Accelerate for ML inference
+ */
+
+const accelerate = require('../index');
+
+console.log('Machine Learning Example');
+console.log('='.repeat(50));
+console.log('');
+
+// Simple neural network layer: y = activation(W*x + b)
+function denseLayer(input, weights, bias, output) {
+  const inputSize = input.length;
+  const outputSize = output.length;
+  
+  // Matrix-vector multiply: output = weights * input
+  accelerate.matvec(weights, input, output, outputSize, inputSize);
+  
+  // Add bias: output = output + bias
+  accelerate.axpy(1.0, bias, output);
+  
+  // ReLU activation: output = max(0, output)
+  const zeros = new Float64Array(outputSize);
+  for (let i = 0; i < outputSize; i++) {
+    output[i] = Math.max(0, output[i]);
+  }
+  
+  return output;
+}
+
+// Example: 2-layer network
+console.log('Building 2-layer neural network...');
+console.log('  Input: 784 (28×28 image)');
+console.log('  Hidden: 128');
+console.log('  Output: 10 (digits 0-9)');
+console.log('');
+
+// Layer 1: 784 → 128
+const input = new Float64Array(784);
+for (let i = 0; i < input.length; i++) {
+  input[i] = Math.random();
+}
+
+const weights1 = new Float64Array(128 * 784);
+const bias1 = new Float64Array(128);
+const hidden = new Float64Array(128);
+
+for (let i = 0; i < weights1.length; i++) weights1[i] = Math.random() - 0.5;
+for (let i = 0; i < bias1.length; i++) bias1[i] = Math.random() - 0.5;
+
+console.log('Layer 1: Forward pass...');
+let start = process.hrtime.bigint();
+denseLayer(input, weights1, bias1, hidden);
+let end = process.hrtime.bigint();
+console.log(`  Time: ${(Number(end - start) / 1e6).toFixed(3)}ms`);
+console.log('');
+
+// Layer 2: 128 → 10
+const weights2 = new Float64Array(10 * 128);
+const bias2 = new Float64Array(10);
+const output = new Float64Array(10);
+
+for (let i = 0; i < weights2.length; i++) weights2[i] = Math.random() - 0.5;
+for (let i = 0; i < bias2.length; i++) bias2[i] = Math.random() - 0.5;
+
+console.log('Layer 2: Forward pass...');
+start = process.hrtime.bigint();
+denseLayer(hidden, weights2, bias2, output);
+end = process.hrtime.bigint();
+console.log(`  Time: ${(Number(end - start) / 1e6).toFixed(3)}ms`);
+console.log('');
+
+// Softmax (normalize to probabilities)
+console.log('Softmax activation...');
+const expOutput = new Float64Array(10);
+for (let i = 0; i < output.length; i++) {
+  expOutput[i] = Math.exp(output[i]);
+}
+const sumExp = accelerate.sum(expOutput);
+for (let i = 0; i < expOutput.length; i++) {
+  expOutput[i] /= sumExp;
+}
+
+console.log('Output probabilities:');
+for (let i = 0; i < 10; i++) {
+  console.log(`  Digit ${i}: ${(expOutput[i] * 100).toFixed(2)}%`);
+}
+console.log('');
+
+// K-means clustering example
+console.log('K-means Clustering Example');
+console.log('-'.repeat(50));
+
+const numPoints = 1000;
+const numClusters = 3;
+const dimensions = 2;
+
+// Generate random points
+const points = new Float64Array(numPoints * dimensions);
+for (let i = 0; i < points.length; i++) {
+  points[i] = Math.random() * 100;
+}
+
+// Initialize centroids
+const centroids = new Float64Array(numClusters * dimensions);
+for (let i = 0; i < numClusters; i++) {
+  const idx = Math.floor(Math.random() * numPoints);
+  centroids[i * dimensions] = points[idx * dimensions];
+  centroids[i * dimensions + 1] = points[idx * dimensions + 1];
+}
+
+console.log('Finding nearest centroids for 1000 points...');
+start = process.hrtime.bigint();
+
+const assignments = new Int32Array(numPoints);
+const point = new Float64Array(dimensions);
+const centroid = new Float64Array(dimensions);
+
+for (let i = 0; i < numPoints; i++) {
+  point[0] = points[i * dimensions];
+  point[1] = points[i * dimensions + 1];
+  
+  let minDist = Infinity;
+  let minCluster = 0;
+  
+  for (let j = 0; j < numClusters; j++) {
+    centroid[0] = centroids[j * dimensions];
+    centroid[1] = centroids[j * dimensions + 1];
+    
+    const dist = accelerate.euclidean(point, centroid);
+    if (dist < minDist) {
+      minDist = dist;
+      minCluster = j;
+    }
+  }
+  
+  assignments[i] = minCluster;
+}
+
+end = process.hrtime.bigint();
+console.log(`  Time: ${(Number(end - start) / 1e6).toFixed(3)}ms`);
+console.log('');
+
+// Count assignments
+const counts = [0, 0, 0];
+for (let i = 0; i < numPoints; i++) {
+  counts[assignments[i]]++;
+}
+
+console.log('Cluster assignments:');
+for (let i = 0; i < numClusters; i++) {
+  console.log(`  Cluster ${i}: ${counts[i]} points`);
+}
+console.log('');
+
+console.log('✓ Machine learning operations completed!');

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/matrix-multiply.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+/**
+ * Example: Matrix Multiplication
+ * Demonstrates hardware-accelerated matrix operations
+ */
+
+const accelerate = require('../index');
+
+console.log('Matrix Multiplication Example');
+console.log('='.repeat(50));
+console.log('');
+
+// Create two 1000×1000 matrices
+const M = 1000, K = 1000, N = 1000;
+console.log(`Computing C = A × B where:`);
+console.log(`  A is ${M}×${K}`);
+console.log(`  B is ${K}×${N}`);
+console.log(`  C is ${M}×${N}`);
+console.log('');
+
+const A = new Float64Array(M * K);
+const B = new Float64Array(K * N);
+const C = new Float64Array(M * N);
+
+// Fill with random data
+console.log('Filling matrices with random data...');
+for (let i = 0; i < A.length; i++) A[i] = Math.random();
+for (let i = 0; i < B.length; i++) B[i] = Math.random();
+
+// Perform matrix multiplication
+console.log('Performing matrix multiplication...');
+const start = process.hrtime.bigint();
+accelerate.matmul(A, B, C, M, K, N);
+const end = process.hrtime.bigint();
+
+const timeMs = Number(end - start) / 1e6;
+console.log(`✓ Completed in ${timeMs.toFixed(2)}ms`);
+console.log('');
+
+// Calculate GFLOPS
+const operations = 2 * M * K * N; // 2 ops per multiply-add
+const gflops = operations / (timeMs * 1e6);
+console.log(`Performance: ${gflops.toFixed(2)} GFLOPS`);
+console.log('');
+
+// Verify result (check a few elements)
+console.log('Sample results:');
+console.log(`  C[0,0] = ${C[0].toFixed(6)}`);
+console.log(`  C[0,1] = ${C[1].toFixed(6)}`);
+console.log(`  C[1,0] = ${C[N].toFixed(6)}`);