cuSolverDx in Tile#

The cuSolverDx Tile C++ API provides dense factorizations, linear solves, eigensolvers, and singular-value decompositions. Include cusolverdx_tile.hpp. Link mathdx_tile::cusolverdx.

The cuSolverDx and cuBLASDx Python interfaces are combined in Linear Algebra cutile-python API.

Routines that can fail at runtime return a status value, info, alongside the numerical result. For a single problem, info is an integer scalar. For batched calls, it is an integer tile of shape (Batch,). The caller must check these status values. Refer to Status codes. All dense routines accept an optional leading batch extent.

Quick start#

#include "cusolverdx_tile.hpp"

namespace ct = cuda::tiles;

__tile_global__ void cholesky_kernel(float* matrix, float* factor, int* status) {
    using matrix_shape = ct::shape<16, 16>;
    auto source = ct::partition_view { ct::tensor_span { matrix, matrix_shape {} }, matrix_shape {} };
    auto destination = ct::partition_view { ct::tensor_span { factor, matrix_shape {} }, matrix_shape {} };

    auto [result, info] = cusolverdx::tiles::cholesky_factor(source.load(0, 0), cusolverdx::tiles::lower);
    destination.store(result, 0, 0);
    *status = static_cast<int>(info);
}

void launch_cholesky(float* matrix, float* factor, int* status) {
    cholesky_kernel<<<1, 1>>>(matrix, factor, status);
}

C++ API reference#

constexpr lower_t cusolverdx::tiles::lower = {}#

Lower fill tag.

constexpr upper_t cusolverdx::tiles::upper = {}#

Upper fill tag.

constexpr partial_pivot_t cusolverdx::tiles::partial_pivot = {}#

Partial-pivot tag.

constexpr no_pivot_t cusolverdx::tiles::no_pivot = {}#

No-pivot tag.

constexpr left_t cusolverdx::tiles::left = {}#

Left-side tag.

constexpr right_t cusolverdx::tiles::right = {}#

Right-side tag.

constexpr no_trans_t cusolverdx::tiles::no_trans = {}#

Non-transpose tag.

constexpr trans_t cusolverdx::tiles::trans = {}#

Transpose tag.

constexpr no_vectors_t cusolverdx::tiles::no_vectors = {}#

No-vectors tag.

constexpr all_vectors_t cusolverdx::tiles::all_vectors = {}#

All-vectors tag.

constexpr some_vectors_t cusolverdx::tiles::some_vectors = {}#

Thin-vectors tag.

constexpr multiply_vectors_t cusolverdx::tiles::multiply_vectors = {}#

Multiply-vectors tag.

template<int K>
constexpr eig_type_t<K> cusolverdx::tiles::eig_type = {}#

Generalized-eigenproblem tag for LAPACK itype K.

template<typename ATile, typename FillTag>
auto cusolverdx::tiles::cholesky_factor(
ATile A,
[[maybe_unused]] FillTag fill,
)#

Factor symmetric positive-definite A using the selected triangle. A has shape (M, M), or (Batch, M, M) to factor Batch independent matrices in one tile block. Returns (factor, info); each selected triangle contains its Cholesky factor and info holds one status per batch (scalar unbatched).

Parameters:
  • A – Positive-definite matrix with shape (M, M) or (Batch, M, M).

  • fill – Selects the lower or upper triangle of A.

Returns:

(factor, info), where factor has the shape of A and info is scalar unbatched or has shape (Batch) batched.

template<typename ATile>
auto cusolverdx::tiles::lu_factor(
ATile A,
[[maybe_unused]] partial_pivot_t pivot,
)#

Compute packed LU factors with partial pivoting. A has shape (M, N), or (Batch, M, N) to factor Batch independent matrices in one tile block. Returns (LU, pivots, info) with one pivot vector and status per batch.

Parameters:
  • A – Matrix with shape (M, N) or (Batch, M, N).

  • pivot – Selects partial pivoting.

Returns:

