Skip to content

liblaf.peach.linalg.cupy

CuPy-backed linear solvers.

Classes:

  • CupyCG –
  • CupyMinRes –
  • CupySolver –

    Base class for linear solvers backed by CuPy sparse routines.

  • CupyState –

    State recorded by CuPy-backed linear solvers.

  • CupyStats –

    Stats placeholder for CuPy-backed linear solvers.

CupyCG

Bases: CupySolver


              flowchart TD
              liblaf.peach.linalg.cupy.CupyCG[CupyCG]
              liblaf.peach.linalg.cupy._base.CupySolver[CupySolver]
              liblaf.peach.linalg.base._solver.LinearSolver[LinearSolver]

                              liblaf.peach.linalg.cupy._base.CupySolver --> liblaf.peach.linalg.cupy.CupyCG
                                liblaf.peach.linalg.base._solver.LinearSolver --> liblaf.peach.linalg.cupy._base.CupySolver
                



              click liblaf.peach.linalg.cupy.CupyCG href "" "liblaf.peach.linalg.cupy.CupyCG"
              click liblaf.peach.linalg.cupy._base.CupySolver href "" "liblaf.peach.linalg.cupy._base.CupySolver"
              click liblaf.peach.linalg.base._solver.LinearSolver href "" "liblaf.peach.linalg.base._solver.LinearSolver"

Parameters:

  • maxiter (int | None, default: None ) –
  • rtol (float, default: 1e-05 ) –
  • atol (float, default: 0.0 ) –

Type Aliases:

  • Solution –

    Linear-solver output bundle.

Classes:

  • State –

    State recorded by CuPy-backed linear solvers.

  • Stats –

    Stats placeholder for CuPy-backed linear solvers.

Methods:

  • compute –

    Run one complete solve from an initialized state.

  • init –

    Create solver state from an initial parameter vector.

  • postprocess –

    Wrap final state and result metadata in a solution object.

  • solve –

    Initialize, compute, and postprocess a linear solve.

Attributes:

atol class-attribute instance-attribute 

atol: float = 0.0

maxiter class-attribute instance-attribute 

maxiter: int | None = None

rtol class-attribute instance-attribute 

rtol: float = 1e-05

Solution 

Solution = Solution[CupyState, CupyStats]

Linear-solver output bundle.

Parameters:

  • result (Result) –
  • state (S) –
  • stats (T) –

State

Bases: State


              flowchart TD
              liblaf.peach.linalg.cupy.CupyCG.State[State]
              liblaf.peach.linalg.base._types.State[State]

                              liblaf.peach.linalg.base._types.State --> liblaf.peach.linalg.cupy.CupyCG.State
                


              click liblaf.peach.linalg.cupy.CupyCG.State href "" "liblaf.peach.linalg.cupy.CupyCG.State"
              click liblaf.peach.linalg.base._types.State href "" "liblaf.peach.linalg.base._types.State"

State recorded by CuPy-backed linear solvers.

Parameters:

  • params (Vector) –

    Current solution estimate.

  • info (int, default: -1 ) –
  • step (int | None, default: None ) –

Attributes:

info class-attribute instance-attribute 

info: int = -1

params instance-attribute 

params: Vector

Current solution estimate.

step class-attribute instance-attribute 

step: int | None = None

Stats

Bases: Stats


              flowchart TD
              liblaf.peach.linalg.cupy.CupyCG.Stats[Stats]
              liblaf.peach.linalg.base._types.Stats[Stats]

                              liblaf.peach.linalg.base._types.Stats --> liblaf.peach.linalg.cupy.CupyCG.Stats
                


              click liblaf.peach.linalg.cupy.CupyCG.Stats href "" "liblaf.peach.linalg.cupy.CupyCG.Stats"
              click liblaf.peach.linalg.base._types.Stats href "" "liblaf.peach.linalg.base._types.Stats"

Stats placeholder for CuPy-backed linear solvers.

Parameters:

  • absolute_residual (Scalar, default: None ) –
  • relative_residual (Scalar, default: None ) –

Attributes:

absolute_residual class-attribute instance-attribute 

absolute_residual: Scalar = field(default=None)

relative_residual class-attribute instance-attribute 

relative_residual: Scalar = field(default=None)

compute 

compute(problem: BaseProblem, state: CupyState) -> Result

Run one complete solve from an initialized state.

