num::solve_transpose

Defined in header <linear/factorization/block_tridiagonal.hpp>, <linear/factorization/cholesky.hpp>, <linear/factorization/factor.hpp>, <linear/factorization/lu.hpp>, <linear/factorization/mixed_lu.hpp>, <linear/factorization/reuse.hpp>, <linear/factorization/woodbury.hpp>, <linear/solve.hpp>, <linear/solvers/auto_linear.hpp>, <linear/sparse/klu.hpp>

template <class F, class RHS>
RHS solve_transpose(const F &factor, const RHS &b)
requires requires(RHS &x);  // (1)

template <class F, class RHS>
void solve_transpose(detail::transposed_factor<F> factor, const RHS &b, RHS &x);  // (2)

template <std::floating_point T>
void solve_transpose(const lu_result<T> &f, const std::type_identity_t<vec<T>> &b,
                     vec<T> &x);  // (3)

template <std::floating_point T>
void solve_transpose(const lu_result<T> &f, const std::type_identity_t<mat<T>> &B,
                     mat<T> &X);  // (4)

void solve_transpose(const cholesky_result &f, const vec<real> &b, vec<real> &x);  // (5)

void solve_transpose(const cholesky_result &f, const mat<real> &B, mat<real> &X);  // (6)

void solve_transpose(const block_lu_factor &factor, const mat<real> &B, mat<real> &X);  // (7)

void solve_transpose(const block_lu_factor &factor, const vec<real> &b, vec<real> &x);  // (8)

friend void solve_transpose(const auto_linear_solver &, const vec<real> &, vec<real> &);  // (9)

friend void solve_transpose(const auto_linear_solver &, const mat<real> &, mat<real> &);  // (10)

friend void solve_transpose(const klu_factorization &, const vec<real> &, vec<real> &);  // (11)

friend void solve_transpose(const klu_factorization &, const mat<real> &, mat<real> &);  // (12)

void solve_transpose(const block_cholesky_factor &Z, const vec<real> &b, vec<real> &x);  // (13)

void solve_transpose(const block_cholesky_factor &Z, const mat<real> &B, mat<real> &X);  // (14)

template <class F, class RHS>
void solve_transpose(const similar_factor<F> &Z, const RHS &b, RHS &x);  // (15)

void solve_transpose(const mixed_lu &F, const vec<real> &b, vec<real> &x);  // (16)

void solve_transpose(const mixed_lu &F, const mat<real> &B, mat<real> &X);  // (17)

template <class RHS>
friend void solve_transpose(const woodbury_solver &W, const RHS &b, RHS &x);  // (18)

template <class RHS>
friend void solve_transpose(const corrected_factor &Z, const RHS &rhs, RHS &out);  // (19)

template <class RHS>
void solve_transpose(const suffix_block_lu &Z, const RHS &rhs, RHS &out);  // (20)

template <class RHS>
void solve_transpose(const suffix_block_cholesky &Z, const RHS &rhs, RHS &out);  // (21)

(1) Solve \(A^Tx = b\), allocating x.

(2) Undocumented.

(3) Solve \(A^T x = b\). x may be b.

\(A^T = U^T L^T P\), so \(U^T Q = B\), \(L^T Y = Q\), \(X = P^T Y\).

(4) Solve \(A^T X = B\). X may be B.

(5) Solve \(A^Tx=b\), the same solve since \(A\) is symmetric.

(6) Undocumented.

(7) Solve \(A^{T}X = B\) from the same factors, without refactorizing.

\(A = \mathcal{L}\mathcal{U}\) gives \(A^{T} = \mathcal{U}^{T}\mathcal{L}^{T}\), so the block dependency runs the other way: a forward sweep through \(\mathcal{U}^{T}\) (block lower bidiagonal, upper[k]^T below the diagonal) followed by a backward sweep through \(\mathcal{L}^{T}\) (block unit upper bidiagonal, lower[k]^T above it).

(8) Solve \(A^{T}x = b\) from the same factors, without refactorizing.

(9) Solve \(A^Tx = b\). x may be b.

(10) Undocumented.

(11) Solve \(A^Tx = b\). x may be b.

(12) Undocumented.

(13) Undocumented.

(14) Undocumented.

(15) Undocumented.

(16) Solve \(A^Tx = b\) to double-precision accuracy. x may be b.

(17) Solve \(A^TX = B\), refining each column. X may be B.

(18) Solve \((A_{base} + PQ^{T})^{T}x = b\).

x may be b.

(19) Undocumented.

(20) Undocumented.

(21) Undocumented.