(LU, pivots, info), where LU has the shape of A, pivots has shape (R) or (Batch, R) for \(R = \min(M, N)\), and info is scalar or has shape (Batch).

template<typename ATile>
auto cusolverdx::tiles::lu_factor(
ATile A,
[[maybe_unused]] no_pivot_t pivot,
)#

Compute packed LU factors without pivoting. Returns (LU, info) with one status per batch; A is batched like the partial-pivot form.

Parameters:
  • A – Matrix with shape (M, N) or (Batch, M, N).

  • pivot – Selects no pivoting.

Returns:

(LU, info), where LU has the shape of A and info is scalar or has shape (Batch).

template<typename ATile>
auto cusolverdx::tiles::lu_factor(ATile A)#

Compute packed LU factors with partial pivoting by default. Returns (LU, pivots, info).

Parameters:

A – Matrix with shape (M, N) or (Batch, M, N).

Returns:

(LU, pivots, info), where LU has the shape of A, pivots has shape (R) or (Batch, R) for \(R = \min(M, N)\), and info is scalar or has shape (Batch).

template<typename ATile>
auto cusolverdx::tiles::modified_lu_factor(
ATile A,
)#

Compute the modified no-pivot factorization \(A - \operatorname{diag}(S) = L U\) for \(M \ge N\); A has shape (M, N) or (Batch, M, N). Returns packed factors and per-batch diagonal entries (LU, S) without an info result.

Parameters:

A – Matrix with shape (M, N) or (Batch, M, N), where \(M \ge N\).

Returns:

(LU, S), where LU has the shape of A and S has shape (N) or (Batch, N).

template<typename ATile>
auto cusolverdx::tiles::qr_factor(ATile A)#

Compute packed Householder QR factors (QR, tau) for \(M \ge N\); A has shape (M, N) or (Batch, M, N), with one tau vector per batch.

Parameters:

A – Matrix with shape (M, N) or (Batch, M, N), where \(M \ge N\).

Returns:

(QR, tau), where QR has the shape of A and tau has shape (N) or (Batch, N).

template<typename ATile>
auto cusolverdx::tiles::lq_factor(ATile A)#

Compute packed Householder LQ factors (LQ, tau) for \(M \le N\); A has shape (M, N) or (Batch, M, N), with one tau vector per batch.

Parameters:

A – Matrix with shape (M, N) or (Batch, M, N), where \(M \le N\).

Returns:

(LQ, tau), where LQ has the shape of A and tau has shape (M) or (Batch, M).

template<typename ATile, typename TauTile>
auto cusolverdx::tiles::qr_generate_q(
ATile A,
TauTile tau,
)#

Form the explicit thin Q represented by (QR, tau), per batch entry when the operands carry a common leading batch dim.

Parameters:
  • A – Packed QR factors with shape (M, N) or (Batch, M, N).

  • tau – Householder scales with shape (N) or (Batch, N).

Returns:

Explicit thin Q with shape (M, N) or (Batch, M, N).

template<typename ATile, typename TauTile>
auto cusolverdx::tiles::lq_generate_q(
ATile A,
TauTile tau,
)#

Form the explicit thin Q represented by (LQ, tau), per batch entry when the operands carry a common leading batch dim.

Parameters:
  • A – Packed LQ factors with shape (M, N) or (Batch, M, N).

  • tau – Householder scales with shape (M) or (Batch, M).

Returns:

Explicit thin Q with shape (M, N) or (Batch, M, N).

template<typename ATile, typename TauTile, typename CTile, typename SideTag, typename TransTag = no_trans_t>
auto cusolverdx::tiles::qr_multiply_by_q(
ATile A,
TauTile tau,
CTile C,
[[maybe_unused]] SideTag side,
[[maybe_unused]] TransTag trans = {},
)#

Apply the implicit \(\operatorname{op}(Q)\) represented by (A, tau) to C, per batch entry when the operands carry a common leading batch dim. \(\operatorname{op}(Q)\) is \(Q\) or \(Q^T\) according to the transpose tag. Returns \(\operatorname{op}(Q) C\) from the left or \(C \operatorname{op}(Q)\) from the right. Defaults to no transpose.

