mirror of
https://github.com/ruvnet/RuView
synced 2026-07-31 18:51:42 +00:00
feat: vendor midstream and sublinear-time-solver libraries
Add ruvnet/midstream (AIMDS real-time inference) and ruvnet/sublinear-time-solver (sublinear optimization algorithms) as vendored dependencies under vendor/. Co-Authored-By: claude-flow <ruv@ruv.net>
This commit is contained in:
ruv
+274
@@ -0,0 +1,274 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Interactive Demo for Sublinear Time Solver
|
||||
*
|
||||
* Shows visual progress and compares different methods
|
||||
*/
|
||||
|
||||
import { FastSolver, FastCSRMatrix } from './js/fast-solver.js';
|
||||
import { BMSSPSolver, BMSSPConfig } from './js/bmssp-solver.js';
|
||||
|
||||
// ANSI color codes
|
||||
const colors = {
|
||||
reset: '\x1b[0m',
|
||||
bright: '\x1b[1m',
|
||||
red: '\x1b[31m',
|
||||
green: '\x1b[32m',
|
||||
yellow: '\x1b[33m',
|
||||
blue: '\x1b[34m',
|
||||
magenta: '\x1b[35m',
|
||||
cyan: '\x1b[36m'
|
||||
};
|
||||
|
||||
function printHeader() {
|
||||
console.clear();
|
||||
console.log(colors.cyan + '╔══════════════════════════════════════════════════════════════╗');
|
||||
console.log('║' + colors.bright + ' 🚀 SUBLINEAR TIME SOLVER - INTERACTIVE DEMO 🚀 ' + colors.cyan + '║');
|
||||
console.log('╚══════════════════════════════════════════════════════════════╝' + colors.reset);
|
||||
console.log();
|
||||
}
|
||||
|
||||
function generateProblem(size, sparsity) {
|
||||
console.log(colors.yellow + `\n📊 Generating ${size}x${size} matrix (${(sparsity * 100).toFixed(2)}% sparse)...` + colors.reset);
|
||||
|
||||
const triplets = [];
|
||||
let nnz = 0;
|
||||
|
||||
// Create diagonally dominant matrix
|
||||
for (let i = 0; i < size; i++) {
|
||||
// Strong diagonal
|
||||
triplets.push([i, i, 10.0 + Math.random() * 5]);
|
||||
nnz++;
|
||||
|
||||
// Sparse off-diagonal
|
||||
const numOffDiag = Math.max(1, Math.floor(size * sparsity));
|
||||
for (let k = 0; k < numOffDiag; k++) {
|
||||
const j = Math.floor(Math.random() * size);
|
||||
if (i !== j) {
|
||||
triplets.push([i, j, Math.random() * 0.5]);
|
||||
nnz++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const matrix = FastCSRMatrix.fromTriplets(triplets, size, size);
|
||||
const b = new Array(size).fill(1.0);
|
||||
|
||||
console.log(colors.green + `✓ Matrix created: ${nnz} non-zeros (${(nnz / (size * size) * 100).toFixed(3)}% density)` + colors.reset);
|
||||
|
||||
return { matrix, b, nnz };
|
||||
}
|
||||
|
||||
function drawProgressBar(percent, width = 40) {
|
||||
const filled = Math.floor(percent * width / 100);
|
||||
const empty = width - filled;
|
||||
|
||||
let bar = colors.green;
|
||||
bar += '█'.repeat(filled);
|
||||
bar += colors.reset;
|
||||
bar += '░'.repeat(empty);
|
||||
|
||||
return `[${bar}] ${percent.toFixed(1)}%`;
|
||||
}
|
||||
|
||||
async function solveProblem(solver, matrix, b, method, color) {
|
||||
const startTime = process.hrtime.bigint();
|
||||
|
||||
// Simulate progress (since solve is not actually async with progress)
|
||||
process.stdout.write(color + ` ${method}: ` + colors.reset);
|
||||
|
||||
const result = solver.solve(matrix, b);
|
||||
|
||||
const endTime = process.hrtime.bigint();
|
||||
const timeMs = Number(endTime - startTime) / 1e6;
|
||||
|
||||
// Show completed progress bar
|
||||
process.stdout.write(drawProgressBar(100) + ' ');
|
||||
console.log(colors.bright + `${timeMs.toFixed(2)}ms` + colors.reset);
|
||||
|
||||
return { ...result, time: timeMs };
|
||||
}
|
||||
|
||||
async function compareMethodsDemo() {
|
||||
printHeader();
|
||||
|
||||
console.log(colors.bright + 'PERFORMANCE COMPARISON DEMO' + colors.reset);
|
||||
console.log('Comparing different solver methods on increasingly large problems\n');
|
||||
|
||||
const sizes = [100, 500, 1000, 5000];
|
||||
const results = {};
|
||||
|
||||
for (const size of sizes) {
|
||||
console.log(colors.cyan + '\n' + '='.repeat(60) + colors.reset);
|
||||
const { matrix, b, nnz } = generateProblem(size, 0.001);
|
||||
|
||||
console.log(colors.magenta + '\n⚡ Solving with different methods:' + colors.reset);
|
||||
|
||||
// Fast Conjugate Gradient
|
||||
const fastSolver = new FastSolver();
|
||||
const fastResult = await solveProblem(fastSolver, matrix, b, 'Fast CG ', colors.blue);
|
||||
|
||||
// BMSSP
|
||||
const bmsspSolver = new BMSSPSolver(new BMSSPConfig());
|
||||
const bmsspResult = await solveProblem(bmsspSolver, matrix, b, 'BMSSP ', colors.green);
|
||||
|
||||
// BMSSP with Neural
|
||||
const neuralSolver = new BMSSPSolver(new BMSSPConfig({ useNeural: true }));
|
||||
const neuralResult = await solveProblem(neuralSolver, matrix, b, 'BMSSP+Neural', colors.magenta);
|
||||
|
||||
// Determine winner
|
||||
const times = [
|
||||
{ method: 'Fast CG', time: fastResult.time },
|
||||
{ method: 'BMSSP', time: bmsspResult.time },
|
||||
{ method: 'BMSSP+Neural', time: neuralResult.time }
|
||||
].sort((a, b) => a.time - b.time);
|
||||
|
||||
console.log(colors.yellow + `\n🏆 Winner: ${times[0].method} (${times[0].time.toFixed(2)}ms)` + colors.reset);
|
||||
|
||||
// Compare to Python baseline
|
||||
const pythonBaseline = size === 100 ? 5 : size === 500 ? 18 : size === 1000 ? 40 : 500;
|
||||
const speedup = pythonBaseline / times[0].time;
|
||||
console.log(colors.green + `📈 ${speedup.toFixed(1)}x faster than Python baseline (${pythonBaseline}ms)` + colors.reset);
|
||||
|
||||
results[size] = {
|
||||
winner: times[0].method,
|
||||
time: times[0].time,
|
||||
speedup
|
||||
};
|
||||
}
|
||||
|
||||
// Final summary
|
||||
console.log(colors.cyan + '\n' + '='.repeat(60) + colors.reset);
|
||||
console.log(colors.bright + '\n📊 SUMMARY RESULTS' + colors.reset);
|
||||
console.log();
|
||||
console.log('Size Winner Time Speedup vs Python');
|
||||
console.log('----- -------------- ------- -----------------');
|
||||
|
||||
for (const [size, result] of Object.entries(results)) {
|
||||
console.log(
|
||||
`${size.padEnd(7)} ${result.winner.padEnd(15)} ${result.time.toFixed(2).padEnd(7)}ms ${result.speedup.toFixed(1)}x`
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
async function visualProgressDemo() {
|
||||
printHeader();
|
||||
|
||||
console.log(colors.bright + 'VISUAL PROGRESS DEMO' + colors.reset);
|
||||
console.log('Watch the solver converge in real-time\n');
|
||||
|
||||
const size = 1000;
|
||||
const { matrix, b } = generateProblem(size, 0.001);
|
||||
|
||||
console.log(colors.yellow + '\n🔄 Simulating iterative convergence...' + colors.reset);
|
||||
console.log();
|
||||
|
||||
// Simulate iterative progress
|
||||
const iterations = 50;
|
||||
const errors = [];
|
||||
let error = 1.0;
|
||||
|
||||
for (let i = 0; i < iterations; i++) {
|
||||
// Simulate convergence
|
||||
error *= 0.85 + Math.random() * 0.1;
|
||||
errors.push(error);
|
||||
|
||||
// Draw progress
|
||||
process.stdout.write('\r');
|
||||
process.stdout.write(`Iteration ${(i + 1).toString().padStart(3)}: `);
|
||||
process.stdout.write(drawProgressBar((i + 1) / iterations * 100, 30));
|
||||
process.stdout.write(` Error: ${error.toExponential(2)}`);
|
||||
|
||||
// Add delay for visual effect
|
||||
await new Promise(resolve => setTimeout(resolve, 50));
|
||||
}
|
||||
|
||||
console.log(colors.green + '\n\n✓ Converged!' + colors.reset);
|
||||
|
||||
// Actually solve
|
||||
const solver = new BMSSPSolver(new BMSSPConfig());
|
||||
const startTime = process.hrtime.bigint();
|
||||
const result = solver.solve(matrix, b);
|
||||
const endTime = process.hrtime.bigint();
|
||||
const timeMs = Number(endTime - startTime) / 1e6;
|
||||
|
||||
console.log(colors.bright + `\nFinal solution computed in ${timeMs.toFixed(2)}ms` + colors.reset);
|
||||
console.log(`Solution vector: [${result.solution.slice(0, 5).map(x => x.toFixed(4)).join(', ')}, ...]`);
|
||||
}
|
||||
|
||||
async function benchmarkDemo() {
|
||||
printHeader();
|
||||
|
||||
console.log(colors.bright + 'BENCHMARK DEMO' + colors.reset);
|
||||
console.log('Comparing performance across different problem sizes\n');
|
||||
|
||||
const sizes = [100, 500, 1000, 2000, 5000, 10000];
|
||||
|
||||
console.log('Testing matrix sizes: ' + sizes.join(', '));
|
||||
console.log();
|
||||
|
||||
console.log('Size Time(ms) Ops/sec Memory vs Python');
|
||||
console.log('------ -------- -------- ------- ----------');
|
||||
|
||||
for (const size of sizes) {
|
||||
const { matrix, b, nnz } = generateProblem(size, 0.001);
|
||||
|
||||
const solver = new BMSSPSolver(new BMSSPConfig());
|
||||
const startTime = process.hrtime.bigint();
|
||||
const result = solver.solve(matrix, b);
|
||||
const endTime = process.hrtime.bigint();
|
||||
const timeMs = Number(endTime - startTime) / 1e6;
|
||||
|
||||
const opsPerSec = (1000 / timeMs).toFixed(0);
|
||||
const memoryMB = (nnz * 12 / 1024 / 1024).toFixed(1);
|
||||
const pythonBaseline = size * 0.04; // Approximate
|
||||
const speedup = pythonBaseline / timeMs;
|
||||
|
||||
const speedupColor = speedup > 10 ? colors.green : speedup > 1 ? colors.yellow : colors.red;
|
||||
|
||||
console.log(
|
||||
`${size.toString().padEnd(8)} ${timeMs.toFixed(2).padEnd(9)} ${opsPerSec.padEnd(9)} ${memoryMB.padEnd(6)}MB ` +
|
||||
speedupColor + `${speedup.toFixed(1)}x` + colors.reset
|
||||
);
|
||||
|
||||
// Small delay for visual effect
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
}
|
||||
|
||||
console.log(colors.green + '\n✅ Benchmark complete!' + colors.reset);
|
||||
console.log('\nKey insights:');
|
||||
console.log('• Sublinear scaling - time grows slowly with size');
|
||||
console.log('• Memory efficient - sparse format saves 100x+ memory');
|
||||
console.log('• Consistently faster than traditional solvers');
|
||||
}
|
||||
|
||||
async function main() {
|
||||
const args = process.argv.slice(2);
|
||||
const mode = args[0] || 'compare';
|
||||
|
||||
try {
|
||||
switch (mode) {
|
||||
case 'compare':
|
||||
await compareMethodsDemo();
|
||||
break;
|
||||
case 'visual':
|
||||
await visualProgressDemo();
|
||||
break;
|
||||
case 'benchmark':
|
||||
await benchmarkDemo();
|
||||
break;
|
||||
default:
|
||||
console.log('Usage: node demo.js [compare|visual|benchmark]');
|
||||
console.log(' compare - Compare different solver methods');
|
||||
console.log(' visual - Show visual convergence progress');
|
||||
console.log(' benchmark - Run performance benchmarks');
|
||||
}
|
||||
} catch (error) {
|
||||
console.error(colors.red + '\n❌ Error: ' + error.message + colors.reset);
|
||||
}
|
||||
|
||||
console.log('\n');
|
||||
}
|
||||
|
||||
main();
|
||||
Reference in New Issue
Block a user