Source code in src/liblaf/peach/linalg/cupy/_base.py 
35
36
37
38
39
40
41
42
43
44
45
46
@override
def compute(self, problem: BaseProblem, state: State) -> Result:
    problem: Problem = cast("Problem", problem)
    lop: linalg.LinearOperator = _as_lop(problem)
    options: dict[str, Any] = self._options(problem)
    with cp.cuda.Stream.from_external(torch.cuda.current_stream()):
        x, info = self._wrapped(
            lop, cp.asarray(problem.b), cp.asarray(state.params), **options
        )
    state.params = torch.as_tensor(x)
    result: Result = self._result(state, info)
    return result

init 

init(problem: BaseProblem, params: Vector) -> CupyState

Create solver state from an initial parameter vector.

Source code in src/liblaf/peach/linalg/cupy/_base.py 
31
32
33
@override
def init(self, problem: BaseProblem, params: Vector) -> State:
    return self.State(params=params)

postprocess 

postprocess(
    problem: BaseProblem, state: CupyState, result: Result
) -> Solution

Wrap final state and result metadata in a solution object.

Source code in src/liblaf/peach/linalg/cupy/_base.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
@override
def postprocess(
    self, problem: BaseProblem, state: State, result: Result
) -> Solution:
    problem: Problem = cast("Problem", problem)
    stats: CupySolver.Stats = self.Stats()
    if state.info >= 0:
        stats.absolute_residual = torch.linalg.vector_norm(
            problem.matvec(state.params) - problem.b
        )
        stats.relative_residual = (
            stats.absolute_residual / torch.linalg.vector_norm(problem.b).item()
        )
    return LinearSolver.Solution(result=result, state=state, stats=stats)

solve 

solve(
    problem: BaseProblem, params: Vector
) -> Solution[S, T]

Initialize, compute, and postprocess a linear solve.

Source code in src/liblaf/peach/linalg/base/_solver.py 
36
37
38
39
40
def solve(self, problem: BaseProblem, params: Vector) -> Solution[S, T]:
    """Initialize, compute, and postprocess a linear solve."""
    state: S = self.init(problem, params)
    result: Result = self.compute(problem, state)
    return self.postprocess(problem, state, result)

CupyMinRes

Bases: CupySolver


              flowchart TD
              liblaf.peach.linalg.cupy.CupyMinRes[CupyMinRes]
              liblaf.peach.linalg.cupy._base.CupySolver[CupySolver]
              liblaf.peach.linalg.base._solver.LinearSolver[LinearSolver]

                              liblaf.peach.linalg.cupy._base.CupySolver --> liblaf.peach.linalg.cupy.CupyMinRes
                                liblaf.peach.linalg.base._solver.LinearSolver --> liblaf.peach.linalg.cupy._base.CupySolver
                



              click liblaf.peach.linalg.cupy.CupyMinRes href "" "liblaf.peach.linalg.cupy.CupyMinRes"
              click liblaf.peach.linalg.cupy._base.CupySolver href "" "liblaf.peach.linalg.cupy._base.CupySolver"
              click liblaf.peach.linalg.base._solver.LinearSolver href "" "liblaf.peach.linalg.base._solver.LinearSolver"

Parameters:

  • maxiter (int | None, default: None ) –
  • shift (float, default: 0.0 ) –
  • tol (float, default: 1e-05 ) –

Type Aliases:

  • Solution –

    Linear-solver output bundle.

Classes:

  • State –

    State recorded by CuPy-backed linear solvers.

  • Stats –

    Stats placeholder for CuPy-backed linear solvers.

Methods:

  • compute –

    Run one complete solve from an initialized state.

  • init –

    Create solver state from an initial parameter vector.

  • postprocess –

    Wrap final state and result metadata in a solution object.

  • solve –

    Initialize, compute, and postprocess a linear solve.

Attributes:

maxiter class-attribute instance-attribute 

maxiter: int | None = None

shift class-attribute instance-attribute 

shift: float = 0.0

tol class-attribute instance-attribute 

tol: float = 1e-05

Solution 

Solution = Solution[CupyState, CupyStats]

Linear-solver output bundle.

Parameters:

  • result (Result) –
  • state (S) –
  • stats (T) –

State

Bases: State


              flowchart TD
              liblaf.peach.linalg.cupy.CupyMinRes.State[State]
              liblaf.peach.linalg.base._types.State[State]

                              liblaf.peach.linalg.base._types.State --> liblaf.peach.linalg.cupy.CupyMinRes.State
                


              click liblaf.peach.linalg.cupy.CupyMinRes.State href "" "liblaf.peach.linalg.cupy.CupyMinRes.State"
              click liblaf.peach.linalg.base._types.State href "" "liblaf.peach.linalg.base._types.State"