Parameters:
  • A – Packed QR factors with shape (M, N) or (Batch, M, N).

  • tau – Householder scales with shape (N) or (Batch, N).

  • C – Matrix with shape (M, K) for a left application or (K, M) for a right application, optionally prefixed by Batch.

  • side – Selects whether \(\operatorname{op}(Q)\) acts from the left or right.

  • trans – Selects \(\operatorname{op}(Q)\) as \(Q\) or \(Q^T\).

Returns:

Transformed matrix with the same shape as C.

template<typename ATile, typename TauTile, typename CTile, typename SideTag, typename TransTag = no_trans_t>
auto cusolverdx::tiles::lq_multiply_by_q(
ATile A,
TauTile tau,
CTile C,
[[maybe_unused]] SideTag side,
[[maybe_unused]] TransTag trans = {},
)#

Apply the implicit \(\operatorname{op}(Q)\) represented by (A, tau) to C, per batch entry when the operands carry a common leading batch dim. \(\operatorname{op}(Q)\) is \(Q\) or \(Q^T\) according to the transpose tag. Returns \(\operatorname{op}(Q) C\) from the left or \(C \operatorname{op}(Q)\) from the right. Defaults to no transpose.

Parameters:
  • A – Packed LQ factors with shape (M, N) or (Batch, M, N).

  • tau – Householder scales with shape (M) or (Batch, M).

  • C – Matrix with shape (N, K) for a left application or (K, N) for a right application, optionally prefixed by Batch.

  • side – Selects whether \(\operatorname{op}(Q)\) acts from the left or right.

  • trans – Selects \(\operatorname{op}(Q)\) as \(Q\) or \(Q^T\).

Returns:

Transformed matrix with the same shape as C.

template<typename ATile, typename BTile>
auto cusolverdx::tiles::lu_solve(
ATile A,
BTile B,
[[maybe_unused]] partial_pivot_t pivot,
)#

Factor A with partial pivoting and solve \(A X = B\), per batch entry when the operands carry a common leading batch dim. Returns (X, info) with one status per batch.

Parameters:
  • A – Square coefficient matrix with shape (M, M) or (Batch, M, M).

  • B – Right-hand sides with shape (M, K) or (Batch, M, K).

  • pivot – Selects partial pivoting.

Returns:

(X, info), where X has the shape of B and info is scalar or has shape (Batch).

template<typename ATile, typename BTile>
auto cusolverdx::tiles::lu_solve(
ATile A,
BTile B,
[[maybe_unused]] no_pivot_t pivot,
)#

Factor A without pivoting and solve \(A X = B\), per batch entry when the operands carry a common leading batch dim. Returns (X, info) with one status per batch.

Parameters:
  • A – Square coefficient matrix with shape (M, M) or (Batch, M, M).

  • B – Right-hand sides with shape (M, K) or (Batch, M, K).

  • pivot – Selects no pivoting.

Returns:

(X, info), where X has the shape of B and info is scalar or has shape (Batch).

template<typename ATile, typename BTile>
auto cusolverdx::tiles::lu_solve(
ATile A,
BTile B,
)#

Factor A with partial pivoting by default and solve \(A X = B\). Returns (X, info).

Parameters:
  • A – Square coefficient matrix with shape (M, M) or (Batch, M, M).

  • B – Right-hand sides with shape (M, K) or (Batch, M, K).

Returns:

(X, info), where X has the shape of B and info is scalar or has shape (Batch).

template<typename ATile, typename BTile, typename FillTag>
auto cusolverdx::tiles::cholesky_solve(
ATile A,
BTile B,
[[maybe_unused]] FillTag fill,
)#

Factor positive-definite A using the selected triangle and solve \(A X = B\), per batch entry when the operands carry a common leading batch dim. Returns (X, info) with one status per batch.

