liblaf.peach.linalg.fallback ¶

Bases: LinearSolver[FallbackState, FallbackStats]

              flowchart TD
              liblaf.peach.linalg.fallback.FallbackSolver[FallbackSolver]
              liblaf.peach.linalg.base._solver.LinearSolver[LinearSolver]

                              liblaf.peach.linalg.base._solver.LinearSolver --> liblaf.peach.linalg.fallback.FallbackSolver
                


              click liblaf.peach.linalg.fallback.FallbackSolver href "" "liblaf.peach.linalg.fallback.FallbackSolver"
              click liblaf.peach.linalg.base._solver.LinearSolver href "" "liblaf.peach.linalg.base._solver.LinearSolver"
            

Parameters:

• solvers (list[LinearSolver], default: [CupyCG(maxiter=None, rtol=1e-05, atol=0.0), CupyMinRes(maxiter=None, shift=0.0, tol=1e-05)] ) –

solvers: list[LinearSolver] = field(
    factory=_default_solvers
)

Solution = Solution[FallbackState, FallbackStats]

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

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

@override
def compute(self, problem: BaseProblem, state: State) -> Result:
    problem: Problem = cast("Problem", problem)
    results: list[Result] = []
    absolute_residuals: list[Scalar] = []
    relative_residuals: list[Scalar] = []
    for solver in self.solvers:
        solution: Solution = solver.solve(problem, state.init_params)
        state.solutions.append(solution)
        results.append(solution.result)
        absolute_residual: Scalar = torch.linalg.vector_norm(
            problem.matvec(solution.state.params) - problem.b
        )
        relative_residual: Scalar = absolute_residual / torch.linalg.vector_norm(
            problem.b
        )
        absolute_residuals.append(absolute_residual)
        relative_residuals.append(relative_residual)
        if solution.success:
            break
    state.absolute_residuals = torch.as_tensor(absolute_residuals)
    state.relative_residuals = torch.as_tensor(relative_residuals)
    state.best_index = torch.argmin(state.absolute_residuals)
    return state.result

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

37
38
39

@override
def init(self, problem: BaseProblem, params: Vector) -> State:
    return self.State(init_params=params)

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)

Bases: State

              flowchart TD
              liblaf.peach.linalg.fallback.FallbackState[FallbackState]
              liblaf.peach.linalg.base._types.State[State]

                              liblaf.peach.linalg.base._types.State --> liblaf.peach.linalg.fallback.FallbackState
                


              click liblaf.peach.linalg.fallback.FallbackState href "" "liblaf.peach.linalg.fallback.FallbackState"
              click liblaf.peach.linalg.base._types.State href "" "liblaf.peach.linalg.base._types.State"
            

State collected while trying multiple linear solvers.

Parameters:

• init_params (Vector) –
• solutions (list[Solution], default: <dynamic> ) –

  Built-in mutable sequence.

  If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.

• absolute_residuals (Float[Tensor, S], default: <dynamic> ) –

  Built-in mutable sequence.

  If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.

• relative_residuals (Float[Tensor, S], default: <dynamic> ) –

  Built-in mutable sequence.

  If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.

• best_index (Integer[Tensor, ''], default: tensor(0, dtype=torch.int32) ) –

absolute_residuals: Float[Tensor, " S"] = field(
    factory=list
)

best_index: Integer[Tensor, ""] = field(
    factory=lambda: as_tensor(0, dtype=int32)
)

best_solution: Solution

init_params: Vector

params: Vector

relative_residuals: Float[Tensor, " S"] = field(
    factory=list
)

result: Result

solutions: list[Solution] = field(factory=list)

Bases: Stats

              flowchart TD
              liblaf.peach.linalg.fallback.FallbackStats[FallbackStats]
              liblaf.peach.linalg.base._types.Stats[Stats]

                              liblaf.peach.linalg.base._types.Stats --> liblaf.peach.linalg.fallback.FallbackStats
                


              click liblaf.peach.linalg.fallback.FallbackStats href "" "liblaf.peach.linalg.fallback.FallbackStats"
              click liblaf.peach.linalg.base._types.Stats href "" "liblaf.peach.linalg.base._types.Stats"
            

Stats placeholder for fallback linear solves.