State recorded by CuPy-backed linear solvers.

Parameters:

  • params (Vector) –

    Current solution estimate.

  • info (int, default: -1 ) –
  • step (int | None, default: None ) –

Attributes:

info class-attribute instance-attribute 

info: int = -1

params instance-attribute 

params: Vector

Current solution estimate.

step class-attribute instance-attribute 

step: int | None = None

Stats

Bases: Stats


              flowchart TD
              liblaf.peach.linalg.cupy.CupyMinRes.Stats[Stats]
              liblaf.peach.linalg.base._types.Stats[Stats]

                              liblaf.peach.linalg.base._types.Stats --> liblaf.peach.linalg.cupy.CupyMinRes.Stats
                


              click liblaf.peach.linalg.cupy.CupyMinRes.Stats href "" "liblaf.peach.linalg.cupy.CupyMinRes.Stats"
              click liblaf.peach.linalg.base._types.Stats href "" "liblaf.peach.linalg.base._types.Stats"

Stats placeholder for CuPy-backed linear solvers.

Parameters:

  • absolute_residual (Scalar, default: None ) –
  • relative_residual (Scalar, default: None ) –

Attributes:

absolute_residual class-attribute instance-attribute 

absolute_residual: Scalar = field(default=None)

relative_residual class-attribute instance-attribute 

relative_residual: Scalar = field(default=None)

compute 

compute(problem: BaseProblem, state: CupyState) -> Result

Run one complete solve from an initialized state.

Source code in src/liblaf/peach/linalg/cupy/_base.py 
35
36
37
38
39
40
41
42
43
44
45
46
@override
def compute(self, problem: BaseProblem, state: State) -> Result:
    problem: Problem = cast("Problem", problem)
    lop: linalg.LinearOperator = _as_lop(problem)
    options: dict[str, Any] = self._options(problem)
    with cp.cuda.Stream.from_external(torch.cuda.current_stream()):
        x, info = self._wrapped(
            lop, cp.asarray(problem.b), cp.asarray(state.params), **options
        )
    state.params = torch.as_tensor(x)
    result: Result = self._result(state, info)
    return result

init 

init(problem: BaseProblem, params: Vector) -> CupyState

Create solver state from an initial parameter vector.

Source code in src/liblaf/peach/linalg/cupy/_base.py 
31
32
33
@override
def init(self, problem: BaseProblem, params: Vector) -> State:
    return self.State(params=params)

postprocess 

postprocess(
    problem: BaseProblem, state: CupyState, result: Result
) -> Solution

Wrap final state and result metadata in a solution object.

Source code in src/liblaf/peach/linalg/cupy/_base.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
@override
def postprocess(
    self, problem: BaseProblem, state: State, result: Result
) -> Solution:
    problem: Problem = cast("Problem", problem)
    stats: CupySolver.Stats = self.Stats()
    if state.info >= 0:
        stats.absolute_residual = torch.linalg.vector_norm(
            problem.matvec(state.params) - problem.b
        )
        stats.relative_residual = (
            stats.absolute_residual / torch.linalg.vector_norm(problem.b).item()
        )
    return LinearSolver.Solution(result=result, state=state, stats=stats)

solve 

solve(
    problem: BaseProblem, params: Vector
) -> Solution[S, T]

Initialize, compute, and postprocess a linear solve.

Source code in src/liblaf/peach/linalg/base/_solver.py 
36
37
38
39
40
def solve(self, problem: BaseProblem, params: Vector) -> Solution[S, T]:
    """Initialize, compute, and postprocess a linear solve."""
    state: S = self.init(problem, params)
    result: Result = self.compute(problem, state)
    return self.postprocess(problem, state, result)

CupySolver

Bases: LinearSolver[CupyState, CupyStats]


              flowchart TD
              liblaf.peach.linalg.cupy.CupySolver[CupySolver]
              liblaf.peach.linalg.base._solver.LinearSolver[LinearSolver]

                              liblaf.peach.linalg.base._solver.LinearSolver --> liblaf.peach.linalg.cupy.CupySolver
                


              click liblaf.peach.linalg.cupy.CupySolver href "" "liblaf.peach.linalg.cupy.CupySolver"
              click liblaf.peach.linalg.base._solver.LinearSolver href "" "liblaf.peach.linalg.base._solver.LinearSolver"

Base class for linear solvers backed by CuPy sparse routines.

Parameters:

  • maxiter (int | None, default: None ) –

Type Aliases:

  • Solution –

    Linear-solver output bundle.