Parameters:
  • A – Positive-definite matrix with shape (M, M) or (Batch, M, M).

  • B – Right-hand sides with shape (M, K) or (Batch, M, K).

  • fill – Selects the lower or upper triangle of A.

Returns:

(X, info), where X has the shape of B and info is scalar or has shape (Batch).

template<typename LTile, typename BTile, typename FillTag>
auto cusolverdx::tiles::cholesky_solve_using_factor(
LTile L,
BTile B,
[[maybe_unused]] FillTag fill,
)#

Solve \(A X = B\) using an existing Cholesky factor and matching fill tag, per batch entry when the operands carry a common leading batch dim. Returns X without an info result.

Parameters:
  • L – Cholesky factor with shape (M, M) or (Batch, M, M).

  • B – Right-hand sides with shape (M, K) or (Batch, M, K).

  • fill – Selects the triangle containing the factor.

Returns:

Solution with the same shape as B.

template<typename LUTile, typename PivotTile, typename BTile>
auto cusolverdx::tiles::lu_solve_using_factor(
LUTile LU,
PivotTile pivots,
BTile B,
)#

Solve \(A X = B\) using packed partial-pivot LU factors and their per-batch pivot vectors. Returns X without an info result.

Parameters:
  • LU – Packed factors with shape (M, M) or (Batch, M, M).

  • pivots – Pivot indices with shape (M) or (Batch, M).

  • B – Right-hand sides with shape (M, K) or (Batch, M, K).

Returns:

Solution with the same shape as B.

template<typename LUTile, typename BTile>
auto cusolverdx::tiles::lu_solve_using_factor(
LUTile LU,
BTile B,
)#

Solve \(A X = B\) using packed no-pivot LU factors, per batch entry when the operands carry a common leading batch dim. Returns X without an info result.

Parameters:
  • LU – Packed factors with shape (M, M) or (Batch, M, M).

  • B – Right-hand sides with shape (M, K) or (Batch, M, K).

Returns:

Solution with the same shape as B.

template<typename T, size_t N>
auto cusolverdx::tiles::tridiagonal_solve(
ct::tile<T, ct::shape<N>> dl,
ct::tile<T, ct::shape<N>> d,
ct::tile<T, ct::shape<N>> du,
ct::tile<T, ct::shape<N>> B,
)#

Solve a no-pivot tridiagonal system for a length-N right-hand side. Returns (X, info) with X retaining rank one.

Parameters:
  • dl – Subdiagonal values with padded shape (N).

  • d – Diagonal values with shape (N).

  • du – Superdiagonal values with padded shape (N).

  • B – Right-hand side with shape (N).

Returns:

(X, info), where X has shape (N) and info is scalar.

template<typename T, size_t N, size_t K>
auto cusolverdx::tiles::tridiagonal_solve(
ct::tile<T, ct::shape<N>> dl,
ct::tile<T, ct::shape<N>> d,
ct::tile<T, ct::shape<N>> du,
ct::tile<T, ct::shape<N, K>> B,
)#

Solve a no-pivot tridiagonal system for an N-by-K right-hand side. Returns (X, info) with X retaining rank two, including when K is one.

Parameters:
  • dl – Subdiagonal values with padded shape (N).

  • d – Diagonal values with shape (N).

  • du – Superdiagonal values with padded shape (N).

  • B – Right-hand sides with shape (N, K).

Returns:

(X, info), where X has shape (N, K) and info is scalar.

template<typename T, size_t N>
auto cusolverdx::tiles::eig_hermitian_tridiagonal(
ct::tile<T, ct::shape<N>> d,
ct::tile<T, ct::shape<N>> e,
[[maybe_unused]] no_vectors_t job,
)#

Solve the symmetric tridiagonal eigensystem defined by diagonal d and off-diagonal e, whose final element is padding. Returns (w, info).

Parameters:
  • d – Diagonal values with shape (N).

  • e – Off-diagonal values with padded shape (N).

  • job – Selects eigenvalues without eigenvectors.

