Struct NapiSolver

Source

pub struct NapiSolver { /* private fields */ }

Expand description

High-performance sparse linear solver with automatic algorithm selection.

Provides async methods for solving Ax = b, computing PageRank, and estimating computational complexity. All heavy computation runs on worker threads.

§Example

const { NapiSolver } = require('@ruvector/solver');

const solver = new NapiSolver();
const result = await solver.solve({
  values: [4, -1, -1, 4, -1, -1, 4],
  colIndices: [0, 1, 0, 1, 2, 1, 2],
  rowPtrs: [0, 2, 5, 7],
  rows: 3, cols: 3,
  rhs: [1, 0, 1],
});
console.log('Solution:', result.solution);
console.log('Converged:', result.converged);

Implementations§

Source §

pub fn into_reference( val: NapiSolver, env: Env, ) -> Result<Reference<NapiSolver>>

Source

pub fn into_instance(self, env: Env) -> Result<ClassInstance<NapiSolver>>

Source §

impl NapiSolver

Source

pub fn new() -> Self

Create a new solver instance with default settings.

Source

pub async fn solve(&self, config: SolveConfig) -> Result<SolveResult>

Solve a sparse linear system Ax = b asynchronously.

Runs the computation on a worker thread to avoid blocking the Node.js event loop.

§Arguments

config - Solver configuration including the CSR matrix, RHS vector, tolerance, max iterations, and algorithm selection.

§Returns

A SolveResult containing the solution vector, convergence info, and timing data.

§Example

const result = await solver.solve({
  values: [2, -1, -1, 2, -1, -1, 2],
  colIndices: [0, 1, 0, 1, 2, 1, 2],
  rowPtrs: [0, 2, 5, 7],
  rows: 3, cols: 3,
  rhs: [1, 0, 1],
  tolerance: 1e-8,
  algorithm: 'jacobi',
});

Source

pub async fn solve_json(&self, json: String) -> Result<String>

Solve a sparse linear system from JSON input.

Accepts a JSON string with the same fields as SolveConfig and returns a JSON string with the SolveResult fields.

§Example

const input = JSON.stringify({
  values: [2, -1, -1, 2],
  col_indices: [0, 1, 0, 1],
  row_ptrs: [0, 2, 4],
  rows: 2, cols: 2,
  rhs: [1, 1],
});
const output = await solver.solveJson(input);
const result = JSON.parse(output);

Source

pub async fn pagerank(&self, config: PageRankConfig) -> Result<PageRankResult>

Compute PageRank scores for a directed graph asynchronously.

Implements the power iteration method: r_{k+1} = d * A^T * D^{-1} * r_k + (1 - d) * p where d is the damping factor, D is the out-degree diagonal, and p is the personalization vector.

§Example

// Simple 3-node graph: 0->1, 1->2, 2->0
const result = await solver.pagerank({
  values: [1, 1, 1],
  colIndices: [1, 2, 0],
  rowPtrs: [0, 1, 2, 3],
  numNodes: 3,
  damping: 0.85,
});
console.log('PageRank:', result.scores);

Source

pub fn estimate_complexity( &self, config: ComplexityConfig, ) -> Result<ComplexityResult>

Estimate computational complexity for a given problem size.

This is a synchronous method since the estimation is O(1).

§Example

const estimate = solver.estimateComplexity({
  rows: 10000,
  nnz: 50000,
  algorithm: 'jacobi',
});
console.log('Complexity:', estimate.complexityClass);
console.log('Recommended:', estimate.recommendedAlgorithm);

Source

pub async fn solve_with_history( &self, config: SolveConfig, ) -> Result<SolveWithHistoryResult>

Solve with full convergence history returned.

Identical to solve but also returns per-iteration residual data for convergence analysis and visualization.

§Example

const result = await solver.solveWithHistory({
  values: [4, -1, -1, 4],
  colIndices: [0, 1, 0, 1],
  rowPtrs: [0, 2, 4],
  rows: 2, cols: 2,
  rhs: [1, 1],
});
result.convergenceHistory.forEach(entry => {
  console.log(`Iter ${entry.iteration}: residual = ${entry.residual}`);
});