Struct SuperLuDistSolver 

pub struct SuperLuDistSolver { /* private fields */ }

Available on crate feature superlu_dist only.

SuperLU_DIST distributed direct solver

Implementations

impl SuperLuDistSolver

pub fn new() -> Self

Create a new SuperLU_DIST solver with default options

pub fn with_options(options: SuperLuDistOptions) -> Self

Create a new SuperLU_DIST solver with custom options

pub fn set_diagonal_pivot_threshold(&mut self, threshold: f64) -> &mut Self

Set the diagonal pivot threshold

pub fn set_column_permutation(&mut self, perm: ColumnPermutation) -> &mut Self

Set the column permutation strategy

pub fn set_iterative_refinement( &mut self, refine: IterativeRefinement, ) -> &mut Self

Set the iterative refinement strategy

pub fn set_print_level(&mut self, level: u8) -> &mut Self

Set the print level for diagnostics

pub fn set_panel_size(&mut self, size: usize) -> &mut Self

Set the panel size for local dense factorization

pub fn set_3d_factorization( &mut self, enable: bool, depth: Option<usize>, ) -> &mut Self

Enable 3D communication-avoiding factorization

pub fn set_memory_tradeoff(&mut self, factor: f64) -> &mut Self

Set memory trade-off factor for 3D algorithm

pub fn set_max_concurrent_panels(&mut self, max_panels: usize) -> &mut Self

Set maximum concurrent panels

pub fn set_async_panel_updates(&mut self, enable: bool) -> &mut Self

Enable asynchronous panel updates

pub fn set_static_pivoting(&mut self, enable: bool) -> &mut Self

Set static pivoting mode

pub fn set_row_permutation(&mut self, perm: RowPermutation) -> &mut Self

Set the row permutation strategy

pub fn set_replace_tiny_pivots(&mut self, enable: bool) -> &mut Self

Set whether to replace tiny pivots

pub fn set_process_grid(&mut self, rows: usize, cols: usize) -> &mut Self

Set the process grid dimensions

pub fn set_process_grid_auto(&mut self) -> &mut Self

Use automatic process grid determination

pub fn with_complete_options(self, options: SuperLuDistOptions) -> Self

Configure a complete set of options via SuperLuDistOptions

pub fn builder() -> SuperLuDistBuilder

Create a new solver with fluent configuration

pub fn options(&self) -> &SuperLuDistOptions

Get a reference to the current options

pub fn enable_iterative_refinement(&mut self) -> &mut Self

Enable iterative refinement with default configuration

pub fn set_refinement_config(&mut self, config: RefinementConfig) -> &mut Self

Configure iterative refinement with custom settings

pub fn set_residual_method(&mut self, method: ResidualMethod) -> &mut Self

Set the residual computation method for iterative refinement

pub fn disable_iterative_refinement(&mut self) -> &mut Self

Disable iterative refinement

pub fn refinement_stats(&self) -> Option<&RefinementStats>

Get refinement statistics from the last solve (if available)

pub fn set_workspace_memory_limit(&mut self, limit_mb: usize) -> &mut Self

Configure workspace memory settings

pub fn set_aggressive_memory_reuse(&mut self, enable: bool) -> &mut Self

Enable aggressive memory reuse for better performance

pub fn set_preallocation_strategy( &mut self, strategy: PreallocationStrategy, ) -> &mut Self

Set workspace preallocation strategy

pub fn workspace_memory_stats(&self) -> Option<WorkspaceMemoryStats>

Get workspace memory statistics (if workspace is set up)

pub fn optimize_workspace(&mut self) -> Result<(), KError>

Optimize workspace memory usage

pub fn clear_workspace_temp_data(&mut self) -> Result<(), KError>

Clear workspace temporary data to free memory

pub fn workspace_needs_cleanup(&self) -> bool

Check if workspace needs cleanup due to memory pressure

pub fn destroy(&mut self)

Destroy the factorization and free memory

pub fn clear_factors(&mut self)

pub fn has_factors(&self) -> bool

Trait Implementations

impl Default for SuperLuDistSolver

fn default() -> Self

Returns the “default value” for a type.

impl LinearSolver<CsrMatrix<f64>, Vec<f64>> for SuperLuDistSolver

type Error = KError

type Scalar = f64

fn solve( &mut self, a: &CsrMatrix<f64>, pc: Option<&(dyn Preconditioner<CsrMatrix<f64>, Vec<f64>> + '_)>, b: &Vec<f64>, x: &mut Vec<f64>, pc_side: PcSide, comm: &UniverseComm, monitors: Option<&[Box<MonitorCallback<Self::Scalar>>]>, _work: Option<&mut Workspace>, ) -> Result<SolveStats<f64>, KError>

fn setup_workspace(&mut self, _work: &mut Workspace)

fn solve_simple( &mut self, a: &M, pc: Option<&(dyn Preconditioner<M, V> + '_)>, b: &V, x: &mut V, pc_side: PcSide, comm: &UniverseComm, ) -> Result<SolveStats<Self::Scalar>, Self::Error>

where Self: Sized,

fn solve_with_monitors( &mut self, a: &M, pc: Option<&(dyn Preconditioner<M, V> + '_)>, b: &V, x: &mut V, pc_side: PcSide, comm: &UniverseComm, monitors: &[Box<MonitorCallback<Self::Scalar>>], ) -> Result<SolveStats<Self::Scalar>, Self::Error>

where Self: Sized,

fn solve_with_workspace( &mut self, a: &M, pc: Option<&(dyn Preconditioner<M, V> + '_)>, b: &V, x: &mut V, pc_side: PcSide, comm: &UniverseComm, work: &mut Workspace, ) -> Result<SolveStats<Self::Scalar>, Self::Error>

where Self: Sized,

impl Solver<CsrMatrix<f64>> for SuperLuDistSolver

type Error = KError

fn setup( &mut self, a: &CsrMatrix<f64>, comm: &UniverseComm, ) -> Result<(), Self::Error>

fn factor(&mut self, a: &CsrMatrix<f64>) -> Result<(), Self::Error>

fn solve( &mut self, b: &[f64], x: &mut [f64], comm: &UniverseComm, ) -> Result<SolveStats<f64>, Self::Error>

fn reuse_factorization(&self) -> bool