liblaf.peach.linalg.base ¶

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.

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

24
25
26

def compute(self, problem: BaseProblem, state: S) -> Result:
    """Run one complete solve from an initialized state."""
    raise NotImplementedError

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

20
21
22

def init(self, problem: BaseProblem, params: Vector) -> S:
    """Create solver state from an initial parameter vector."""
    raise NotImplementedError

postprocess(
    problem: BaseProblem, state: S, result: Result
) -> Solution[S, T]

28
29
30
31
32
33
34

def postprocess(
    self, problem: BaseProblem, state: S, result: Result
) -> Solution[S, T]:
    """Wrap final state and result metadata in a solution object."""
    del problem
    stats: T = cast("T", self.Stats())  # ty:ignore[call-non-callable]
    return Solution(result=result, state=state, stats=stats)

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

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)

Methods:

• matvec –

  Apply the system matrix to x.

• precondition –

  Apply an optional left preconditioner to x.

• rmatvec –

  Apply the transpose or adjoint system matrix to x.

• rprecondition –

  Apply an optional transpose or adjoint preconditioner to x.

Attributes:

• b (Vector) –

  Right-hand-side vector.

b: Vector

matvec(x: Vector) -> Vector

23
24
25

@not_implemented
def matvec(self, x: Vector, /) -> Vector:
    """Apply the system matrix to `x`."""

precondition(x: Vector) -> Vector

31
32
33

@not_implemented
def precondition(self, x: Vector, /) -> Vector:
    """Apply an optional left preconditioner to `x`."""

rmatvec(x: Vector) -> Vector

27
28
29

@not_implemented
def rmatvec(self, x: Vector, /) -> Vector:
    """Apply the transpose or adjoint system matrix to `x`."""

rprecondition(x: Vector) -> Vector

35
36
37

@not_implemented
def rprecondition(self, x: Vector, /) -> Vector:
    """Apply an optional transpose or adjoint preconditioner to `x`."""

Attributes:

• BREAKDOWN –
• MAX_STEPS_REACHED –
• PRIMARY_SUCCESS –
• SECONDARY_SUCCESS –
• SUCCESS –
• UNKNOWN_ERROR –
• success (bool) –

  Whether the result represents an accepted solution.

BREAKDOWN = auto()

MAX_STEPS_REACHED = auto()

PRIMARY_SUCCESS = auto()

SECONDARY_SUCCESS = auto()

SUCCESS = auto()

UNKNOWN_ERROR = auto()

success: bool

Attributes:

• params (Vector) –

  Final solution parameters.

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

  Whether result is successful.

params: Vector

result: Result

state: S

stats: T

success: bool

Attributes:

• params (Vector) –

  Current solution estimate.

params: Vector