Methods:

  • compute –

    Run one complete solve from an initialized state.

  • init –

    Create solver state from an initial parameter vector.

  • postprocess –

    Wrap final state and result metadata in a solution object.

  • solve –

    Initialize, compute, and postprocess a linear solve.

Attributes:

maxiter class-attribute instance-attribute 

maxiter: int | None = None

Solution 

Solution = Solution[CupyState, CupyStats]

Linear-solver output bundle.

Parameters:

  • result (Result) –
  • state (S) –
  • stats (T) –

compute 

compute(problem: BaseProblem, state: CupyState) -> Result

Run one complete solve from an initialized state.

Source code in src/liblaf/peach/linalg/cupy/_base.py 
35
36
37
38
39
40
41
42
43
44
45
46
@override
def compute(self, problem: BaseProblem, state: State) -> Result:
    problem: Problem = cast("Problem", problem)
    lop: linalg.LinearOperator = _as_lop(problem)
    options: dict[str, Any] = self._options(problem)
    with cp.cuda.Stream.from_external(torch.cuda.current_stream()):
        x, info = self._wrapped(
            lop, cp.asarray(problem.b), cp.asarray(state.params), **options
        )
    state.params = torch.as_tensor(x)
    result: Result = self._result(state, info)
    return result

init 

init(problem: BaseProblem, params: Vector) -> CupyState

Create solver state from an initial parameter vector.

Source code in src/liblaf/peach/linalg/cupy/_base.py 
31
32
33
@override
def init(self, problem: BaseProblem, params: Vector) -> State:
    return self.State(params=params)

postprocess 

postprocess(
    problem: BaseProblem, state: CupyState, result: Result
) -> Solution

Wrap final state and result metadata in a solution object.

Source code in src/liblaf/peach/linalg/cupy/_base.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
@override
def postprocess(
    self, problem: BaseProblem, state: State, result: Result
) -> Solution:
    problem: Problem = cast("Problem", problem)
    stats: CupySolver.Stats = self.Stats()
    if state.info >= 0:
        stats.absolute_residual = torch.linalg.vector_norm(
            problem.matvec(state.params) - problem.b
        )
        stats.relative_residual = (
            stats.absolute_residual / torch.linalg.vector_norm(problem.b).item()
        )
    return LinearSolver.Solution(result=result, state=state, stats=stats)

solve 

solve(
    problem: BaseProblem, params: Vector
) -> Solution[S, T]

Initialize, compute, and postprocess a linear solve.

Source code in src/liblaf/peach/linalg/base/_solver.py 
36
37
38
39
40
def solve(self, problem: BaseProblem, params: Vector) -> Solution[S, T]:
    """Initialize, compute, and postprocess a linear solve."""
    state: S = self.init(problem, params)
    result: Result = self.compute(problem, state)
    return self.postprocess(problem, state, result)

CupyState

Bases: State


              flowchart TD
              liblaf.peach.linalg.cupy.CupyState[CupyState]
              liblaf.peach.linalg.base._types.State[State]

                              liblaf.peach.linalg.base._types.State --> liblaf.peach.linalg.cupy.CupyState
                


              click liblaf.peach.linalg.cupy.CupyState href "" "liblaf.peach.linalg.cupy.CupyState"
              click liblaf.peach.linalg.base._types.State href "" "liblaf.peach.linalg.base._types.State"

State recorded by CuPy-backed linear solvers.

Parameters:

  • params (Vector) –

    Current solution estimate.

  • info (int, default: -1 ) –
  • step (int | None, default: None ) –

Attributes:

info class-attribute instance-attribute 

info: int = -1

params instance-attribute 

params: Vector

Current solution estimate.

step class-attribute instance-attribute 

step: int | None = None

CupyStats

Bases: Stats


              flowchart TD
              liblaf.peach.linalg.cupy.CupyStats[CupyStats]
              liblaf.peach.linalg.base._types.Stats[Stats]

                              liblaf.peach.linalg.base._types.Stats --> liblaf.peach.linalg.cupy.CupyStats
                


              click liblaf.peach.linalg.cupy.CupyStats href "" "liblaf.peach.linalg.cupy.CupyStats"
              click liblaf.peach.linalg.base._types.Stats href "" "liblaf.peach.linalg.base._types.Stats"

Stats placeholder for CuPy-backed linear solvers.

Parameters:

  • absolute_residual (Scalar, default: None ) –
  • relative_residual (Scalar, default: None ) –

Attributes:

absolute_residual class-attribute instance-attribute 

absolute_residual: Scalar = field(default=None)

relative_residual class-attribute instance-attribute 

relative_residual: Scalar = field(default=None)