Returns:

(w, info), where w has shape (N) and info is scalar.

template<typename T, size_t N>
auto cusolverdx::tiles::eig_hermitian_tridiagonal(
ct::tile<T, ct::shape<N>> d,
ct::tile<T, ct::shape<N>> e,
[[maybe_unused]] all_vectors_t job,
)#

Solve the symmetric tridiagonal eigensystem defined by diagonal d and off-diagonal e, whose final element is padding. Returns (w, V, info).

Parameters:
  • d – Diagonal values with shape (N).

  • e – Off-diagonal values with padded shape (N).

  • job – Selects all eigenvectors.

Returns:

(w, V, info), where w has shape (N), V has shape (N, N), and info is scalar.

template<typename T, size_t N>
auto cusolverdx::tiles::eig_hermitian_tridiagonal(
ct::tile<T, ct::shape<N>> d,
ct::tile<T, ct::shape<N>> e,
ct::tile<T, ct::shape<N, N>> V,
[[maybe_unused]] multiply_vectors_t job,
)#

Solve the symmetric tridiagonal eigensystem and multiply its eigenvectors into input basis V. Returns (w, V_out, info).

Parameters:
  • d – Diagonal values with shape (N).

  • e – Off-diagonal values with padded shape (N).

  • V – Input basis with shape (N, N).

  • job – Selects multiplication of the eigenvectors into V.

Returns:

(w, V_out, info), where w has shape (N), V_out has shape (N, N), and info is scalar.

template<typename ATile, typename FillTag>
auto cusolverdx::tiles::eig_hermitian(
ATile A,
[[maybe_unused]] FillTag fill,
[[maybe_unused]] no_vectors_t job,
)#

Solve a real symmetric eigensystem using the selected triangle; A has shape (N, N), or (Batch, N, N) to solve Batch independent systems in one tile block. Returns (w, info) without eigenvectors, with one status per batch (scalar unbatched).

Parameters:
  • A – Symmetric matrix with shape (N, N) or (Batch, N, N).

  • fill – Selects the lower or upper triangle of A.

  • job – Selects eigenvalues without eigenvectors.

Returns:

(w, info), where w has shape (N) or (Batch, N) and info is scalar or has shape (Batch).

template<typename ATile, typename FillTag>
auto cusolverdx::tiles::eig_hermitian(
ATile A,
[[maybe_unused]] FillTag fill,
[[maybe_unused]] all_vectors_t job,
)#

Solve a real symmetric eigensystem using the selected triangle; A has shape (N, N), or (Batch, N, N) to solve Batch independent systems in one tile block. Returns eigenpairs (w, V, info) with one status per batch.

Parameters:
  • A – Symmetric matrix with shape (N, N) or (Batch, N, N).

  • fill – Selects the lower or upper triangle of A.

  • job – Selects all eigenvectors.

Returns:

(w, V, info), where w has shape (N) or (Batch, N), V has the shape of A, and info is scalar or has shape (Batch).

template<typename ATile, typename BTile, typename FillTag, int K>
auto cusolverdx::tiles::generalized_to_standard_eig_hermitian(
ATile A,
BTile B,
[[maybe_unused]] eig_type_t<K> problem_type,
[[maybe_unused]] FillTag fill,
)#

Reduce a generalized Hermitian-definite eigenproblem to a standard one, per batch entry when the operands carry a common leading batch dim. B is the Cholesky factor of the definite matrix, from cholesky_factor with the same fill tag. Returns the reduced matrix without an info result.

Parameters:
  • A – Problem matrix with shape (N, N) or (Batch, N, N).

  • B – Cholesky factor with the same shape as A.

  • problem_type – LAPACK problem type 1, 2, or 3.

  • fill – Selects the triangle containing the Cholesky factor in B.

Returns:

Reduced standard-problem matrix with the same shape as A.

