Struct PerronSolver 

pub struct PerronSolver {
    pub tol: f64,
    pub max_iter: usize,
    pub shift_margin: f64,
}

Power-iteration solver for the principal eigenpair of a symmetric operator.

Fields

tol: f64

Convergence tolerance on the L2 distance between consecutive iterates.

max_iter: usize

Maximum number of power iterations.

shift_margin: f64

Extra shift added to the Gershgorin lower bound. A positive margin guarantees a strictly positive definite shifted operator.

Implementations

impl PerronSolver

pub fn new() -> Self

Creates a solver with default settings.

Examples

use solver::numeric::ergodic::PerronSolver;
let solver = PerronSolver::new();
assert_eq!(solver.tol, 1e-10);

pub fn with_tol(self, tol: f64) -> Self

Selects the power-iteration convergence tolerance.

Panics

Panics if tol is not positive.

Examples

use solver::numeric::ergodic::PerronSolver;
let solver = PerronSolver::new().with_tol(1e-12);
assert_eq!(solver.tol, 1e-12);

pub fn with_max_iter(self, max_iter: usize) -> Self

Selects the maximum number of power iterations.

Panics

Panics if max_iter is zero.

Examples

use solver::numeric::ergodic::PerronSolver;
let solver = PerronSolver::new().with_max_iter(500);
assert_eq!(solver.max_iter, 500);

pub fn with_shift_margin(self, shift_margin: f64) -> Self

Selects the shift margin added to the Gershgorin lower bound.

Panics

Panics if shift_margin is not positive.

Examples

use solver::numeric::ergodic::PerronSolver;
let solver = PerronSolver::new().with_shift_margin(0.5);
assert_eq!(solver.shift_margin, 0.5);

pub fn solve<const N: usize, P: StationaryEigenProblem<N>>( &self, grid: &Grid<N>, problem: &P, ) -> PerronSolution

Solves for the principal eigenpair of problem on grid.

Power iteration is applied to A + shift * I, where A is the operator and shift is chosen from the Gershgorin lower bound so that the shifted operator is positive definite. Shifting preserves eigenvectors and moves every eigenvalue by the same constant, so the returned eigenvalue subtracts the shift.

Panics

Panics if problem.operator(grid) has a different size from the grid.

Examples

use solver::core::grid::Grid;
use solver::linalg::csr::CsrMatrix;
use solver::numeric::ergodic::{PerronSolver, StationaryEigenProblem};

struct Single;
impl StationaryEigenProblem<1> for Single {
    fn operator(&self, _grid: &Grid<1>) -> CsrMatrix {
        let mut mat = CsrMatrix::new(1, 1);
        mat.add_entry(0, 5.0);
        mat.finish_row();
        mat
    }
}

let grid = Grid::<1>::new([1], [0.0], [0.0]);
let solution = PerronSolver::new().solve(&grid, &Single);
assert!((solution.eigenvalue - 5.0).abs() < 1e-12);

Trait Implementations

impl Clone for PerronSolver

fn clone(&self) -> PerronSolver

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for PerronSolver

impl Debug for PerronSolver

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PerronSolver

fn default() -> Self

Returns the “default value” for a type.