template<typename ATile, typename BTile, typename FillTag, int K>
auto cusolverdx::tiles::generalized_eig_hermitian(
ATile A,
BTile B,
[[maybe_unused]] eig_type_t<K> problem_type,
[[maybe_unused]] FillTag fill,
[[maybe_unused]] no_vectors_t job,
)#

Solve a generalized Hermitian-definite eigenproblem without eigenvectors, per batch entry when the operands carry a common leading batch dim. B is the definite matrix itself and is factored internally. Returns (w, info) with one status per batch.

Parameters:
  • A – Problem matrix with shape (N, N) or (Batch, N, N).

  • B – Definite matrix with the same shape as A.

  • problem_type – LAPACK problem type 1, 2, or 3.

  • fill – Selects the lower or upper triangle of A and B.

  • job – Selects eigenvalues without eigenvectors.

Returns:

(w, info), where w has shape (N) or (Batch, N) and info is scalar or has shape (Batch).

template<typename ATile, typename BTile, typename FillTag, int K>
auto cusolverdx::tiles::generalized_eig_hermitian(
ATile A,
BTile B,
[[maybe_unused]] eig_type_t<K> problem_type,
[[maybe_unused]] FillTag fill,
[[maybe_unused]] all_vectors_t job,
)#

Solve a generalized Hermitian-definite eigenproblem and compute vectors, per batch entry when the operands carry a common leading batch dim. B is the definite matrix itself and is factored internally. Returns eigenpairs (w, V, info) with one status per batch.

Parameters:
  • A – Problem matrix with shape (N, N) or (Batch, N, N).

  • B – Definite matrix with the same shape as A.

  • problem_type – LAPACK problem type 1, 2, or 3.

  • fill – Selects the lower or upper triangle of A and B.

  • job – Selects all eigenvectors.

Returns:

(w, V, info), where w has shape (N) or (Batch, N), V has the shape of A, and info is scalar or has shape (Batch).

template<typename T, size_t N, typename JobUTag, typename JobVTTag>
auto cusolverdx::tiles::svd_bidiagonal(
ct::tile<T, ct::shape<N>> d,
ct::tile<T, ct::shape<N>> e,
[[maybe_unused]] JobUTag jobu,
[[maybe_unused]] JobVTTag jobvt,
)#

Compute the SVD of the upper-bidiagonal matrix represented by d and e; e[i] is the superdiagonal entry in row i and its final element is padding. Paired no-vector jobs return (S, info); paired full/thin jobs return (U, S, Vt, info).

Parameters:
  • d – Diagonal values with shape (N).

  • e – Superdiagonal values with padded shape (N).

  • jobu – Selects no, thin, or all left singular vectors.

  • jobvt – Selects no, thin, or all right singular vectors.

Returns:

(S, info) for paired no-vector jobs; otherwise (U, S, Vt, info). S has shape (N), U and Vt have shape (N, N), and info is scalar.

template<typename T, size_t N, typename JobUTag, typename JobVTTag>
auto cusolverdx::tiles::svd_bidiagonal(
ct::tile<T, ct::shape<N>> d,
ct::tile<T, ct::shape<N>> e,
[[maybe_unused]] JobUTag jobu,
[[maybe_unused]] JobVTTag jobvt,
ct::tile<T, ct::shape<N, N>> U0,
ct::tile<T, ct::shape<N, N>> Vt0,
)#

Compute a bidiagonal SVD and multiply its vectors into bases U0 and Vt0. Both jobs must be multiply_vectors; returns (U, S, Vt, info).

Parameters:
  • d – Diagonal values with shape (N).

  • e – Superdiagonal values with padded shape (N).

  • jobu – Selects multiplication of left singular vectors into U0.

  • jobvt – Selects multiplication of right singular vectors into Vt0.

  • U0 – Left input basis with shape (N, N).

  • Vt0 – Right input basis with shape (N, N).

Returns:

(U, S, Vt, info), where U and Vt have shape (N, N), S has shape (N), and info is scalar.

template<typename ATile, typename JobUTag, typename JobVTTag>
auto cusolverdx::tiles::svd(
ATile A,
[[maybe_unused]] JobUTag jobu,
[[maybe_unused]] JobVTTag jobvt,
)#

Compute singular values and optionally left and right singular vectors; A has shape (M, N), or (Batch, M, N) to decompose Batch independent matrices in one tile block. With both jobs no_vectors, returns (S, info). Otherwise returns (U, S, Vt, info). For \(R = \min(M, N)\), each U is M-by-R or M-by-M and each Vt is R-by-N or N-by-N for some_vectors or all_vectors, respectively. info holds one status per batch (scalar unbatched).

Parameters:
  • A – Matrix with shape (M, N) or (Batch, M, N).

  • jobu – Selects no, thin, or all left singular vectors.

  • jobvt – Selects no, thin, or all right singular vectors.

Returns:

(S, info) for paired no-vector jobs; otherwise (U, S, Vt, info). S has shape (R) or (Batch, R), U has matrix shape (M, R) or (M, M), Vt has matrix shape (R, N) or (N, N), and info is scalar or has shape (Batch).

template<typename ATile, typename BTile, typename TransTag = no_trans_t>
auto cusolverdx::tiles::least_squares_solve(
ATile A,
BTile B,
[[maybe_unused]] TransTag trans = {},
)#

Solve \(\min_X \lVert \operatorname{op}(A) X - B \rVert_2\) with the selected transpose tag, per batch entry when the operands carry a common leading batch dim. B has as many rows as \(\operatorname{op}(A)\); underdetermined systems use the minimum-norm solution. Defaults to no transpose and returns reusable (factors, tau, X) and no info.

Parameters:
  • A – Coefficient matrix with shape (M, N) or (Batch, M, N).

  • B – Right-hand sides with shape (M, K) when \(\operatorname{op}(A) = A\) or (N, K) when \(\operatorname{op}(A) = A^T\), optionally prefixed by Batch.

  • trans – Selects \(\operatorname{op}(A)\) as \(A\) or \(A^T\).

Returns:

(factors, tau, X), where factors has the shape of A, tau has shape (R) or (Batch, R) for \(R = \min(M, N)\), and X has matrix shape (N, K) without transpose or (M, K) with transpose, preserving any batch extent.

struct all_vectors_t#
#include <cusolverdx_tile.hpp>

Compute all eigenvectors or singular vectors.

template<int K>
struct eig_type_t#
#include <cusolverdx_tile.hpp>

The LAPACK itype of a generalized Hermitian-definite eigenproblem, as a tag argument: eig_type<1> is \(A x = \lambda B x\), eig_type<2> is \(A B x = \lambda x\), and eig_type<3> is \(B A x = \lambda x\).

struct left_t#
#include <cusolverdx_tile.hpp>

Apply an implicit Q or triangular matrix from the left.

struct lower_t#
#include <cusolverdx_tile.hpp>

Select the lower triangle of symmetric or triangular input.

struct multiply_vectors_t#
#include <cusolverdx_tile.hpp>

Multiply vectors into supplied input bases.

struct no_pivot_t#
#include <cusolverdx_tile.hpp>

Select no pivoting for an LU operation.

struct no_trans_t#
#include <cusolverdx_tile.hpp>

Define \(\operatorname{op}(A) = A\).

struct no_vectors_t#
#include <cusolverdx_tile.hpp>

Compute no eigenvectors or singular vectors.

struct partial_pivot_t#
#include <cusolverdx_tile.hpp>

Select partial pivoting for an LU operation.

struct right_t#
#include <cusolverdx_tile.hpp>

Apply an implicit Q or triangular matrix from the right.

struct some_vectors_t#
#include <cusolverdx_tile.hpp>

Compute the thin set of singular vectors.

struct trans_t#
#include <cusolverdx_tile.hpp>

Define \(\operatorname{op}(A) = A^T\).

struct upper_t#
#include <cusolverdx_tile.hpp>

Select the upper triangle of symmetric or triangular input.