singe_cusolver/

dense.rs

#[allow(unused_imports)]
use crate::error::Status;

use singe_cuda::{
    data_type::{DataType, DataTypeLike},
    memory::DeviceMemory,
    types::{Complex32, Complex64},
};

use crate::{
    context::Context,
    error::{Error, Result},
    layout::{
        BatchedMatrixRef, BatchedVectorRef, ByteWorkspaceMut, MatrixMut, MatrixRef, VectorMut,
        VectorRef, WorkspaceSizes,
    },
    params::Params,
    sys, try_ffi,
    types::{DiagonalType, DirectMode, FillMode, Operation, SideMode, StorevMode},
    utility::{to_i32, to_i64, to_usize},
};

pub fn spotrf_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSpotrf_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dpotrf_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDpotrf_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn cpotrf_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCpotrf_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zpotrf_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZpotrf_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the Cholesky factorization of a Hermitian positive-definite matrix.
///
/// `A` is an $n \times n$ Hermitian matrix, only the lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The other triangular part is left unchanged.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed, and replaced by the lower triangular Cholesky factor `L`.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular Cholesky factor `U`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If Cholesky factorization failed, that is, some leading minor of `A` is not positive definite, or equivalently some diagonal elements of `L` or `U` are not real.
/// `dev_info` reports the smallest leading minor of `A` that is not positive definite.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn spotrf(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    let lwork = spotrf_buffer_size(ctx, fill_mode, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSpotrf(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the Cholesky factorization of a Hermitian positive-definite matrix.
///
/// `A` is an $n \times n$ Hermitian matrix, only the lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The other triangular part is left unchanged.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed, and replaced by the lower triangular Cholesky factor `L`.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular Cholesky factor `U`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If Cholesky factorization failed, that is, some leading minor of `A` is not positive definite, or equivalently some diagonal elements of `L` or `U` are not real.
/// `dev_info` reports the smallest leading minor of `A` that is not positive definite.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn dpotrf(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    let lwork = dpotrf_buffer_size(ctx, fill_mode, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDpotrf(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the Cholesky factorization of a Hermitian positive-definite matrix.
///
/// `A` is an $n \times n$ Hermitian matrix, only the lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The other triangular part is left unchanged.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed, and replaced by the lower triangular Cholesky factor `L`.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular Cholesky factor `U`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If Cholesky factorization failed, that is, some leading minor of `A` is not positive definite, or equivalently some diagonal elements of `L` or `U` are not real.
/// `dev_info` reports the smallest leading minor of `A` that is not positive definite.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn cpotrf(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    let lwork = cpotrf_buffer_size(ctx, fill_mode, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCpotrf(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the Cholesky factorization of a Hermitian positive-definite matrix.
///
/// `A` is an $n \times n$ Hermitian matrix, only the lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The other triangular part is left unchanged.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed, and replaced by the lower triangular Cholesky factor `L`.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular Cholesky factor `U`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If Cholesky factorization failed, that is, some leading minor of `A` is not positive definite, or equivalently some diagonal elements of `L` or `U` are not real.
/// `dev_info` reports the smallest leading minor of `A` that is not positive definite.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn zpotrf(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    let lwork = zpotrf_buffer_size(ctx, fill_mode, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZpotrf(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Solves a system of linear equations
///
/// where `A` is an $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The other triangular part is left unchanged.
///
/// Call `potrf` first to factorize matrix `A`.
/// If `fill_mode` is [`FillMode::Lower`], `A` is lower triangular Cholesky factor `L` corresponding to $A = L\cdot L^H$.
/// If `fill_mode` is [`FillMode::Upper`], `A` is upper triangular Cholesky factor `U` corresponding to $A = U^{H}\cdot U$.
///
/// The operation is in-place, that is, matrix `X` overwrites matrix `B` with the same leading dimension `ldb`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, right-hand-side count, or leading dimensions are
/// invalid, if the current GPU architecture is unsupported, or if cuSOLVER
/// reports an internal failure.
pub fn spotrs(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    nrhs: usize,
    a: &DeviceMemory<f32>,
    lda: usize,
    b: &mut DeviceMemory<f32>,
    ldb: usize,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    validate_matrix(n, nrhs, b.len(), ldb)?;
    require_info_buffer(dev_info)?;
    unsafe {
        try_ffi!(sys::cusolverDnSpotrs(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            to_i32(nrhs, "nrhs")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            b.as_mut_ptr().cast(),
            to_i32(ldb, "ldb")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Solves a system of linear equations
///
/// where `A` is an $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The other triangular part is left unchanged.
///
/// Call `potrf` first to factorize matrix `A`.
/// If `fill_mode` is [`FillMode::Lower`], `A` is lower triangular Cholesky factor `L` corresponding to $A = L\cdot L^H$.
/// If `fill_mode` is [`FillMode::Upper`], `A` is upper triangular Cholesky factor `U` corresponding to $A = U^{H}\cdot U$.
///
/// The operation is in-place, that is, matrix `X` overwrites matrix `B` with the same leading dimension `ldb`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, right-hand-side count, or leading dimensions are
/// invalid, if the current GPU architecture is unsupported, or if cuSOLVER
/// reports an internal failure.
pub fn dpotrs(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    nrhs: usize,
    a: &DeviceMemory<f64>,
    lda: usize,
    b: &mut DeviceMemory<f64>,
    ldb: usize,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    validate_matrix(n, nrhs, b.len(), ldb)?;
    require_info_buffer(dev_info)?;
    unsafe {
        try_ffi!(sys::cusolverDnDpotrs(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            to_i32(nrhs, "nrhs")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            b.as_mut_ptr().cast(),
            to_i32(ldb, "ldb")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Solves a system of linear equations
///
/// where `A` is an $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The other triangular part is left unchanged.
///
/// Call `potrf` first to factorize matrix `A`.
/// If `fill_mode` is [`FillMode::Lower`], `A` is lower triangular Cholesky factor `L` corresponding to $A = L\cdot L^H$.
/// If `fill_mode` is [`FillMode::Upper`], `A` is upper triangular Cholesky factor `U` corresponding to $A = U^{H}\cdot U$.
///
/// The operation is in-place, that is, matrix `X` overwrites matrix `B` with the same leading dimension `ldb`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, right-hand-side count, or leading dimensions are
/// invalid, if the current GPU architecture is unsupported, or if cuSOLVER
/// reports an internal failure.
pub fn cpotrs(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    nrhs: usize,
    a: &DeviceMemory<Complex32>,
    lda: usize,
    b: &mut DeviceMemory<Complex32>,
    ldb: usize,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    validate_matrix(n, nrhs, b.len(), ldb)?;
    require_info_buffer(dev_info)?;
    unsafe {
        try_ffi!(sys::cusolverDnCpotrs(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            to_i32(nrhs, "nrhs")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            b.as_mut_ptr().cast(),
            to_i32(ldb, "ldb")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Solves a system of linear equations
///
/// where `A` is an $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The other triangular part is left unchanged.
///
/// Call `potrf` first to factorize matrix `A`.
/// If `fill_mode` is [`FillMode::Lower`], `A` is lower triangular Cholesky factor `L` corresponding to $A = L\cdot L^H$.
/// If `fill_mode` is [`FillMode::Upper`], `A` is upper triangular Cholesky factor `U` corresponding to $A = U^{H}\cdot U$.
///
/// The operation is in-place, that is, matrix `X` overwrites matrix `B` with the same leading dimension `ldb`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, right-hand-side count, or leading dimensions are
/// invalid, if the current GPU architecture is unsupported, or if cuSOLVER
/// reports an internal failure.
pub fn zpotrs(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    nrhs: usize,
    a: &DeviceMemory<Complex64>,
    lda: usize,
    b: &mut DeviceMemory<Complex64>,
    ldb: usize,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    validate_matrix(n, nrhs, b.len(), ldb)?;
    require_info_buffer(dev_info)?;
    unsafe {
        try_ffi!(sys::cusolverDnZpotrs(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            to_i32(nrhs, "nrhs")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            b.as_mut_ptr().cast(),
            to_i32(ldb, "ldb")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the Cholesky factorization of a sequence of Hermitian positive-definite matrices.
///
/// Each `a[i]` for `i = 0, 1, ..., batch_size - 1` is a $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular Cholesky factor `L`.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular Cholesky factor `U`.
///
/// If Cholesky factorization failed, that is, some leading minor of `A` is not positive definite, or equivalently some diagonal elements of `L` or `U` are not real.
/// `info` contains one entry per matrix and reports the smallest leading minor of `A` that is not positive definite.
///
/// `info` must have one integer entry for each matrix in the batch.
/// If cuSOLVER reports [`Status::InvalidValue`], `info[0] == -i` indicates that the `i`th parameter is invalid.
/// If `potrf_batched` returns [`Ok`] and `info[i] == k` is positive, the `i`th matrix is not positive definite and the Cholesky factorization failed at row `k`.
///
/// The other part of `A` is used as workspace.
/// For example, if `fill_mode` is [`FillMode::Upper`], upper triangle of `A` contains Cholesky factor `U` and lower triangle of `A` is destroyed after `potrf_batched`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, leading dimension, or batch size are invalid, or if
/// cuSOLVER reports an internal failure.
pub fn spotrf_batched(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: BatchedMatrixRef<'_, f32>,
    info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_batched_square_matrix_pointers(n, a)?;
    require_info_entries(info, a.len())?;
    unsafe {
        try_ffi!(sys::cusolverDnSpotrfBatched(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr(),
            to_i32(a.leading_dimension, "lda")?,
            info.as_mut_ptr().cast(),
            to_i32(a.len(), "batch_size")?,
        ))?;
    }
    Ok(())
}

/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the Cholesky factorization of a sequence of Hermitian positive-definite matrices.
///
/// Each `a[i]` for `i = 0, 1, ..., batch_size - 1` is a $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular Cholesky factor `L`.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular Cholesky factor `U`.
///
/// If Cholesky factorization failed, that is, some leading minor of `A` is not positive definite, or equivalently some diagonal elements of `L` or `U` are not real.
/// `info` contains one entry per matrix and reports the smallest leading minor of `A` that is not positive definite.
///
/// `info` must have one integer entry for each matrix in the batch.
/// If cuSOLVER reports [`Status::InvalidValue`], `info[0] == -i` indicates that the `i`th parameter is invalid.
/// If `potrf_batched` returns [`Ok`] and `info[i] == k` is positive, the `i`th matrix is not positive definite and the Cholesky factorization failed at row `k`.
///
/// The other part of `A` is used as workspace.
/// For example, if `fill_mode` is [`FillMode::Upper`], upper triangle of `A` contains Cholesky factor `U` and lower triangle of `A` is destroyed after `potrf_batched`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, leading dimension, or batch size are invalid, or if
/// cuSOLVER reports an internal failure.
pub fn dpotrf_batched(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: BatchedMatrixRef<'_, f64>,
    info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_batched_square_matrix_pointers(n, a)?;
    require_info_entries(info, a.len())?;
    unsafe {
        try_ffi!(sys::cusolverDnDpotrfBatched(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr(),
            to_i32(a.leading_dimension, "lda")?,
            info.as_mut_ptr().cast(),
            to_i32(a.len(), "batch_size")?,
        ))?;
    }
    Ok(())
}

/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the Cholesky factorization of a sequence of Hermitian positive-definite matrices.
///
/// Each `a[i]` for `i = 0, 1, ..., batch_size - 1` is a $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular Cholesky factor `L`.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular Cholesky factor `U`.
///
/// If Cholesky factorization failed, that is, some leading minor of `A` is not positive definite, or equivalently some diagonal elements of `L` or `U` are not real.
/// `info` contains one entry per matrix and reports the smallest leading minor of `A` that is not positive definite.
///
/// `info` must have one integer entry for each matrix in the batch.
/// If cuSOLVER reports [`Status::InvalidValue`], `info[0] == -i` indicates that the `i`th parameter is invalid.
/// If `potrf_batched` returns [`Ok`] and `info[i] == k` is positive, the `i`th matrix is not positive definite and the Cholesky factorization failed at row `k`.
///
/// The other part of `A` is used as workspace.
/// For example, if `fill_mode` is [`FillMode::Upper`], upper triangle of `A` contains Cholesky factor `U` and lower triangle of `A` is destroyed after `potrf_batched`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, leading dimension, or batch size are invalid, or if
/// cuSOLVER reports an internal failure.
pub fn cpotrf_batched(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: BatchedMatrixRef<'_, Complex32>,
    info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_batched_square_matrix_pointers(n, a)?;
    require_info_entries(info, a.len())?;
    unsafe {
        try_ffi!(sys::cusolverDnCpotrfBatched(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(a.leading_dimension, "lda")?,
            info.as_mut_ptr().cast(),
            to_i32(a.len(), "batch_size")?,
        ))?;
    }
    Ok(())
}

/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the Cholesky factorization of a sequence of Hermitian positive-definite matrices.
///
/// Each `a[i]` for `i = 0, 1, ..., batch_size - 1` is a $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular Cholesky factor `L`.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular Cholesky factor `U`.
///
/// If Cholesky factorization failed, that is, some leading minor of `A` is not positive definite, or equivalently some diagonal elements of `L` or `U` are not real.
/// `info` contains one entry per matrix and reports the smallest leading minor of `A` that is not positive definite.
///
/// `info` must have one integer entry for each matrix in the batch.
/// If cuSOLVER reports [`Status::InvalidValue`], `info[0] == -i` indicates that the `i`th parameter is invalid.
/// If `potrf_batched` returns [`Ok`] and `info[i] == k` is positive, the `i`th matrix is not positive definite and the Cholesky factorization failed at row `k`.
///
/// The other part of `A` is used as workspace.
/// For example, if `fill_mode` is [`FillMode::Upper`], upper triangle of `A` contains Cholesky factor `U` and lower triangle of `A` is destroyed after `potrf_batched`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, leading dimension, or batch size are invalid, or if
/// cuSOLVER reports an internal failure.
pub fn zpotrf_batched(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: BatchedMatrixRef<'_, Complex64>,
    info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_batched_square_matrix_pointers(n, a)?;
    require_info_entries(info, a.len())?;
    unsafe {
        try_ffi!(sys::cusolverDnZpotrfBatched(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(a.leading_dimension, "lda")?,
            info.as_mut_ptr().cast(),
            to_i32(a.len(), "batch_size")?,
        ))?;
    }
    Ok(())
}

/// Solves a sequence of linear systems
///
/// where each `a[i]` for `i = 0, 1, ..., batch_size - 1` is a $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
///
/// Call `potrf_batched` first to factorize matrix `a[i]`.
/// If `fill_mode` is [`FillMode::Lower`], `A` is lower triangular Cholesky factor `L` corresponding to $A = L\cdot L^{H}$.
/// If `fill_mode` is [`FillMode::Upper`], `A` is upper triangular Cholesky factor `U` corresponding to $A = U^{H}\cdot U$.
///
/// The operation is in-place, that is, matrix `X` overwrites matrix `B` with the same leading dimension `ldb`.
///
/// `info` is a single status value for the whole batched call.
/// If the reported `info` value is `-i`, the `i`th parameter is invalid.
///
/// - only `nrhs=1` is supported.
///
/// - `info` from `potrf_batched` indicates whether each matrix is positive definite.
///   `info` from `potrsBatched` only reports invalid arguments for the batched call.
///
/// - the other part of `A` is used as a workspace.
///   For example, if `fill_mode` is [`FillMode::Upper`], upper triangle of `A` contains Cholesky factor `U` and lower triangle of `A` is destroyed after `potrsBatched`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, right-hand-side count, leading dimensions, or batch
/// size are invalid, or if cuSOLVER reports an internal failure.
pub fn spotrs_batched(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: BatchedMatrixRef<'_, f32>,
    b: BatchedVectorRef<'_, f32>,
    info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_batched_square_matrix_pointers(n, a)?;
    validate_batched_vector_pointers(n, b)?;
    require_info_buffer(info)?;
    if a.len() != b.len() {
        return Err(Error::InvalidMatrixShape);
    }
    unsafe {
        try_ffi!(sys::cusolverDnSpotrsBatched(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            1,
            a.as_mut_ptr(),
            to_i32(a.leading_dimension, "lda")?,
            b.as_mut_ptr(),
            to_i32(b.leading_dimension, "ldb")?,
            info.as_mut_ptr().cast(),
            to_i32(a.len(), "batch_size")?,
        ))?;
    }
    Ok(())
}

/// Solves a sequence of linear systems
///
/// where each `a[i]` for `i = 0, 1, ..., batch_size - 1` is a $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
///
/// Call `potrf_batched` first to factorize matrix `a[i]`.
/// If `fill_mode` is [`FillMode::Lower`], `A` is lower triangular Cholesky factor `L` corresponding to $A = L\cdot L^{H}$.
/// If `fill_mode` is [`FillMode::Upper`], `A` is upper triangular Cholesky factor `U` corresponding to $A = U^{H}\cdot U$.
///
/// The operation is in-place, that is, matrix `X` overwrites matrix `B` with the same leading dimension `ldb`.
///
/// `info` is a single status value for the whole batched call.
/// If the reported `info` value is `-i`, the `i`th parameter is invalid.
///
/// - only `nrhs=1` is supported.
///
/// - `info` from `potrf_batched` indicates whether each matrix is positive definite.
///   `info` from `potrsBatched` only reports invalid arguments for the batched call.
///
/// - the other part of `A` is used as a workspace.
///   For example, if `fill_mode` is [`FillMode::Upper`], upper triangle of `A` contains Cholesky factor `U` and lower triangle of `A` is destroyed after `potrsBatched`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, right-hand-side count, leading dimensions, or batch
/// size are invalid, or if cuSOLVER reports an internal failure.
pub fn dpotrs_batched(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: BatchedMatrixRef<'_, f64>,
    b: BatchedVectorRef<'_, f64>,
    info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_batched_square_matrix_pointers(n, a)?;
    validate_batched_vector_pointers(n, b)?;
    require_info_buffer(info)?;
    if a.len() != b.len() {
        return Err(Error::InvalidMatrixShape);
    }
    unsafe {
        try_ffi!(sys::cusolverDnDpotrsBatched(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            1,
            a.as_mut_ptr(),
            to_i32(a.leading_dimension, "lda")?,
            b.as_mut_ptr(),
            to_i32(b.leading_dimension, "ldb")?,
            info.as_mut_ptr().cast(),
            to_i32(a.len(), "batch_size")?,
        ))?;
    }
    Ok(())
}

/// Solves a sequence of linear systems
///
/// where each `a[i]` for `i = 0, 1, ..., batch_size - 1` is a $n \times n$ Hermitian matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
///
/// Call `potrf_batched` first to factorize matrix `a[i]`.
/// If `fill_mode` is [`FillMode::Lower`], `A` is lower triangular Cholesky factor `L` corresponding to $A = L\cdot L^{H}$.
/// If `fill_mode` is [`FillMode::Upper`], `A` is upper triangular Cholesky factor `U` corresponding to $A = U^{H}\cdot U$.
///
/// The operation is in-place, that is, matrix `X` overwrites matrix `B` with the same leading dimension `ldb`.
///
/// `info` is a single status value for the whole batched call.
/// If the reported `info` value is `-i`, the `i`th parameter is invalid.
///
/// - only `nrhs=1` is supported.
///
/// - `info` from `potrf_batched` indicates whether each matrix is positive definite.
///   `info` from `potrsBatched` only reports invalid arguments for the batched call.
///
/// - the other part of `A` is used as a workspace.
///   For example, if `fill_mode` is [`FillMode::Upper`], upper triangle of `A` contains Cholesky factor `U` and lower triangle of `A` is destroyed after `potrsBatched`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, right-hand-side count, leading dimensions, or batch
/// size are invalid, or if cuSOLVER reports an internal failure.
pub fn zpotrs_batched(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: BatchedMatrixRef<'_, Complex64>,
    b: BatchedVectorRef<'_, Complex64>,
    info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_batched_square_matrix_pointers(n, a)?;
    validate_batched_vector_pointers(n, b)?;
    require_info_buffer(info)?;
    if a.len() != b.len() {
        return Err(Error::InvalidMatrixShape);
    }
    unsafe {
        try_ffi!(sys::cusolverDnZpotrsBatched(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            1,
            a.as_mut_ptr().cast(),
            to_i32(a.leading_dimension, "lda")?,
            b.as_mut_ptr().cast(),
            to_i32(b.leading_dimension, "ldb")?,
            info.as_mut_ptr().cast(),
            to_i32(a.len(), "batch_size")?,
        ))?;
    }
    Ok(())
}

pub fn spotri_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSpotri_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dpotri_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDpotri_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn cpotri_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCpotri_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zpotri_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZpotri_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the inverse of a positive-definite matrix `A` using the Cholesky factorization
///
/// computed by `potrf()`.
///
/// `A` is an $n \times n$ matrix containing the triangular factor `L` or `U` computed by the Cholesky factorization.
/// Only the lower or upper part is meaningful, as selected by `fill_mode`.
/// The other triangular part is left unchanged.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular part of the inverse.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular part of the inverse.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If the inverse computation fails because a leading minor of `L` or `U` is singular, `dev_info` indicates the smallest leading minor that is not positive definite.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn spotri(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    let lwork = spotri_buffer_size(ctx, fill_mode, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSpotri(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the inverse of a positive-definite matrix `A` using the Cholesky factorization
///
/// computed by `potrf()`.
///
/// `A` is an $n \times n$ matrix containing the triangular factor `L` or `U` computed by the Cholesky factorization.
/// Only the lower or upper part is meaningful, as selected by `fill_mode`.
/// The other triangular part is left unchanged.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular part of the inverse.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular part of the inverse.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If the inverse computation fails because a leading minor of `L` or `U` is singular, `dev_info` indicates the smallest leading minor that is not positive definite.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn dpotri(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    let lwork = dpotri_buffer_size(ctx, fill_mode, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDpotri(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the inverse of a positive-definite matrix `A` using the Cholesky factorization
///
/// computed by `potrf()`.
///
/// `A` is an $n \times n$ matrix containing the triangular factor `L` or `U` computed by the Cholesky factorization.
/// Only the lower or upper part is meaningful, as selected by `fill_mode`.
/// The other triangular part is left unchanged.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular part of the inverse.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular part of the inverse.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If the inverse computation fails because a leading minor of `L` or `U` is singular, `dev_info` indicates the smallest leading minor that is not positive definite.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn cpotri(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    let lwork = cpotri_buffer_size(ctx, fill_mode, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCpotri(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the inverse of a positive-definite matrix `A` using the Cholesky factorization
///
/// computed by `potrf()`.
///
/// `A` is an $n \times n$ matrix containing the triangular factor `L` or `U` computed by the Cholesky factorization.
/// Only the lower or upper part is meaningful, as selected by `fill_mode`.
/// The other triangular part is left unchanged.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular part of the inverse.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular part of the inverse.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If the inverse computation fails because a leading minor of `L` or `U` is singular, `dev_info` indicates the smallest leading minor that is not positive definite.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn zpotri(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    let lwork = zpotri_buffer_size(ctx, fill_mode, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZpotri(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn sgetrf_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSgetrf_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dgetrf_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDgetrf_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn cgetrf_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCgetrf_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zgetrf_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZgetrf_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the LU factorization of an $m \times n$ matrix
///
/// where `A` is an $m \times n$ matrix, `P` is a permutation matrix, `L` is a lower triangular matrix with unit diagonal, and `U` is an upper triangular matrix.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If LU factorization failed, that is, matrix `A` (`U`) is singular, `dev_info = i` indicates `U(i,i) = 0`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// If `pivots` is `None`, no pivoting is performed.
/// The factorization is `A=L*U`, which is not numerically stable.
///
/// Whether LU factorization succeeds or fails, `pivots` contains the pivoting
/// sequence. Row `i` is interchanged with row `pivots[i]`.
///
/// Callers can combine `getrf` and `getrs` to complete a linear solver.
///
/// `getrf` uses the fastest implementation with a large workspace of size `m * n`.
/// Callers can choose the legacy implementation with minimal workspace by calling [`Params::set_adv_options`] with [`Function::Getrf`](crate::types::Function::Getrf) and [`AlgorithmMode::Algorithm1`](crate::types::AlgorithmMode::Algorithm1).
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn sgetrf(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    workspace: &mut DeviceMemory<f32>,
    pivots: Option<&mut DeviceMemory<i32>>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    if let Some(pivots) = pivots.as_ref() {
        require_pivot_buffer(pivots, m.min(n))?;
    }
    let lwork = sgetrf_buffer_size(ctx, m, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSgetrf(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            pivots.map_or(std::ptr::null_mut(), |p| p.as_mut_ptr()),
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the LU factorization of an $m \times n$ matrix
///
/// where `A` is an $m \times n$ matrix, `P` is a permutation matrix, `L` is a lower triangular matrix with unit diagonal, and `U` is an upper triangular matrix.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If LU factorization failed, that is, matrix `A` (`U`) is singular, `dev_info = i` indicates `U(i,i) = 0`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// If `pivots` is `None`, no pivoting is performed.
/// The factorization is `A=L*U`, which is not numerically stable.
///
/// Whether LU factorization succeeds or fails, `pivots` contains the pivoting
/// sequence. Row `i` is interchanged with row `pivots[i]`.
///
/// Callers can combine `getrf` and `getrs` to complete a linear solver.
///
/// `getrf` uses the fastest implementation with a large workspace of size `m * n`.
/// Callers can choose the legacy implementation with minimal workspace by calling [`Params::set_adv_options`] with [`Function::Getrf`](crate::types::Function::Getrf) and [`AlgorithmMode::Algorithm1`](crate::types::AlgorithmMode::Algorithm1).
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn dgetrf(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    workspace: &mut DeviceMemory<f64>,
    pivots: Option<&mut DeviceMemory<i32>>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    if let Some(pivots) = pivots.as_ref() {
        require_pivot_buffer(pivots, m.min(n))?;
    }
    let lwork = dgetrf_buffer_size(ctx, m, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDgetrf(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            pivots.map_or(std::ptr::null_mut(), |p| p.as_mut_ptr()),
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the LU factorization of an $m \times n$ matrix
///
/// where `A` is an $m \times n$ matrix, `P` is a permutation matrix, `L` is a lower triangular matrix with unit diagonal, and `U` is an upper triangular matrix.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If LU factorization failed, that is, matrix `A` (`U`) is singular, `dev_info = i` indicates `U(i,i) = 0`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// If `pivots` is `None`, no pivoting is performed.
/// The factorization is `A=L*U`, which is not numerically stable.
///
/// Whether LU factorization succeeds or fails, `pivots` contains the pivoting
/// sequence. Row `i` is interchanged with row `pivots[i]`.
///
/// Callers can combine `getrf` and `getrs` to complete a linear solver.
///
/// `getrf` uses the fastest implementation with a large workspace of size `m * n`.
/// Callers can choose the legacy implementation with minimal workspace by calling [`Params::set_adv_options`] with [`Function::Getrf`](crate::types::Function::Getrf) and [`AlgorithmMode::Algorithm1`](crate::types::AlgorithmMode::Algorithm1).
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn cgetrf(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    workspace: &mut DeviceMemory<Complex32>,
    pivots: Option<&mut DeviceMemory<i32>>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    if let Some(pivots) = pivots.as_ref() {
        require_pivot_buffer(pivots, m.min(n))?;
    }
    let lwork = cgetrf_buffer_size(ctx, m, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCgetrf(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            pivots.map_or(std::ptr::null_mut(), |p| p.as_mut_ptr()),
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the LU factorization of an $m \times n$ matrix
///
/// where `A` is an $m \times n$ matrix, `P` is a permutation matrix, `L` is a lower triangular matrix with unit diagonal, and `U` is an upper triangular matrix.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If LU factorization failed, that is, matrix `A` (`U`) is singular, `dev_info = i` indicates `U(i,i) = 0`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// If `pivots` is `None`, no pivoting is performed.
/// The factorization is `A=L*U`, which is not numerically stable.
///
/// Whether LU factorization succeeds or fails, `pivots` contains the pivoting
/// sequence. Row `i` is interchanged with row `pivots[i]`.
///
/// Callers can combine `getrf` and `getrs` to complete a linear solver.
///
/// `getrf` uses the fastest implementation with a large workspace of size `m * n`.
/// Callers can choose the legacy implementation with minimal workspace by calling [`Params::set_adv_options`] with [`Function::Getrf`](crate::types::Function::Getrf) and [`AlgorithmMode::Algorithm1`](crate::types::AlgorithmMode::Algorithm1).
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn zgetrf(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    workspace: &mut DeviceMemory<Complex64>,
    pivots: Option<&mut DeviceMemory<i32>>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_info_buffer(dev_info)?;
    if let Some(pivots) = pivots.as_ref() {
        require_pivot_buffer(pivots, m.min(n))?;
    }
    let lwork = zgetrf_buffer_size(ctx, m, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZgetrf(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            workspace.as_mut_ptr().cast(),
            pivots.map_or(std::ptr::null_mut(), |p| p.as_mut_ptr()),
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

///
/// Solves a linear system of multiple right-hand sides
///
/// where `A` is an $n \times n$ matrix, and was LU-factored by `getrf`, that is, lower triangular part of A is `L`, and upper triangular part (including diagonal elements) of `A` is `U`.
/// `B` is an $n\times {nrhs}$ right-hand side matrix.
///
/// The `operation` argument is described by [`Operation`].
///
/// `pivots` is returned by the matching `getrf` operation.
/// It contains pivot indices, which are used to permute right-hand sides.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// Callers can combine `getrf` and `getrs` to complete a linear solver.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimensions are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn sgetrs(
    ctx: &Context,
    operation: Operation,
    n: usize,
    nrhs: usize,
    a: &DeviceMemory<f32>,
    lda: usize,
    pivots: &DeviceMemory<i32>,
    b: &mut DeviceMemory<f32>,
    ldb: usize,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    validate_matrix(n, nrhs, b.len(), ldb)?;
    require_pivot_buffer(pivots, n)?;
    require_info_buffer(dev_info)?;
    unsafe {
        try_ffi!(sys::cusolverDnSgetrs(
            ctx.as_raw(),
            operation.into(),
            to_i32(n, "n")?,
            to_i32(nrhs, "nrhs")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            pivots.as_ptr().cast(),
            b.as_mut_ptr().cast(),
            to_i32(ldb, "ldb")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

///
/// Solves a linear system of multiple right-hand sides
///
/// where `A` is an $n \times n$ matrix, and was LU-factored by `getrf`, that is, lower triangular part of A is `L`, and upper triangular part (including diagonal elements) of `A` is `U`.
/// `B` is an $n\times {nrhs}$ right-hand side matrix.
///
/// The `operation` argument is described by [`Operation`].
///
/// `pivots` is returned by the matching `getrf` operation.
/// It contains pivot indices, which are used to permute right-hand sides.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// Callers can combine `getrf` and `getrs` to complete a linear solver.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimensions are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn dgetrs(
    ctx: &Context,
    operation: Operation,
    n: usize,
    nrhs: usize,
    a: &DeviceMemory<f64>,
    lda: usize,
    pivots: &DeviceMemory<i32>,
    b: &mut DeviceMemory<f64>,
    ldb: usize,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    validate_matrix(n, nrhs, b.len(), ldb)?;
    require_pivot_buffer(pivots, n)?;
    require_info_buffer(dev_info)?;
    unsafe {
        try_ffi!(sys::cusolverDnDgetrs(
            ctx.as_raw(),
            operation.into(),
            to_i32(n, "n")?,
            to_i32(nrhs, "nrhs")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            pivots.as_ptr().cast(),
            b.as_mut_ptr().cast(),
            to_i32(ldb, "ldb")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

///
/// Solves a linear system of multiple right-hand sides
///
/// where `A` is an $n \times n$ matrix, and was LU-factored by `getrf`, that is, lower triangular part of A is `L`, and upper triangular part (including diagonal elements) of `A` is `U`.
/// `B` is an $n\times {nrhs}$ right-hand side matrix.
///
/// The `operation` argument is described by [`Operation`].
///
/// `pivots` is returned by the matching `getrf` operation.
/// It contains pivot indices, which are used to permute right-hand sides.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// Callers can combine `getrf` and `getrs` to complete a linear solver.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimensions are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn cgetrs(
    ctx: &Context,
    operation: Operation,
    n: usize,
    nrhs: usize,
    a: &DeviceMemory<Complex32>,
    lda: usize,
    pivots: &DeviceMemory<i32>,
    b: &mut DeviceMemory<Complex32>,
    ldb: usize,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    validate_matrix(n, nrhs, b.len(), ldb)?;
    require_pivot_buffer(pivots, n)?;
    require_info_buffer(dev_info)?;
    unsafe {
        try_ffi!(sys::cusolverDnCgetrs(
            ctx.as_raw(),
            operation.into(),
            to_i32(n, "n")?,
            to_i32(nrhs, "nrhs")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            pivots.as_ptr().cast(),
            b.as_mut_ptr().cast(),
            to_i32(ldb, "ldb")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

///
/// Solves a linear system of multiple right-hand sides
///
/// where `A` is an $n \times n$ matrix, and was LU-factored by `getrf`, that is, lower triangular part of A is `L`, and upper triangular part (including diagonal elements) of `A` is `U`.
/// `B` is an $n\times {nrhs}$ right-hand side matrix.
///
/// The `operation` argument is described by [`Operation`].
///
/// `pivots` is returned by the matching `getrf` operation.
/// It contains pivot indices, which are used to permute right-hand sides.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// Callers can combine `getrf` and `getrs` to complete a linear solver.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimensions are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn zgetrs(
    ctx: &Context,
    operation: Operation,
    n: usize,
    nrhs: usize,
    a: &DeviceMemory<Complex64>,
    lda: usize,
    pivots: &DeviceMemory<i32>,
    b: &mut DeviceMemory<Complex64>,
    ldb: usize,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    validate_matrix(n, nrhs, b.len(), ldb)?;
    require_pivot_buffer(pivots, n)?;
    require_info_buffer(dev_info)?;
    unsafe {
        try_ffi!(sys::cusolverDnZgetrs(
            ctx.as_raw(),
            operation.into(),
            to_i32(n, "n")?,
            to_i32(nrhs, "nrhs")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            pivots.as_ptr().cast(),
            b.as_mut_ptr().cast(),
            to_i32(ldb, "ldb")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn ssytrf_buffer_size(
    ctx: &Context,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSsytrf_bufferSize(
            ctx.as_raw(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dsytrf_buffer_size(
    ctx: &Context,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDsytrf_bufferSize(
            ctx.as_raw(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn csytrf_buffer_size(
    ctx: &Context,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCsytrf_bufferSize(
            ctx.as_raw(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zsytrf_buffer_size(
    ctx: &Context,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZsytrf_bufferSize(
            ctx.as_raw(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the factorization of a symmetric indefinite matrix using the Bunch-Kaufman diagonal pivoting.
///
/// `A` is a $n \times n$ symmetric matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// If `pivots` is `None`, no pivoting is performed, which is not numerically stable.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular factor `L` and block diagonal matrix `D`.
/// Each block of `D` is either 1x1 or 2x2 block, depending on pivoting.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular factor `U` and block diagonal matrix `D`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
/// When no pivoting is performed, the other triangular part of the input matrix `A` is used as workspace.
///
/// If Bunch-Kaufman factorization failed, that is, `A` is singular,
/// `dev_info = i` indicates `D(i, i) = 0`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// `pivots` contains the pivoting sequence.
/// If `pivots[i] = k` with `k > 0`, `D(i, i)` is a 1x1 block, and row/column `i` of `A`
/// is interchanged with row/column `k`.
/// If `fill_mode` is [`FillMode::Upper`] and `pivots[i - 1] = pivots[i] = -m` with `m > 0`,
/// `D(i-1:i,i-1:i)` is a 2x2 block, and row/column `i - 1` is interchanged
/// with row/column `m`.
/// If `fill_mode` is [`FillMode::Lower`] and `pivots[i + 1] = pivots[i] = -m` with `m > 0`,
/// `D(i:i+1,i:i+1)` is a 2x2 block, and row/column `i + 1` is interchanged
/// with row/column `m`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn ssytrf(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    pivots: Option<&mut DeviceMemory<i32>>,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    if let Some(pivots) = pivots.as_ref() {
        require_pivot_buffer(pivots, n)?;
    }
    require_info_buffer(dev_info)?;
    let lwork = ssytrf_buffer_size(ctx, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSsytrf(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            pivots.map_or(std::ptr::null_mut(), |p| p.as_mut_ptr()),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the factorization of a symmetric indefinite matrix using the Bunch-Kaufman diagonal pivoting.
///
/// `A` is a $n \times n$ symmetric matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// If `pivots` is `None`, no pivoting is performed, which is not numerically stable.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular factor `L` and block diagonal matrix `D`.
/// Each block of `D` is either 1x1 or 2x2 block, depending on pivoting.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular factor `U` and block diagonal matrix `D`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
/// When no pivoting is performed, the other triangular part of the input matrix `A` is used as workspace.
///
/// If Bunch-Kaufman factorization failed, that is, `A` is singular,
/// `dev_info = i` indicates `D(i, i) = 0`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// `pivots` contains the pivoting sequence.
/// If `pivots[i] = k` with `k > 0`, `D(i, i)` is a 1x1 block, and row/column `i` of `A`
/// is interchanged with row/column `k`.
/// If `fill_mode` is [`FillMode::Upper`] and `pivots[i - 1] = pivots[i] = -m` with `m > 0`,
/// `D(i-1:i,i-1:i)` is a 2x2 block, and row/column `i - 1` is interchanged
/// with row/column `m`.
/// If `fill_mode` is [`FillMode::Lower`] and `pivots[i + 1] = pivots[i] = -m` with `m > 0`,
/// `D(i:i+1,i:i+1)` is a 2x2 block, and row/column `i + 1` is interchanged
/// with row/column `m`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn dsytrf(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    pivots: Option<&mut DeviceMemory<i32>>,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    if let Some(pivots) = pivots.as_ref() {
        require_pivot_buffer(pivots, n)?;
    }
    require_info_buffer(dev_info)?;
    let lwork = dsytrf_buffer_size(ctx, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDsytrf(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            pivots.map_or(std::ptr::null_mut(), |p| p.as_mut_ptr()),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the factorization of a symmetric indefinite matrix using the Bunch-Kaufman diagonal pivoting.
///
/// `A` is a $n \times n$ symmetric matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// If `pivots` is `None`, no pivoting is performed, which is not numerically stable.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular factor `L` and block diagonal matrix `D`.
/// Each block of `D` is either 1x1 or 2x2 block, depending on pivoting.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular factor `U` and block diagonal matrix `D`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
/// When no pivoting is performed, the other triangular part of the input matrix `A` is used as workspace.
///
/// If Bunch-Kaufman factorization failed, that is, `A` is singular,
/// `dev_info = i` indicates `D(i, i) = 0`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// `pivots` contains the pivoting sequence.
/// If `pivots[i] = k` with `k > 0`, `D(i, i)` is a 1x1 block, and row/column `i` of `A`
/// is interchanged with row/column `k`.
/// If `fill_mode` is [`FillMode::Upper`] and `pivots[i - 1] = pivots[i] = -m` with `m > 0`,
/// `D(i-1:i,i-1:i)` is a 2x2 block, and row/column `i - 1` is interchanged
/// with row/column `m`.
/// If `fill_mode` is [`FillMode::Lower`] and `pivots[i + 1] = pivots[i] = -m` with `m > 0`,
/// `D(i:i+1,i:i+1)` is a 2x2 block, and row/column `i + 1` is interchanged
/// with row/column `m`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn csytrf(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    pivots: Option<&mut DeviceMemory<i32>>,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    if let Some(pivots) = pivots.as_ref() {
        require_pivot_buffer(pivots, n)?;
    }
    require_info_buffer(dev_info)?;
    let lwork = csytrf_buffer_size(ctx, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCsytrf(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            pivots.map_or(std::ptr::null_mut(), |p| p.as_mut_ptr()),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the factorization of a symmetric indefinite matrix using the Bunch-Kaufman diagonal pivoting.
///
/// `A` is a $n \times n$ symmetric matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// If `pivots` is `None`, no pivoting is performed, which is not numerically stable.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular factor `L` and block diagonal matrix `D`.
/// Each block of `D` is either 1x1 or 2x2 block, depending on pivoting.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular factor `U` and block diagonal matrix `D`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
/// When no pivoting is performed, the other triangular part of the input matrix `A` is used as workspace.
///
/// If Bunch-Kaufman factorization failed, that is, `A` is singular,
/// `dev_info = i` indicates `D(i, i) = 0`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// `pivots` contains the pivoting sequence.
/// If `pivots[i] = k` with `k > 0`, `D(i, i)` is a 1x1 block, and row/column `i` of `A`
/// is interchanged with row/column `k`.
/// If `fill_mode` is [`FillMode::Upper`] and `pivots[i - 1] = pivots[i] = -m` with `m > 0`,
/// `D(i-1:i,i-1:i)` is a 2x2 block, and row/column `i - 1` is interchanged
/// with row/column `m`.
/// If `fill_mode` is [`FillMode::Lower`] and `pivots[i + 1] = pivots[i] = -m` with `m > 0`,
/// `D(i:i+1,i:i+1)` is a 2x2 block, and row/column `i + 1` is interchanged
/// with row/column `m`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn zsytrf(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    pivots: Option<&mut DeviceMemory<i32>>,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_square_matrix(n, a.len(), lda)?;
    if let Some(pivots) = pivots.as_ref() {
        require_pivot_buffer(pivots, n)?;
    }
    require_info_buffer(dev_info)?;
    let lwork = zsytrf_buffer_size(ctx, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZsytrf(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            pivots.map_or(std::ptr::null_mut(), |p| p.as_mut_ptr()),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn sgebrd_buffer_size(ctx: &Context, m: usize, n: usize) -> Result<usize> {
    ctx.bind()?;
    validate_bidiagonal_dims(m, n)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSgebrd_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dgebrd_buffer_size(ctx: &Context, m: usize, n: usize) -> Result<usize> {
    ctx.bind()?;
    validate_bidiagonal_dims(m, n)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDgebrd_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn cgebrd_buffer_size(ctx: &Context, m: usize, n: usize) -> Result<usize> {
    ctx.bind()?;
    validate_bidiagonal_dims(m, n)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCgebrd_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zgebrd_buffer_size(ctx: &Context, m: usize, n: usize) -> Result<usize> {
    ctx.bind()?;
    validate_bidiagonal_dims(m, n)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZgebrd_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Reduces a general $m \times n$ matrix `A` to a real upper or lower
/// bidiagonal form `B` by an orthogonal transformation:
/// $Q^{H}\cdot A\cdot P = B$.
///
/// If `m >= n`, `B` is upper bidiagonal; if `m < n`, `B` is lower
/// bidiagonal.
///
/// The matrix `Q` and `P` are overwritten into matrix `A` in the following sense:
///
/// - If `m >= n`, the diagonal and first superdiagonal are overwritten with
///   the upper bidiagonal matrix `B`. Elements below the diagonal, together
///   with `tauq`, represent `Q`; elements above the first superdiagonal,
///   together with `taup`, represent `P`.
/// - If `m < n`, the diagonal and first subdiagonal are overwritten with the
///   lower bidiagonal matrix `B`. Elements below the first subdiagonal,
///   together with `tauq`, represent `Q`; elements above the diagonal,
///   together with `taup`, represent `P`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// `gebrd` only supports `m >= n`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn sgebrd(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    d: &mut DeviceMemory<f32>,
    e: &mut DeviceMemory<f32>,
    tauq: &mut DeviceMemory<f32>,
    taup: &mut DeviceMemory<f32>,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_bidiagonal_buffers(m, n, a.len(), lda, d.len(), e.len(), tauq.len(), taup.len())?;
    require_info_buffer(dev_info)?;
    let lwork = sgebrd_buffer_size(ctx, m, n)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSgebrd(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_mut_ptr().cast(),
            e.as_mut_ptr().cast(),
            tauq.as_mut_ptr().cast(),
            taup.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Reduces a general $m \times n$ matrix `A` to a real upper or lower
/// bidiagonal form `B` by an orthogonal transformation:
/// $Q^{H}\cdot A\cdot P = B$.
///
/// If `m >= n`, `B` is upper bidiagonal; if `m < n`, `B` is lower
/// bidiagonal.
///
/// The matrix `Q` and `P` are overwritten into matrix `A` in the following sense:
///
/// - If `m >= n`, the diagonal and first superdiagonal are overwritten with
///   the upper bidiagonal matrix `B`. Elements below the diagonal, together
///   with `tauq`, represent `Q`; elements above the first superdiagonal,
///   together with `taup`, represent `P`.
/// - If `m < n`, the diagonal and first subdiagonal are overwritten with the
///   lower bidiagonal matrix `B`. Elements below the first subdiagonal,
///   together with `tauq`, represent `Q`; elements above the diagonal,
///   together with `taup`, represent `P`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// `gebrd` only supports `m >= n`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn dgebrd(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    d: &mut DeviceMemory<f64>,
    e: &mut DeviceMemory<f64>,
    tauq: &mut DeviceMemory<f64>,
    taup: &mut DeviceMemory<f64>,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_bidiagonal_buffers(m, n, a.len(), lda, d.len(), e.len(), tauq.len(), taup.len())?;
    require_info_buffer(dev_info)?;
    let lwork = dgebrd_buffer_size(ctx, m, n)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDgebrd(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_mut_ptr().cast(),
            e.as_mut_ptr().cast(),
            tauq.as_mut_ptr().cast(),
            taup.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Reduces a general $m \times n$ matrix `A` to a real upper or lower
/// bidiagonal form `B` by an orthogonal transformation:
/// $Q^{H}\cdot A\cdot P = B$.
///
/// If `m >= n`, `B` is upper bidiagonal; if `m < n`, `B` is lower
/// bidiagonal.
///
/// The matrix `Q` and `P` are overwritten into matrix `A` in the following sense:
///
/// - If `m >= n`, the diagonal and first superdiagonal are overwritten with
///   the upper bidiagonal matrix `B`. Elements below the diagonal, together
///   with `tauq`, represent `Q`; elements above the first superdiagonal,
///   together with `taup`, represent `P`.
/// - If `m < n`, the diagonal and first subdiagonal are overwritten with the
///   lower bidiagonal matrix `B`. Elements below the first subdiagonal,
///   together with `tauq`, represent `Q`; elements above the diagonal,
///   together with `taup`, represent `P`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// `gebrd` only supports `m >= n`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn cgebrd(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    d: &mut DeviceMemory<f32>,
    e: &mut DeviceMemory<f32>,
    tauq: &mut DeviceMemory<Complex32>,
    taup: &mut DeviceMemory<Complex32>,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_bidiagonal_buffers(m, n, a.len(), lda, d.len(), e.len(), tauq.len(), taup.len())?;
    require_info_buffer(dev_info)?;
    let lwork = cgebrd_buffer_size(ctx, m, n)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCgebrd(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_mut_ptr().cast(),
            e.as_mut_ptr().cast(),
            tauq.as_mut_ptr().cast(),
            taup.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Reduces a general $m \times n$ matrix `A` to a real upper or lower
/// bidiagonal form `B` by an orthogonal transformation:
/// $Q^{H}\cdot A\cdot P = B$.
///
/// If `m >= n`, `B` is upper bidiagonal; if `m < n`, `B` is lower
/// bidiagonal.
///
/// The matrix `Q` and `P` are overwritten into matrix `A` in the following sense:
///
/// - If `m >= n`, the diagonal and first superdiagonal are overwritten with
///   the upper bidiagonal matrix `B`. Elements below the diagonal, together
///   with `tauq`, represent `Q`; elements above the first superdiagonal,
///   together with `taup`, represent `P`.
/// - If `m < n`, the diagonal and first subdiagonal are overwritten with the
///   lower bidiagonal matrix `B`. Elements below the first subdiagonal,
///   together with `tauq`, represent `Q`; elements above the diagonal,
///   together with `taup`, represent `P`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// `gebrd` only supports `m >= n`.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn zgebrd(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    d: &mut DeviceMemory<f64>,
    e: &mut DeviceMemory<f64>,
    tauq: &mut DeviceMemory<Complex64>,
    taup: &mut DeviceMemory<Complex64>,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_bidiagonal_buffers(m, n, a.len(), lda, d.len(), e.len(), tauq.len(), taup.len())?;
    require_info_buffer(dev_info)?;
    let lwork = zgebrd_buffer_size(ctx, m, n)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZgebrd(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_mut_ptr().cast(),
            e.as_mut_ptr().cast(),
            tauq.as_mut_ptr().cast(),
            taup.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn sorgbr_buffer_size(
    ctx: &Context,
    side: SideMode,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<f32>,
    lda: usize,
    tau: &DeviceMemory<f32>,
) -> Result<usize> {
    ctx.bind()?;
    validate_orgbr_inputs(side, m, n, k, a.len(), lda, tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSorgbr_bufferSize(
            ctx.as_raw(),
            side.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dorgbr_buffer_size(
    ctx: &Context,
    side: SideMode,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<f64>,
    lda: usize,
    tau: &DeviceMemory<f64>,
) -> Result<usize> {
    ctx.bind()?;
    validate_orgbr_inputs(side, m, n, k, a.len(), lda, tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDorgbr_bufferSize(
            ctx.as_raw(),
            side.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn cungbr_buffer_size(
    ctx: &Context,
    side: SideMode,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<Complex32>,
    lda: usize,
    tau: &DeviceMemory<Complex32>,
) -> Result<usize> {
    ctx.bind()?;
    validate_orgbr_inputs(side, m, n, k, a.len(), lda, tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCungbr_bufferSize(
            ctx.as_raw(),
            side.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zungbr_buffer_size(
    ctx: &Context,
    side: SideMode,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<Complex64>,
    lda: usize,
    tau: &DeviceMemory<Complex64>,
) -> Result<usize> {
    ctx.bind()?;
    validate_orgbr_inputs(side, m, n, k, a.len(), lda, tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZungbr_bufferSize(
            ctx.as_raw(),
            side.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Generates one of the unitary matrices `Q` or $P^{H}$ determined by `gebrd`
/// when reducing matrix `A` to bidiagonal form:
/// $Q^{H}\cdot A\cdot P = B$.
///
/// `Q` and $P^{H}$ are defined as products of elementary reflectors `H(i)`
/// or `G(i)`, respectively.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn sorgbr(
    ctx: &Context,
    side: SideMode,
    m: usize,
    n: usize,
    k: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    tau: &DeviceMemory<f32>,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_orgbr_inputs(side, m, n, k, a.len(), lda, tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = sorgbr_buffer_size(ctx, side, m, n, k, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSorgbr(
            ctx.as_raw(),
            side.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Generates one of the unitary matrices `Q` or $P^{H}$ determined by `gebrd`
/// when reducing matrix `A` to bidiagonal form:
/// $Q^{H}\cdot A\cdot P = B$.
///
/// `Q` and $P^{H}$ are defined as products of elementary reflectors `H(i)`
/// or `G(i)`, respectively.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn dorgbr(
    ctx: &Context,
    side: SideMode,
    m: usize,
    n: usize,
    k: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    tau: &DeviceMemory<f64>,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_orgbr_inputs(side, m, n, k, a.len(), lda, tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = dorgbr_buffer_size(ctx, side, m, n, k, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDorgbr(
            ctx.as_raw(),
            side.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn cungbr(
    ctx: &Context,
    side: SideMode,
    m: usize,
    n: usize,
    k: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    tau: &DeviceMemory<Complex32>,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_orgbr_inputs(side, m, n, k, a.len(), lda, tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = cungbr_buffer_size(ctx, side, m, n, k, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCungbr(
            ctx.as_raw(),
            side.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn zungbr(
    ctx: &Context,
    side: SideMode,
    m: usize,
    n: usize,
    k: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    tau: &DeviceMemory<Complex64>,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_orgbr_inputs(side, m, n, k, a.len(), lda, tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = zungbr_buffer_size(ctx, side, m, n, k, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZungbr(
            ctx.as_raw(),
            side.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn ssytrd_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &DeviceMemory<f32>,
    lda: usize,
    d: &DeviceMemory<f32>,
    e: &DeviceMemory<f32>,
    tau: &DeviceMemory<f32>,
) -> Result<usize> {
    ctx.bind()?;
    validate_sytrd_inputs(n, a.len(), lda, d.len(), e.len(), tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSsytrd_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_ptr().cast(),
            e.as_ptr().cast(),
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dsytrd_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &DeviceMemory<f64>,
    lda: usize,
    d: &DeviceMemory<f64>,
    e: &DeviceMemory<f64>,
    tau: &DeviceMemory<f64>,
) -> Result<usize> {
    ctx.bind()?;
    validate_sytrd_inputs(n, a.len(), lda, d.len(), e.len(), tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDsytrd_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_ptr().cast(),
            e.as_ptr().cast(),
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn chetrd_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &DeviceMemory<Complex32>,
    lda: usize,
    d: &DeviceMemory<f32>,
    e: &DeviceMemory<f32>,
    tau: &DeviceMemory<Complex32>,
) -> Result<usize> {
    ctx.bind()?;
    validate_sytrd_inputs(n, a.len(), lda, d.len(), e.len(), tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnChetrd_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_ptr().cast(),
            e.as_ptr().cast(),
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zhetrd_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &DeviceMemory<Complex64>,
    lda: usize,
    d: &DeviceMemory<f64>,
    e: &DeviceMemory<f64>,
    tau: &DeviceMemory<Complex64>,
) -> Result<usize> {
    ctx.bind()?;
    validate_sytrd_inputs(n, a.len(), lda, d.len(), e.len(), tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZhetrd_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_ptr().cast(),
            e.as_ptr().cast(),
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Reduces a general symmetric (Hermitian) $n \times n$ matrix `A` to the
/// real symmetric tridiagonal form `T` by an orthogonal transformation:
/// $Q^{H}\cdot A\cdot Q = T$.
///
/// On output, `A` contains `T` and Householder reflection vectors.
/// If `fill_mode` is [`FillMode::Upper`], the diagonal and first
/// superdiagonal of `A` are overwritten by `T`; elements above the first
/// superdiagonal, together with `tau`, represent `Q`.
/// If `fill_mode` is [`FillMode::Lower`], the diagonal and first subdiagonal
/// of `A` are overwritten by `T`; elements below the first subdiagonal,
/// together with `tau`, represent `Q`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
/// The problem size `n` is limited by `n * lda <= INT32_MAX` primarily due to the current implementation constraints.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, leading dimension, or fill mode are invalid, if the
/// current GPU architecture is unsupported, or if cuSOLVER reports an
/// internal failure.
pub fn ssytrd(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    d: &mut DeviceMemory<f32>,
    e: &mut DeviceMemory<f32>,
    tau: &mut DeviceMemory<f32>,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_sytrd_inputs(n, a.len(), lda, d.len(), e.len(), tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = ssytrd_buffer_size(ctx, fill_mode, n, a, lda, d, e, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSsytrd(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_mut_ptr().cast(),
            e.as_mut_ptr().cast(),
            tau.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Reduces a general symmetric (Hermitian) $n \times n$ matrix `A` to the
/// real symmetric tridiagonal form `T` by an orthogonal transformation:
/// $Q^{H}\cdot A\cdot Q = T$.
///
/// On output, `A` contains `T` and Householder reflection vectors.
/// If `fill_mode` is [`FillMode::Upper`], the diagonal and first
/// superdiagonal of `A` are overwritten by `T`; elements above the first
/// superdiagonal, together with `tau`, represent `Q`.
/// If `fill_mode` is [`FillMode::Lower`], the diagonal and first subdiagonal
/// of `A` are overwritten by `T`; elements below the first subdiagonal,
/// together with `tau`, represent `Q`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
/// The problem size `n` is limited by `n * lda <= INT32_MAX` primarily due to the current implementation constraints.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, leading dimension, or fill mode are invalid, if the
/// current GPU architecture is unsupported, or if cuSOLVER reports an
/// internal failure.
pub fn dsytrd(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    d: &mut DeviceMemory<f64>,
    e: &mut DeviceMemory<f64>,
    tau: &mut DeviceMemory<f64>,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_sytrd_inputs(n, a.len(), lda, d.len(), e.len(), tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = dsytrd_buffer_size(ctx, fill_mode, n, a, lda, d, e, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDsytrd(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_mut_ptr().cast(),
            e.as_mut_ptr().cast(),
            tau.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn chetrd(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    d: &mut DeviceMemory<f32>,
    e: &mut DeviceMemory<f32>,
    tau: &mut DeviceMemory<Complex32>,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_sytrd_inputs(n, a.len(), lda, d.len(), e.len(), tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = chetrd_buffer_size(ctx, fill_mode, n, a, lda, d, e, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnChetrd(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_mut_ptr().cast(),
            e.as_mut_ptr().cast(),
            tau.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn zhetrd(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    d: &mut DeviceMemory<f64>,
    e: &mut DeviceMemory<f64>,
    tau: &mut DeviceMemory<Complex64>,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_sytrd_inputs(n, a.len(), lda, d.len(), e.len(), tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = zhetrd_buffer_size(ctx, fill_mode, n, a, lda, d, e, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZhetrd(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            d.as_mut_ptr().cast(),
            e.as_mut_ptr().cast(),
            tau.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn sorgtr_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &DeviceMemory<f32>,
    lda: usize,
    tau: &DeviceMemory<f32>,
) -> Result<usize> {
    ctx.bind()?;
    validate_orgtr_inputs(n, a.len(), lda, tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSorgtr_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dorgtr_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &DeviceMemory<f64>,
    lda: usize,
    tau: &DeviceMemory<f64>,
) -> Result<usize> {
    ctx.bind()?;
    validate_orgtr_inputs(n, a.len(), lda, tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDorgtr_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn cungtr_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &DeviceMemory<Complex32>,
    lda: usize,
    tau: &DeviceMemory<Complex32>,
) -> Result<usize> {
    ctx.bind()?;
    validate_orgtr_inputs(n, a.len(), lda, tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCungtr_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zungtr_buffer_size(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &DeviceMemory<Complex64>,
    lda: usize,
    tau: &DeviceMemory<Complex64>,
) -> Result<usize> {
    ctx.bind()?;
    validate_orgtr_inputs(n, a.len(), lda, tau.len())?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZungtr_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Generates the orthogonal matrix `Q` from the elementary reflectors returned
/// by `sytrd`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn sorgtr(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    tau: &DeviceMemory<f32>,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_orgtr_inputs(n, a.len(), lda, tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = sorgtr_buffer_size(ctx, fill_mode, n, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSorgtr(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Generates the orthogonal matrix `Q` from the elementary reflectors returned
/// by `sytrd`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn dorgtr(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    tau: &DeviceMemory<f64>,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_orgtr_inputs(n, a.len(), lda, tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = dorgtr_buffer_size(ctx, fill_mode, n, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDorgtr(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn cungtr(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    tau: &DeviceMemory<Complex32>,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_orgtr_inputs(n, a.len(), lda, tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = cungtr_buffer_size(ctx, fill_mode, n, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCungtr(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn zungtr(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    tau: &DeviceMemory<Complex64>,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_orgtr_inputs(n, a.len(), lda, tau.len())?;
    require_info_buffer(dev_info)?;
    let lwork = zungtr_buffer_size(ctx, fill_mode, n, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZungtr(
            ctx.as_raw(),
            fill_mode.into(),
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn sormtr_buffer_size(
    ctx: &Context,
    side: SideMode,
    fill_mode: FillMode,
    operation: Operation,
    m: usize,
    n: usize,
    a: &DeviceMemory<f32>,
    lda: usize,
    tau: &DeviceMemory<f32>,
    c: &DeviceMemory<f32>,
    ldc: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_ormtr_inputs(side, m, n, a.len(), lda, tau.len(), c.len(), ldc)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSormtr_bufferSize(
            ctx.as_raw(),
            side.into(),
            fill_mode.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_ptr().cast(),
            to_i32(ldc, "ldc")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dormtr_buffer_size(
    ctx: &Context,
    side: SideMode,
    fill_mode: FillMode,
    operation: Operation,
    m: usize,
    n: usize,
    a: &DeviceMemory<f64>,
    lda: usize,
    tau: &DeviceMemory<f64>,
    c: &DeviceMemory<f64>,
    ldc: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_ormtr_inputs(side, m, n, a.len(), lda, tau.len(), c.len(), ldc)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDormtr_bufferSize(
            ctx.as_raw(),
            side.into(),
            fill_mode.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_ptr().cast(),
            to_i32(ldc, "ldc")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn cunmtr_buffer_size(
    ctx: &Context,
    side: SideMode,
    fill_mode: FillMode,
    operation: Operation,
    m: usize,
    n: usize,
    a: &DeviceMemory<Complex32>,
    lda: usize,
    tau: &DeviceMemory<Complex32>,
    c: &DeviceMemory<Complex32>,
    ldc: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_ormtr_inputs(side, m, n, a.len(), lda, tau.len(), c.len(), ldc)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCunmtr_bufferSize(
            ctx.as_raw(),
            side.into(),
            fill_mode.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_ptr().cast(),
            to_i32(ldc, "ldc")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zunmtr_buffer_size(
    ctx: &Context,
    side: SideMode,
    fill_mode: FillMode,
    operation: Operation,
    m: usize,
    n: usize,
    a: &DeviceMemory<Complex64>,
    lda: usize,
    tau: &DeviceMemory<Complex64>,
    c: &DeviceMemory<Complex64>,
    ldc: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_ormtr_inputs(side, m, n, a.len(), lda, tau.len(), c.len(), ldc)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZunmtr_bufferSize(
            ctx.as_raw(),
            side.into(),
            fill_mode.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_ptr().cast(),
            to_i32(ldc, "ldc")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Applies the orthogonal matrix `Q`, represented by the elementary reflectors
/// returned by `sytrd`, to `C` and stores the result in `C`.
///
/// `side` selects whether `Q` is applied from the left or right, and
/// `operation` selects whether `Q` is transposed.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimensions are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn sormtr(
    ctx: &Context,
    side: SideMode,
    fill_mode: FillMode,
    operation: Operation,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    tau: &mut DeviceMemory<f32>,
    c: &mut DeviceMemory<f32>,
    ldc: usize,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_ormtr_inputs(side, m, n, a.len(), lda, tau.len(), c.len(), ldc)?;
    require_info_buffer(dev_info)?;
    let lwork = sormtr_buffer_size(ctx, side, fill_mode, operation, m, n, a, lda, tau, c, ldc)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSormtr(
            ctx.as_raw(),
            side.into(),
            fill_mode.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_mut_ptr().cast(),
            c.as_mut_ptr().cast(),
            to_i32(ldc, "ldc")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Applies the orthogonal matrix `Q`, represented by the elementary reflectors
/// returned by `sytrd`, to `C` and stores the result in `C`.
///
/// `side` selects whether `Q` is applied from the left or right, and
/// `operation` selects whether `Q` is transposed.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimensions are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn dormtr(
    ctx: &Context,
    side: SideMode,
    fill_mode: FillMode,
    operation: Operation,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    tau: &mut DeviceMemory<f64>,
    c: &mut DeviceMemory<f64>,
    ldc: usize,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_ormtr_inputs(side, m, n, a.len(), lda, tau.len(), c.len(), ldc)?;
    require_info_buffer(dev_info)?;
    let lwork = dormtr_buffer_size(ctx, side, fill_mode, operation, m, n, a, lda, tau, c, ldc)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDormtr(
            ctx.as_raw(),
            side.into(),
            fill_mode.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_mut_ptr().cast(),
            c.as_mut_ptr().cast(),
            to_i32(ldc, "ldc")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn cunmtr(
    ctx: &Context,
    side: SideMode,
    fill_mode: FillMode,
    operation: Operation,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    tau: &mut DeviceMemory<Complex32>,
    c: &mut DeviceMemory<Complex32>,
    ldc: usize,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_ormtr_inputs(side, m, n, a.len(), lda, tau.len(), c.len(), ldc)?;
    require_info_buffer(dev_info)?;
    let lwork = cunmtr_buffer_size(ctx, side, fill_mode, operation, m, n, a, lda, tau, c, ldc)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCunmtr(
            ctx.as_raw(),
            side.into(),
            fill_mode.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_mut_ptr().cast(),
            c.as_mut_ptr().cast(),
            to_i32(ldc, "ldc")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn zunmtr(
    ctx: &Context,
    side: SideMode,
    fill_mode: FillMode,
    operation: Operation,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    tau: &mut DeviceMemory<Complex64>,
    c: &mut DeviceMemory<Complex64>,
    ldc: usize,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_ormtr_inputs(side, m, n, a.len(), lda, tau.len(), c.len(), ldc)?;
    require_info_buffer(dev_info)?;
    let lwork = zunmtr_buffer_size(ctx, side, fill_mode, operation, m, n, a, lda, tau, c, ldc)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZunmtr(
            ctx.as_raw(),
            side.into(),
            fill_mode.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_mut_ptr().cast(),
            c.as_mut_ptr().cast(),
            to_i32(ldc, "ldc")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn sgeqrf_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSgeqrf_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dgeqrf_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDgeqrf_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn cgeqrf_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCgeqrf_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zgeqrf_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZgeqrf_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the QR factorization of an $m \times n$ matrix
///
/// where `A` is an $m \times n$ matrix, `Q` is an $m \times n$ matrix, and `R` is a $n \times n$ upper triangular matrix.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// The matrix `R` is overwritten in upper triangular part of `A`, including diagonal elements.
///
/// The matrix `Q` is not formed explicitly, instead, a sequence of householder vectors are stored in lower triangular part of `A`.
/// The leading nonzero element of the Householder vector is assumed to be 1, so `tau` contains the scaling factor `τ`.
/// If `v` is original householder vector, `q` is the new householder vector corresponding to `τ`, satisfying the following relation
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn sgeqrf(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    tau: &mut DeviceMemory<f32>,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, m.min(n))?;
    require_info_buffer(dev_info)?;
    let lwork = sgeqrf_buffer_size(ctx, m, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSgeqrf(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the QR factorization of an $m \times n$ matrix
///
/// where `A` is an $m \times n$ matrix, `Q` is an $m \times n$ matrix, and `R` is a $n \times n$ upper triangular matrix.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// The matrix `R` is overwritten in upper triangular part of `A`, including diagonal elements.
///
/// The matrix `Q` is not formed explicitly, instead, a sequence of householder vectors are stored in lower triangular part of `A`.
/// The leading nonzero element of the Householder vector is assumed to be 1, so `tau` contains the scaling factor `τ`.
/// If `v` is original householder vector, `q` is the new householder vector corresponding to `τ`, satisfying the following relation
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn dgeqrf(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    tau: &mut DeviceMemory<f64>,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, m.min(n))?;
    require_info_buffer(dev_info)?;
    let lwork = dgeqrf_buffer_size(ctx, m, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDgeqrf(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the QR factorization of an $m \times n$ matrix
///
/// where `A` is an $m \times n$ matrix, `Q` is an $m \times n$ matrix, and `R` is a $n \times n$ upper triangular matrix.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// The matrix `R` is overwritten in upper triangular part of `A`, including diagonal elements.
///
/// The matrix `Q` is not formed explicitly, instead, a sequence of householder vectors are stored in lower triangular part of `A`.
/// The leading nonzero element of the Householder vector is assumed to be 1, so `tau` contains the scaling factor `τ`.
/// If `v` is original householder vector, `q` is the new householder vector corresponding to `τ`, satisfying the following relation
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn cgeqrf(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    tau: &mut DeviceMemory<Complex32>,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, m.min(n))?;
    require_info_buffer(dev_info)?;
    let lwork = cgeqrf_buffer_size(ctx, m, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCgeqrf(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Computes the QR factorization of an $m \times n$ matrix
///
/// where `A` is an $m \times n$ matrix, `Q` is an $m \times n$ matrix, and `R` is a $n \times n$ upper triangular matrix.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
///
/// The matrix `R` is overwritten in upper triangular part of `A`, including diagonal elements.
///
/// The matrix `Q` is not formed explicitly, instead, a sequence of householder vectors are stored in lower triangular part of `A`.
/// The leading nonzero element of the Householder vector is assumed to be 1, so `tau` contains the scaling factor `τ`.
/// If `v` is original householder vector, `q` is the new householder vector corresponding to `τ`, satisfying the following relation
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the current GPU
/// architecture is unsupported, or if cuSOLVER reports an internal failure.
pub fn zgeqrf(
    ctx: &Context,
    m: usize,
    n: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    tau: &mut DeviceMemory<Complex64>,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, m.min(n))?;
    require_info_buffer(dev_info)?;
    let lwork = zgeqrf_buffer_size(ctx, m, n, a, lda)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZgeqrf(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_mut_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn sorgqr_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<f32>,
    lda: usize,
    tau: &DeviceMemory<f32>,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSorgqr_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dorgqr_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<f64>,
    lda: usize,
    tau: &DeviceMemory<f64>,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDorgqr_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn cungqr_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<Complex32>,
    lda: usize,
    tau: &DeviceMemory<Complex32>,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCungqr_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zungqr_buffer_size(
    ctx: &Context,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<Complex64>,
    lda: usize,
    tau: &DeviceMemory<Complex64>,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZungqr_bufferSize(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Generates the first `n` columns of the orthogonal matrix `Q` from the
/// elementary reflectors returned by `geqrf` and stores them in `A`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// Callers can combine `geqrf` and `orgqr` to complete orthogonalization.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, reflector count, or leading dimension are invalid, if
/// the current GPU architecture is unsupported, or if cuSOLVER reports an
/// internal failure.
pub fn sorgqr(
    ctx: &Context,
    m: usize,
    n: usize,
    k: usize,
    a: &mut DeviceMemory<f32>,
    lda: usize,
    tau: &DeviceMemory<f32>,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    require_info_buffer(dev_info)?;
    let lwork = sorgqr_buffer_size(ctx, m, n, k, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSorgqr(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Generates the first `n` columns of the orthogonal matrix `Q` from the
/// elementary reflectors returned by `geqrf` and stores them in `A`.
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// Callers can combine `geqrf` and `orgqr` to complete orthogonalization.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, reflector count, or leading dimension are invalid, if
/// the current GPU architecture is unsupported, or if cuSOLVER reports an
/// internal failure.
pub fn dorgqr(
    ctx: &Context,
    m: usize,
    n: usize,
    k: usize,
    a: &mut DeviceMemory<f64>,
    lda: usize,
    tau: &DeviceMemory<f64>,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    require_info_buffer(dev_info)?;
    let lwork = dorgqr_buffer_size(ctx, m, n, k, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDorgqr(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn cungqr(
    ctx: &Context,
    m: usize,
    n: usize,
    k: usize,
    a: &mut DeviceMemory<Complex32>,
    lda: usize,
    tau: &DeviceMemory<Complex32>,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    require_info_buffer(dev_info)?;
    let lwork = cungqr_buffer_size(ctx, m, n, k, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCungqr(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn zungqr(
    ctx: &Context,
    m: usize,
    n: usize,
    k: usize,
    a: &mut DeviceMemory<Complex64>,
    lda: usize,
    tau: &DeviceMemory<Complex64>,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(m, n, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    require_info_buffer(dev_info)?;
    let lwork = zungqr_buffer_size(ctx, m, n, k, a, lda, tau)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZungqr(
            ctx.as_raw(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_mut_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn sormqr_buffer_size(
    ctx: &Context,
    side: SideMode,
    operation: Operation,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<f32>,
    lda: usize,
    tau: &DeviceMemory<f32>,
    c: &DeviceMemory<f32>,
    ldc: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(qr_rows(side, m, n), k, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    validate_matrix(m, n, c.len(), ldc)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnSormqr_bufferSize(
            ctx.as_raw(),
            side.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_ptr().cast(),
            to_i32(ldc, "ldc")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn dormqr_buffer_size(
    ctx: &Context,
    side: SideMode,
    operation: Operation,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<f64>,
    lda: usize,
    tau: &DeviceMemory<f64>,
    c: &DeviceMemory<f64>,
    ldc: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(qr_rows(side, m, n), k, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    validate_matrix(m, n, c.len(), ldc)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnDormqr_bufferSize(
            ctx.as_raw(),
            side.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_ptr().cast(),
            to_i32(ldc, "ldc")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn cunmqr_buffer_size(
    ctx: &Context,
    side: SideMode,
    operation: Operation,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<Complex32>,
    lda: usize,
    tau: &DeviceMemory<Complex32>,
    c: &DeviceMemory<Complex32>,
    ldc: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(qr_rows(side, m, n), k, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    validate_matrix(m, n, c.len(), ldc)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnCunmqr_bufferSize(
            ctx.as_raw(),
            side.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_ptr().cast(),
            to_i32(ldc, "ldc")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

pub fn zunmqr_buffer_size(
    ctx: &Context,
    side: SideMode,
    operation: Operation,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<Complex64>,
    lda: usize,
    tau: &DeviceMemory<Complex64>,
    c: &DeviceMemory<Complex64>,
    ldc: usize,
) -> Result<usize> {
    ctx.bind()?;
    validate_matrix(qr_rows(side, m, n), k, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    validate_matrix(m, n, c.len(), ldc)?;
    let mut lwork = 0;
    unsafe {
        try_ffi!(sys::cusolverDnZunmqr_bufferSize(
            ctx.as_raw(),
            side.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_ptr().cast(),
            to_i32(ldc, "ldc")?,
            &raw mut lwork,
        ))?;
    }
    to_usize(lwork, "lwork")
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Applies the orthogonal matrix `Q`, represented by the elementary reflectors
/// returned by `geqrf`, to `C` and stores the result in `C`.
///
/// `operation` selects whether `Q` is transposed.
///
/// `Q` is of order `m` if `side` = [`SideMode::Left`] and of order `n` if `side` = [`SideMode::Right`].
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// Callers can combine `geqrf`, `ormqr`, and `trsm` to complete a linear solver or a least-square solver.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, reflector count, side/operation mode, or leading
/// dimensions are invalid, if the current GPU architecture is unsupported, or
/// if cuSOLVER reports an internal failure.
pub fn sormqr(
    ctx: &Context,
    side: SideMode,
    operation: Operation,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<f32>,
    lda: usize,
    tau: &DeviceMemory<f32>,
    c: &mut DeviceMemory<f32>,
    ldc: usize,
    workspace: &mut DeviceMemory<f32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(qr_rows(side, m, n), k, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    validate_matrix(m, n, c.len(), ldc)?;
    require_info_buffer(dev_info)?;
    let lwork = sormqr_buffer_size(ctx, side, operation, m, n, k, a, lda, tau, c, ldc)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnSormqr(
            ctx.as_raw(),
            side.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_mut_ptr().cast(),
            to_i32(ldc, "ldc")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Use the matching buffer-size helper to calculate the required workspace size.
///
/// The S and D data types are real valued single and double precision, respectively.
///
/// The C and Z data types are complex valued single and double precision, respectively.
///
/// Applies the orthogonal matrix `Q`, represented by the elementary reflectors
/// returned by `geqrf`, to `C` and stores the result in `C`.
///
/// `operation` selects whether `Q` is transposed.
///
/// `Q` is of order `m` if `side` = [`SideMode::Left`] and of order `n` if `side` = [`SideMode::Right`].
///
/// Provide workspace through `workspace`.
/// Use the corresponding `*_buffer_size` helper to query the required workspace length.
/// The workspace size in bytes is `size_of::<T>() * lwork`.
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// Callers can combine `geqrf`, `ormqr`, and `trsm` to complete a linear solver or a least-square solver.
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, reflector count, side/operation mode, or leading
/// dimensions are invalid, if the current GPU architecture is unsupported, or
/// if cuSOLVER reports an internal failure.
pub fn dormqr(
    ctx: &Context,
    side: SideMode,
    operation: Operation,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<f64>,
    lda: usize,
    tau: &DeviceMemory<f64>,
    c: &mut DeviceMemory<f64>,
    ldc: usize,
    workspace: &mut DeviceMemory<f64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(qr_rows(side, m, n), k, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    validate_matrix(m, n, c.len(), ldc)?;
    require_info_buffer(dev_info)?;
    let lwork = dormqr_buffer_size(ctx, side, operation, m, n, k, a, lda, tau, c, ldc)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnDormqr(
            ctx.as_raw(),
            side.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_mut_ptr().cast(),
            to_i32(ldc, "ldc")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn cunmqr(
    ctx: &Context,
    side: SideMode,
    operation: Operation,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<Complex32>,
    lda: usize,
    tau: &DeviceMemory<Complex32>,
    c: &mut DeviceMemory<Complex32>,
    ldc: usize,
    workspace: &mut DeviceMemory<Complex32>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(qr_rows(side, m, n), k, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    validate_matrix(m, n, c.len(), ldc)?;
    require_info_buffer(dev_info)?;
    let lwork = cunmqr_buffer_size(ctx, side, operation, m, n, k, a, lda, tau, c, ldc)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnCunmqr(
            ctx.as_raw(),
            side.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_mut_ptr().cast(),
            to_i32(ldc, "ldc")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn zunmqr(
    ctx: &Context,
    side: SideMode,
    operation: Operation,
    m: usize,
    n: usize,
    k: usize,
    a: &DeviceMemory<Complex64>,
    lda: usize,
    tau: &DeviceMemory<Complex64>,
    c: &mut DeviceMemory<Complex64>,
    ldc: usize,
    workspace: &mut DeviceMemory<Complex64>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_matrix(qr_rows(side, m, n), k, a.len(), lda)?;
    require_tau_buffer(tau, k)?;
    validate_matrix(m, n, c.len(), ldc)?;
    require_info_buffer(dev_info)?;
    let lwork = zunmqr_buffer_size(ctx, side, operation, m, n, k, a, lda, tau, c, ldc)?;
    require_workspace(workspace.len(), lwork)?;
    unsafe {
        try_ffi!(sys::cusolverDnZunmqr(
            ctx.as_raw(),
            side.into(),
            operation.into(),
            to_i32(m, "m")?,
            to_i32(n, "n")?,
            to_i32(k, "k")?,
            a.as_ptr().cast(),
            to_i32(lda, "lda")?,
            tau.as_ptr().cast(),
            c.as_mut_ptr().cast(),
            to_i32(ldc, "ldc")?,
            workspace.as_mut_ptr().cast(),
            to_i32(lwork, "lwork")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn xgeqrf_buffer_size<TA: DataTypeLike, TTau: DataTypeLike>(
    ctx: &Context,
    params: &Params,
    m: usize,
    n: usize,
    a: MatrixRef<'_, TA>,
    tau: VectorRef<'_, TTau>,
    compute_type: DataType,
) -> Result<WorkspaceSizes> {
    ctx.bind()?;
    let a_type = TA::data_type();
    let tau_type = TTau::data_type();
    validate_x_matrix(m, n, a.data.byte_len(), a.leading_dimension, a_type)?;
    validate_x_vector(m.min(n), tau.data.byte_len(), tau_type)?;
    let mut device_bytes = 0;
    let mut host_bytes = 0;
    unsafe {
        try_ffi!(sys::cusolverDnXgeqrf_bufferSize(
            ctx.as_raw(),
            params.as_raw(),
            to_i64(m, "m")?,
            to_i64(n, "n")?,
            a_type.into(),
            a.data.as_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            tau_type.into(),
            tau.data.as_ptr().cast(),
            compute_type.into(),
            &raw mut device_bytes,
            &raw mut host_bytes,
        ))?;
    }
    Ok(WorkspaceSizes::new(
        device_bytes as usize,
        host_bytes as usize,
    ))
}

/// Use [`xgeqrf_buffer_size`] to calculate the sizes needed for pre-allocated
/// workspace.
///
/// Computes the QR factorization of an $m \times n$ matrix.
///
/// Here `A` is an $m \times n$ matrix, `Q` is an $m \times n$ matrix, and
/// `R` is an $n \times n$ upper triangular matrix.
///
/// Provide device and host workspace through `workspace`.
/// Use [`xgeqrf_buffer_size`] to determine the required sizes for
/// `workspace.device` and `workspace.host`.
///
/// The matrix `R` overwrites the upper triangular part of `A`, including the
/// diagonal elements.
///
/// The matrix `Q` is not formed explicitly. Instead, a sequence of Householder
/// vectors is stored in the lower triangular part of `A`.
/// The leading nonzero element of the Householder vector is assumed to be 1, so `tau` contains the scaling factor `τ`.
/// If `v` is the original Householder vector, `q` is the new Householder vector
/// corresponding to `τ`.
///
/// If the reported `info` value is `-i`, the `i`th parameter is invalid.
///
/// Currently, [`xgeqrf`] supports only the default algorithm.
///
/// **Algorithms supported by [`xgeqrf`]**
///
/// | Algorithm | Notes |
/// | --- | --- |
/// | [`AlgorithmMode::Default`](crate::types::AlgorithmMode::Default) | Default algorithm. |
///
/// List of input arguments for [`xgeqrf_buffer_size`] and [`xgeqrf`]:
///
/// The generic cuSOLVER routine separates matrix, tau-vector, and compute data types:
/// `data_type_a` is the data type of matrix `A`, `data_type_tau` is the data
/// type of `tau`, and `compute_type` is the operation's compute type.
/// [`xgeqrf`] only supports the following four combinations.
///
/// **Valid combination of data type and compute type**
///
/// | **data_type_a** | **compute_type** | **Meaning** |
/// | --- | --- | --- |
/// | [`DataType::F32`] | [`DataType::F32`] | `SGEQRF` |
/// | [`DataType::F64`] | [`DataType::F64`] | `DGEQRF` |
/// | [`DataType::ComplexF32`] | [`DataType::ComplexF32`] | `CGEQRF` |
/// | [`DataType::ComplexF64`] | [`DataType::ComplexF64`] | `ZGEQRF` |
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, or if cuSOLVER reports
/// an internal failure.
pub fn xgeqrf<TA: DataTypeLike, TTau: DataTypeLike>(
    ctx: &Context,
    params: &Params,
    m: usize,
    n: usize,
    a: MatrixMut<'_, TA>,
    tau: VectorMut<'_, TTau>,
    compute_type: DataType,
    workspace: ByteWorkspaceMut<'_>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    let a_type = TA::data_type();
    let tau_type = TTau::data_type();
    validate_x_matrix(m, n, a.data.byte_len(), a.leading_dimension, a_type)?;
    validate_x_vector(m.min(n), tau.data.byte_len(), tau_type)?;
    require_info_buffer(dev_info)?;
    let workspace_sizes =
        xgeqrf_buffer_size(ctx, params, m, n, a.as_ref(), tau.as_ref(), compute_type)?;
    require_workspace_bytes(workspace.device.byte_len(), workspace_sizes.device_bytes)?;
    require_host_workspace(workspace.host.len(), workspace_sizes.host_bytes)?;
    unsafe {
        try_ffi!(sys::cusolverDnXgeqrf(
            ctx.as_raw(),
            params.as_raw(),
            to_i64(m, "m")?,
            to_i64(n, "n")?,
            a_type.into(),
            a.data.as_mut_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            tau_type.into(),
            tau.data.as_mut_ptr().cast(),
            compute_type.into(),
            workspace.device.as_mut_ptr().cast(),
            workspace_sizes.device_bytes as _,
            workspace.host.as_mut_ptr().cast(),
            workspace_sizes.host_bytes as _,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn xpotrf_buffer_size<TA: DataTypeLike>(
    ctx: &Context,
    params: &Params,
    fill_mode: FillMode,
    n: usize,
    a: MatrixRef<'_, TA>,
    compute_type: DataType,
) -> Result<WorkspaceSizes> {
    ctx.bind()?;
    let a_type = TA::data_type();
    validate_x_matrix(n, n, a.data.byte_len(), a.leading_dimension, a_type)?;
    let mut device_bytes = 0;
    let mut host_bytes = 0;
    unsafe {
        try_ffi!(sys::cusolverDnXpotrf_bufferSize(
            ctx.as_raw(),
            params.as_raw(),
            fill_mode.into(),
            to_i64(n, "n")?,
            a_type.into(),
            a.data.as_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            compute_type.into(),
            &raw mut device_bytes,
            &raw mut host_bytes,
        ))?;
    }
    Ok(WorkspaceSizes::new(
        device_bytes as usize,
        host_bytes as usize,
    ))
}

/// Use [`xpotrf_buffer_size`] to calculate the sizes needed for pre-allocated
/// workspace.
///
/// Computes the Cholesky factorization of a Hermitian positive-definite matrix.
///
/// `A` is an $n \times n$ Hermitian matrix; only its lower or upper triangular
/// part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The operation leaves the other part untouched.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular Cholesky factor `L`.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular Cholesky factor `U`.
///
/// Provide device and host workspace through `workspace`.
/// Use [`xpotrf_buffer_size`] to determine the required sizes for
/// `workspace.device` and `workspace.host`.
///
/// If Cholesky factorization fails, some leading minor of `A` is not positive
/// definite, or equivalently some diagonal element of `L` or `U` is not a real
/// number.
/// `dev_info` reports the smallest leading minor of `A` that is not positive definite.
///
/// If the reported `info` value is `-i`, the `i`th parameter is invalid.
///
/// Currently, [`xpotrf`] supports only the default algorithm.
///
/// **Algorithms supported by [`xpotrf`]**
///
/// | Algorithm | Notes |
/// | --- | --- |
/// | [`AlgorithmMode::Default`](crate::types::AlgorithmMode::Default) | Default algorithm. |
///
/// List of input arguments for [`xpotrf_buffer_size`] and [`xpotrf`]:
///
/// The generic cuSOLVER routine separates matrix and compute data types: `data_type_a` is
/// the data type of matrix `A`, and `compute_type` is the operation's compute
/// type.
/// [`xpotrf`] only supports the following four combinations.
///
/// **Valid combination of data type and compute type**
///
/// | **data_type_a** | **compute_type** | **Meaning** |
/// | --- | --- | --- |
/// | [`DataType::F32`] | [`DataType::F32`] | `SPOTRF` |
/// | [`DataType::F64`] | [`DataType::F64`] | `DPOTRF` |
/// | [`DataType::ComplexF32`] | [`DataType::ComplexF32`] | `CPOTRF` |
/// | [`DataType::ComplexF64`] | [`DataType::ComplexF64`] | `ZPOTRF` |
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, or if cuSOLVER reports
/// an internal failure.
pub fn xpotrf<TA: DataTypeLike>(
    ctx: &Context,
    params: &Params,
    fill_mode: FillMode,
    n: usize,
    a: MatrixMut<'_, TA>,
    compute_type: DataType,
    workspace: ByteWorkspaceMut<'_>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    let a_type = TA::data_type();
    validate_x_matrix(n, n, a.data.byte_len(), a.leading_dimension, a_type)?;
    require_info_buffer(dev_info)?;
    let workspace_sizes = xpotrf_buffer_size(ctx, params, fill_mode, n, a.as_ref(), compute_type)?;
    require_workspace_bytes(workspace.device.byte_len(), workspace_sizes.device_bytes)?;
    require_host_workspace(workspace.host.len(), workspace_sizes.host_bytes)?;
    unsafe {
        try_ffi!(sys::cusolverDnXpotrf(
            ctx.as_raw(),
            params.as_raw(),
            fill_mode.into(),
            to_i64(n, "n")?,
            a_type.into(),
            a.data.as_mut_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            compute_type.into(),
            workspace.device.as_mut_ptr().cast(),
            workspace_sizes.device_bytes as _,
            workspace.host.as_mut_ptr().cast(),
            workspace_sizes.host_bytes as _,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Solves a system of linear equations.
///
/// Here `A` is an $n \times n$ Hermitian matrix; only its lower or upper
/// triangular part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The operation leaves the other part untouched.
///
/// Call [`xpotrf`] first to factorize matrix `A`.
/// If `fill_mode` is [`FillMode::Lower`], `A` is lower triangular Cholesky factor `L` corresponding to $A = L\cdot L^{H}$.
/// If `fill_mode` is [`FillMode::Upper`], `A` is upper triangular Cholesky factor `U` corresponding to $A = U^{H}\cdot U$.
///
/// The operation is in-place, that is, matrix `X` overwrites matrix `B` with the same leading dimension `ldb`.
///
/// If the reported `info` value is `-i`, the `i`th parameter is invalid.
///
/// Currently, [`xpotrs`] supports only the default algorithm.
///
/// **Algorithms supported by [`xpotrs`]**
///
/// | Algorithm | Notes |
/// | --- | --- |
/// | [`AlgorithmMode::Default`](crate::types::AlgorithmMode::Default) | Default algorithm. |
///
/// List of input arguments for [`xpotrs`]:
///
/// The generic cuSOLVER routine separates matrix data types: `data_type_a` is the data type
/// of matrix `A`, and `data_type_b` is the data type of matrix `B`.
/// [`xpotrs`] only supports the following four combinations.
///
/// **Valid combination of data type and compute type**
///
/// | **data_type_a** | **data_type_b** | **Meaning** |
/// | --- | --- | --- |
/// | [`DataType::F32`] | [`DataType::F32`] | `SPOTRS` |
/// | [`DataType::F64`] | [`DataType::F64`] | `DPOTRS` |
/// | [`DataType::ComplexF32`] | [`DataType::ComplexF32`] | `CPOTRS` |
/// | [`DataType::ComplexF64`] | [`DataType::ComplexF64`] | `ZPOTRS` |
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions, right-hand-side count, or leading dimensions are
/// invalid, or if cuSOLVER reports an internal failure.
pub fn xpotrs<TA: DataTypeLike, TB: DataTypeLike>(
    ctx: &Context,
    params: &Params,
    fill_mode: FillMode,
    n: usize,
    nrhs: usize,
    a: MatrixRef<'_, TA>,
    b: MatrixMut<'_, TB>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    let a_type = TA::data_type();
    let b_type = TB::data_type();
    validate_x_matrix(n, n, a.data.byte_len(), a.leading_dimension, a_type)?;
    validate_x_matrix(n, nrhs, b.data.byte_len(), b.leading_dimension, b_type)?;
    require_info_buffer(dev_info)?;
    unsafe {
        try_ffi!(sys::cusolverDnXpotrs(
            ctx.as_raw(),
            params.as_raw(),
            fill_mode.into(),
            to_i64(n, "n")?,
            to_i64(nrhs, "nrhs")?,
            a_type.into(),
            a.data.as_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            b_type.into(),
            b.data.as_mut_ptr().cast(),
            to_i64(b.leading_dimension, "ldb")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn xtrtri_buffer_size<TA: DataTypeLike>(
    ctx: &Context,
    fill_mode: FillMode,
    diagonal_type: DiagonalType,
    n: usize,
    a: MatrixRef<'_, TA>,
) -> Result<WorkspaceSizes> {
    ctx.bind()?;
    validate_x_matrix(
        n,
        n,
        a.data.byte_len(),
        a.leading_dimension,
        TA::data_type(),
    )?;
    let mut device_bytes = 0;
    let mut host_bytes = 0;
    unsafe {
        try_ffi!(sys::cusolverDnXtrtri_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            diagonal_type.into(),
            to_i64(n, "n")?,
            TA::data_type().into(),
            a.data.as_ptr().cast_mut().cast(),
            to_i64(a.leading_dimension, "lda")?,
            &raw mut device_bytes,
            &raw mut host_bytes,
        ))?;
    }
    Ok(WorkspaceSizes::new(
        device_bytes as usize,
        host_bytes as usize,
    ))
}

/// Use the matching buffer-size helper to calculate the sizes needed for pre-allocated workspace.
///
/// Computes the inverse of a triangular matrix through the generic cuSOLVER routine.
///
/// `A` is an $n \times n$ triangular matrix, only lower or upper part is meaningful.
/// `fill_mode` indicates which part of the matrix is used.
/// The other triangular part is left unchanged.
///
/// If `fill_mode` is [`FillMode::Lower`], only the lower triangular part of `A` is processed and replaced by the lower triangular inverse.
///
/// If `fill_mode` is [`FillMode::Upper`], only the upper triangular part of `A` is processed and replaced by the upper triangular inverse.
///
/// Provide device and host workspace through `workspace`.
/// Use [`xtrtri_buffer_size`] to determine the required sizes for
/// `workspace.device` and `workspace.host`.
///
/// If matrix inversion fails, `dev_info = i` shows `A(i, i) = 0`.
///
/// If the reported `info` value is `-i`, the `i`th parameter is invalid.
///
/// List of input arguments for [`xtrtri_buffer_size`] and [`xtrtri`]:
///
/// **Valid data types**
///
/// | Algorithm | Notes |
/// | --- | --- |
/// | data type | Meaning |
/// | [`DataType::F32`] | `STRTRI` |
/// | [`DataType::F64`] | `DTRTRI` |
/// | [`DataType::ComplexF32`] | `CTRTRI` |
/// | [`DataType::ComplexF64`] | `ZTRTRI` |
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the data type is not
/// supported, or if cuSOLVER reports an internal failure.
pub fn xtrtri<TA: DataTypeLike>(
    ctx: &Context,
    fill_mode: FillMode,
    diagonal_type: DiagonalType,
    n: usize,
    a: MatrixMut<'_, TA>,
    workspace: ByteWorkspaceMut<'_>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_x_matrix(
        n,
        n,
        a.data.byte_len(),
        a.leading_dimension,
        TA::data_type(),
    )?;
    require_info_buffer(dev_info)?;
    let workspace_sizes = xtrtri_buffer_size(ctx, fill_mode, diagonal_type, n, a.as_ref())?;
    require_workspace_bytes(workspace.device.byte_len(), workspace_sizes.device_bytes)?;
    require_host_workspace(workspace.host.len(), workspace_sizes.host_bytes)?;
    unsafe {
        try_ffi!(sys::cusolverDnXtrtri(
            ctx.as_raw(),
            fill_mode.into(),
            diagonal_type.into(),
            to_i64(n, "n")?,
            TA::data_type().into(),
            a.data.as_mut_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            workspace.device.as_mut_ptr().cast(),
            workspace_sizes.device_bytes as _,
            workspace.host.as_mut_ptr().cast(),
            workspace_sizes.host_bytes as _,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn xgetrf_buffer_size<TA: DataTypeLike>(
    ctx: &Context,
    params: &Params,
    m: usize,
    n: usize,
    a: MatrixRef<'_, TA>,
    compute_type: DataType,
) -> Result<WorkspaceSizes> {
    ctx.bind()?;
    let a_type = TA::data_type();
    validate_x_matrix(m, n, a.data.byte_len(), a.leading_dimension, a_type)?;
    let mut device_bytes = 0;
    let mut host_bytes = 0;
    unsafe {
        try_ffi!(sys::cusolverDnXgetrf_bufferSize(
            ctx.as_raw(),
            params.as_raw(),
            to_i64(m, "m")?,
            to_i64(n, "n")?,
            a_type.into(),
            a.data.as_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            compute_type.into(),
            &raw mut device_bytes,
            &raw mut host_bytes,
        ))?;
    }
    Ok(WorkspaceSizes::new(
        device_bytes as usize,
        host_bytes as usize,
    ))
}

/// Computes the LU factorization of an $m \times n$ matrix
///
/// where `A` is an $m \times n$ matrix, `P` is a permutation matrix, `L` is a lower triangular matrix with unit diagonal, and `U` is an upper triangular matrix.
///
/// If LU factorization failed, that is, matrix `A` (`U`) is singular, `dev_info = i` indicates `U(i,i) = 0`.
///
/// If the reported `info` value is `-i`, the `i`th parameter is invalid.
///
/// If `pivots` is `None`, no pivoting is performed.
/// The factorization is `A=L*U`, which is not numerically stable.
///
/// Whether LU factorization succeeds or fails, `pivots` contains the pivoting
/// sequence. Row `i` is interchanged with row `pivots[i]`.
///
/// Provide device and host workspace through `workspace`.
/// Use [`xgetrf_buffer_size`] to determine the required sizes for
/// `workspace.device` and `workspace.host`.
///
/// Callers can combine [`xgetrf`] and [`xgetrs`] to complete a linear solver.
///
/// Currently, [`xgetrf`] supports two algorithms.
/// To select the legacy implementation, call [`Params::set_adv_options`].
///
/// **Algorithms supported by [`xgetrf`]**
///
/// | Algorithm | Notes |
/// | --- | --- |
/// | [`AlgorithmMode::Default`](crate::types::AlgorithmMode::Default) | Fastest algorithm; requires a large workspace of `m*n` elements. |
/// | [`AlgorithmMode::Algorithm1`](crate::types::AlgorithmMode::Algorithm1) | Legacy implementation. |
///
/// List of input arguments for [`xgetrf_buffer_size`] and [`xgetrf`]:
///
/// The generic cuSOLVER routine has two data types: `data_type_a` is the data type of matrix `A`, and `compute_type` is the operation's compute type.
/// [`xgetrf`] only supports the following four combinations.
///
/// **Valid combination of data type and compute type**
///
/// | **data_type_a** | **compute_type** | **Meaning** |
/// | --- | --- | --- |
/// | [`DataType::F32`] | [`DataType::F32`] | `SGETRF` |
/// | [`DataType::F64`] | [`DataType::F64`] | `DGETRF` |
/// | [`DataType::ComplexF32`] | [`DataType::ComplexF32`] | `CGETRF` |
/// | [`DataType::ComplexF64`] | [`DataType::ComplexF64`] | `ZGETRF` |
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, or if cuSOLVER reports
/// an internal failure.
pub fn xgetrf<TA: DataTypeLike>(
    ctx: &Context,
    params: &Params,
    m: usize,
    n: usize,
    a: MatrixMut<'_, TA>,
    pivots: Option<&mut DeviceMemory<i64>>,
    compute_type: DataType,
    workspace: ByteWorkspaceMut<'_>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    let a_type = TA::data_type();
    validate_x_matrix(m, n, a.data.byte_len(), a.leading_dimension, a_type)?;
    if let Some(pivots) = pivots.as_ref() {
        require_pivot64_buffer(pivots, m.min(n))?;
    }
    require_info_buffer(dev_info)?;
    let workspace_sizes = xgetrf_buffer_size(ctx, params, m, n, a.as_ref(), compute_type)?;
    require_workspace_bytes(workspace.device.byte_len(), workspace_sizes.device_bytes)?;
    require_host_workspace(workspace.host.len(), workspace_sizes.host_bytes)?;
    unsafe {
        try_ffi!(sys::cusolverDnXgetrf(
            ctx.as_raw(),
            params.as_raw(),
            to_i64(m, "m")?,
            to_i64(n, "n")?,
            a_type.into(),
            a.data.as_mut_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            pivots.map_or(std::ptr::null_mut(), |p| p.as_mut_ptr()),
            compute_type.into(),
            workspace.device.as_mut_ptr().cast(),
            workspace_sizes.device_bytes as _,
            workspace.host.as_mut_ptr().cast(),
            workspace_sizes.host_bytes as _,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

/// Solves a linear system of multiple right-hand sides
///
/// where `A` is an $n \times n$ matrix, and was LU-factored by [`xgetrf`], that is, lower triangular part of A is `L`, and upper triangular part (including diagonal elements) of `A` is `U`.
/// `B` is an $n \times {nrhs}$ right-hand side matrix.
///
/// The `operation` argument is described by [`Operation`].
///
/// `pivots` is an output of [`xgetrf`].
/// It contains the pivot indices used to permute the right-hand sides.
///
/// If the reported `info` value is `-i`, the `i`th parameter is invalid.
///
/// Callers can combine [`xgetrf`] and [`xgetrs`] to complete a linear solver.
///
/// Currently, [`xgetrs`] supports only the default algorithm.
///
/// **Algorithms supported by [`xgetrs`]**
///
/// | Algorithm | Notes |
/// | --- | --- |
/// | [`AlgorithmMode::Default`](crate::types::AlgorithmMode::Default) | Default algorithm. |
///
/// List of input arguments for [`xgetrs`]:
///
/// The generic cuSOLVER routine has two data types: `data_type_a` is the data type of matrix `A`, and `data_type_b` is the data type of matrix `B`.
/// [`xgetrs`] only supports the following four combinations:
///
/// **Valid combination of data type and compute type**
///
/// | **data_type_a** | **data_type_b** | **Meaning** |
/// | --- | --- | --- |
/// | [`DataType::F32`] | [`DataType::F32`] | `SGETRS` |
/// | [`DataType::F64`] | [`DataType::F64`] | `DGETRS` |
/// | [`DataType::ComplexF32`] | [`DataType::ComplexF32`] | `CGETRS` |
/// | [`DataType::ComplexF64`] | [`DataType::ComplexF64`] | `ZGETRS` |
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimensions are invalid, or if cuSOLVER reports
/// an internal failure.
pub fn xgetrs<TA: DataTypeLike, TB: DataTypeLike>(
    ctx: &Context,
    params: &Params,
    operation: Operation,
    n: usize,
    nrhs: usize,
    a: MatrixRef<'_, TA>,
    pivots: &DeviceMemory<i64>,
    b: MatrixMut<'_, TB>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    let a_type = TA::data_type();
    let b_type = TB::data_type();
    validate_x_matrix(n, n, a.data.byte_len(), a.leading_dimension, a_type)?;
    require_pivot64_buffer(pivots, n)?;
    validate_x_matrix(n, nrhs, b.data.byte_len(), b.leading_dimension, b_type)?;
    require_info_buffer(dev_info)?;
    unsafe {
        try_ffi!(sys::cusolverDnXgetrs(
            ctx.as_raw(),
            params.as_raw(),
            operation.into(),
            to_i64(n, "n")?,
            to_i64(nrhs, "nrhs")?,
            a_type.into(),
            a.data.as_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            pivots.as_ptr().cast(),
            b_type.into(),
            b.data.as_mut_ptr().cast(),
            to_i64(b.leading_dimension, "ldb")?,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn xsytrs_buffer_size<TA: DataTypeLike, TB: DataTypeLike>(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    nrhs: usize,
    a: MatrixRef<'_, TA>,
    pivots: Option<&DeviceMemory<i64>>,
    b: MatrixRef<'_, TB>,
) -> Result<WorkspaceSizes> {
    ctx.bind()?;
    validate_x_matrix(
        n,
        n,
        a.data.byte_len(),
        a.leading_dimension,
        TA::data_type(),
    )?;
    validate_x_matrix(
        n,
        nrhs,
        b.data.byte_len(),
        b.leading_dimension,
        TB::data_type(),
    )?;
    if let Some(pivots) = pivots {
        require_pivot64_buffer(pivots, n)?;
    }

    let mut device_bytes = 0;
    let mut host_bytes = 0;
    unsafe {
        try_ffi!(sys::cusolverDnXsytrs_bufferSize(
            ctx.as_raw(),
            fill_mode.into(),
            to_i64(n, "n")?,
            to_i64(nrhs, "nrhs")?,
            TA::data_type().into(),
            a.data.as_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            pivots.map_or(std::ptr::null(), DeviceMemory::as_ptr),
            TB::data_type().into(),
            b.data.as_ptr().cast_mut().cast(),
            to_i64(b.leading_dimension, "ldb")?,
            &raw mut device_bytes,
            &raw mut host_bytes,
        ))?;
    }
    Ok(WorkspaceSizes::new(
        device_bytes as usize,
        host_bytes as usize,
    ))
}

/// Use the matching buffer-size helper to calculate the sizes needed for pre-allocated workspace.
///
/// Solves a system of linear equations through the generic cuSOLVER routine.
///
/// `A` contains the factorization produced by the typed `*sytrf` operations in this module.
/// Only the lower or upper part is meaningful; the other part is left untouched.
///
/// Provide the pivot indices returned by the matching `*sytrf` operation, along
/// with device and host workspace through `workspace`.
/// Use [`xsytrs_buffer_size`] to determine the required sizes for
/// `workspace.device` and `workspace.host`.
/// To factorize and solve the symmetric system without pivoting, pass `None`
/// for the pivot buffer to both the matching `*sytrf` operation and [`xsytrs`].
///
/// If the reported `dev_info` value is `-i`, the `i`th parameter is invalid.
///
/// List of input arguments for [`xsytrs_buffer_size`] and [`xsytrs`]:
///
/// The generic cuSOLVER routine has two data types: `data_type_a` is the data type of the
/// matrix `A`, and `data_type_b` is the data type of the matrix `B`.
/// [`xsytrs`] only supports the following four combinations:
///
/// **Valid combination of data type and compute type**
///
/// | **data_type_a** | **data_type_b** | **Meaning** |
/// | --- | --- | --- |
/// | [`DataType::F32`] | [`DataType::F32`] | `SSYTRS` |
/// | [`DataType::F64`] | [`DataType::F64`] | `DSYTRS` |
/// | [`DataType::ComplexF32`] | [`DataType::ComplexF32`] | `CSYTRS` |
/// | [`DataType::ComplexF64`] | [`DataType::ComplexF64`] | `ZSYTRS` |
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// matrix dimensions or leading dimension are invalid, if the matrix data type
/// is not supported, or if cuSOLVER reports an internal failure.
pub fn xsytrs<TA: DataTypeLike, TB: DataTypeLike>(
    ctx: &Context,
    fill_mode: FillMode,
    n: usize,
    nrhs: usize,
    a: MatrixRef<'_, TA>,
    pivots: Option<&DeviceMemory<i64>>,
    b: MatrixMut<'_, TB>,
    workspace: ByteWorkspaceMut<'_>,
    dev_info: &mut DeviceMemory<i32>,
) -> Result<()> {
    ctx.bind()?;
    validate_x_matrix(
        n,
        n,
        a.data.byte_len(),
        a.leading_dimension,
        TA::data_type(),
    )?;
    validate_x_matrix(
        n,
        nrhs,
        b.data.byte_len(),
        b.leading_dimension,
        TB::data_type(),
    )?;
    if let Some(pivots) = pivots {
        require_pivot64_buffer(pivots, n)?;
    }
    require_info_buffer(dev_info)?;
    let workspace_sizes = xsytrs_buffer_size(ctx, fill_mode, n, nrhs, a, pivots, b.as_ref())?;
    require_workspace_bytes(workspace.device.byte_len(), workspace_sizes.device_bytes)?;
    require_host_workspace(workspace.host.len(), workspace_sizes.host_bytes)?;
    unsafe {
        try_ffi!(sys::cusolverDnXsytrs(
            ctx.as_raw(),
            fill_mode.into(),
            to_i64(n, "n")?,
            to_i64(nrhs, "nrhs")?,
            TA::data_type().into(),
            a.data.as_ptr().cast(),
            to_i64(a.leading_dimension, "lda")?,
            pivots.map_or(std::ptr::null(), DeviceMemory::as_ptr),
            TB::data_type().into(),
            b.data.as_mut_ptr().cast(),
            to_i64(b.leading_dimension, "ldb")?,
            workspace.device.as_mut_ptr().cast(),
            workspace_sizes.device_bytes as _,
            workspace.host.as_mut_ptr().cast(),
            workspace_sizes.host_bytes as _,
            dev_info.as_mut_ptr().cast(),
        ))?;
    }
    Ok(())
}

pub fn xlarft_buffer_size<TV: DataTypeLike, TTau: DataTypeLike, TT: DataTypeLike>(
    ctx: &Context,
    params: &Params,
    direct: DirectMode,
    storev: StorevMode,
    n: usize,
    k: usize,
    v: MatrixRef<'_, TV>,
    tau: VectorRef<'_, TTau>,
    t: MatrixRef<'_, TT>,
    compute_type: DataType,
) -> Result<WorkspaceSizes> {
    ctx.bind()?;
    let v_type = TV::data_type();
    let tau_type = TTau::data_type();
    let t_type = TT::data_type();
    validate_xlarft_inputs(
        n,
        k,
        storev,
        v.data.byte_len(),
        v.leading_dimension,
        v_type,
        tau.data.byte_len(),
        tau_type,
        t.data.byte_len(),
        t.leading_dimension,
        t_type,
    )?;
    let mut device_bytes = 0;
    let mut host_bytes = 0;
    unsafe {
        try_ffi!(sys::cusolverDnXlarft_bufferSize(
            ctx.as_raw(),
            params.as_raw(),
            direct.into(),
            storev.into(),
            to_i64(n, "n")?,
            to_i64(k, "k")?,
            v_type.into(),
            v.data.as_ptr().cast(),
            to_i64(v.leading_dimension, "ldv")?,
            tau_type.into(),
            tau.data.as_ptr().cast(),
            t_type.into(),
            t.data.as_ptr().cast_mut().cast(),
            to_i64(t.leading_dimension, "ldt")?,
            compute_type.into(),
            &raw mut device_bytes,
            &raw mut host_bytes,
        ))?;
    }
    Ok(WorkspaceSizes::new(
        device_bytes as usize,
        host_bytes as usize,
    ))
}

/// Use the matching buffer-size helper to calculate the sizes needed for pre-allocated workspace.
///
/// Forms the triangular factor `T` of a real block reflector `H` of order `n`,
/// which is defined as a product of `k` elementary reflectors.
///
/// Only [`StorevMode::Columnwise`] storage is supported. This means the vector
/// defining the elementary reflector `H(i)` is stored in the `i`th column of
/// `V`, and $H = I - V \cdot T \cdot V^{T}$ ($H = I - V \cdot T \cdot V^{H}$
/// for complex types).
///
/// Provide device and host workspace through `workspace`.
/// Use [`xlarft_buffer_size`] to determine the required sizes for
/// `workspace.device` and `workspace.host`.
///
/// Currently, only the `n >= k` scenario is supported.
///
/// The generic cuSOLVER routine has four data types:
///
/// [`xlarft`] only supports the following four combinations.
///
/// **Valid combinations of data types and compute types**
///
/// | **data_type_v** | **data_type_tau** | **data_type_t** | **compute_type** | **Meaning** |
/// | --- | --- | --- | --- | --- |
/// | [`DataType::F32`] | [`DataType::F32`] | [`DataType::F32`] | [`DataType::F32`] | `SLARFT` |
/// | [`DataType::F64`] | [`DataType::F64`] | [`DataType::F64`] | [`DataType::F64`] | `DLARFT` |
/// | [`DataType::ComplexF32`] | [`DataType::ComplexF32`] | [`DataType::ComplexF32`] | [`DataType::ComplexF32`] | `CLARFT` |
/// | [`DataType::ComplexF64`] | [`DataType::ComplexF64`] | [`DataType::ComplexF64`] | [`DataType::ComplexF64`] | `ZLARFT` |
///
/// # Errors
///
/// Returns an error if cuSOLVER has not been initialized, if the
/// reflector dimensions or storage mode are invalid, or if cuSOLVER reports an
/// internal failure.
pub fn xlarft<TV: DataTypeLike, TTau: DataTypeLike, TT: DataTypeLike>(
    ctx: &Context,
    params: &Params,
    direct: DirectMode,
    storev: StorevMode,
    n: usize,
    k: usize,
    v: MatrixRef<'_, TV>,
    tau: VectorRef<'_, TTau>,
    t: MatrixMut<'_, TT>,
    compute_type: DataType,
    workspace: ByteWorkspaceMut<'_>,
) -> Result<()> {
    ctx.bind()?;
    let v_type = TV::data_type();
    let tau_type = TTau::data_type();
    let t_type = TT::data_type();
    validate_xlarft_inputs(
        n,
        k,
        storev,
        v.data.byte_len(),
        v.leading_dimension,
        v_type,
        tau.data.byte_len(),
        tau_type,
        t.data.byte_len(),
        t.leading_dimension,
        t_type,
    )?;
    let workspace_sizes = xlarft_buffer_size(
        ctx,
        params,
        direct,
        storev,
        n,
        k,
        v,
        tau,
        t.as_ref(),
        compute_type,
    )?;
    require_workspace_bytes(workspace.device.byte_len(), workspace_sizes.device_bytes)?;
    require_host_workspace(workspace.host.len(), workspace_sizes.host_bytes)?;
    unsafe {
        try_ffi!(sys::cusolverDnXlarft(
            ctx.as_raw(),
            params.as_raw(),
            direct.into(),
            storev.into(),
            to_i64(n, "n")?,
            to_i64(k, "k")?,
            v_type.into(),
            v.data.as_ptr().cast(),
            to_i64(v.leading_dimension, "ldv")?,
            tau_type.into(),
            tau.data.as_ptr().cast(),
            t_type.into(),
            t.data.as_mut_ptr().cast(),
            to_i64(t.leading_dimension, "ldt")?,
            compute_type.into(),
            workspace.device.as_mut_ptr().cast(),
            workspace_sizes.device_bytes as _,
            workspace.host.as_mut_ptr().cast(),
            workspace_sizes.host_bytes as _,
        ))?;
    }
    Ok(())
}

fn validate_square_matrix(n: usize, len: usize, lda: usize) -> Result<()> {
    validate_matrix(n, n, len, lda)
}

fn validate_matrix(rows: usize, cols: usize, len: usize, lda: usize) -> Result<()> {
    if rows == 0 || cols == 0 {
        return Err(Error::InvalidMatrixShape);
    }
    if lda < rows {
        return Err(Error::InvalidLeadingDimension);
    }
    let required = lda.checked_mul(cols).ok_or(Error::InvalidMatrixShape)?;
    if len < required {
        return Err(Error::InvalidMatrixShape);
    }
    Ok(())
}

fn require_workspace(actual: usize, required: usize) -> Result<()> {
    if actual < required {
        return Err(Error::InsufficientWorkspaceSize { required, actual });
    }
    Ok(())
}

fn require_workspace_bytes(actual: usize, required: usize) -> Result<()> {
    if actual < required {
        return Err(Error::InsufficientWorkspaceSize { required, actual });
    }
    Ok(())
}

fn require_host_workspace(actual: usize, required: usize) -> Result<()> {
    if actual < required {
        return Err(Error::InsufficientWorkspaceSize { required, actual });
    }
    Ok(())
}

fn require_info_buffer(dev_info: &DeviceMemory<i32>) -> Result<()> {
    if dev_info.is_empty() {
        return Err(Error::InvalidVectorShape);
    }
    Ok(())
}

fn require_info_entries(dev_info: &DeviceMemory<i32>, required: usize) -> Result<()> {
    if dev_info.len() < required {
        return Err(Error::InvalidVectorShape);
    }
    Ok(())
}

fn require_pivot_buffer(pivots: &DeviceMemory<i32>, required: usize) -> Result<()> {
    if pivots.len() < required {
        return Err(Error::InvalidVectorShape);
    }
    Ok(())
}

fn require_pivot64_buffer(pivots: &DeviceMemory<i64>, required: usize) -> Result<()> {
    if pivots.len() < required {
        return Err(Error::InvalidVectorShape);
    }
    Ok(())
}

fn require_tau_buffer<T>(tau: &DeviceMemory<T>, required: usize) -> Result<()> {
    if tau.len() < required {
        return Err(Error::InvalidVectorShape);
    }
    Ok(())
}

fn qr_rows(side: SideMode, m: usize, n: usize) -> usize {
    match side {
        SideMode::Left => m,
        SideMode::Right => n,
    }
}

fn tridiagonal_order(side: SideMode, m: usize, n: usize) -> usize {
    match side {
        SideMode::Left => m,
        SideMode::Right => n,
    }
}

fn validate_bidiagonal_dims(m: usize, n: usize) -> Result<()> {
    if m == 0 || n == 0 || m < n {
        return Err(Error::InvalidMatrixShape);
    }
    Ok(())
}

fn validate_bidiagonal_buffers(
    m: usize,
    n: usize,
    a_len: usize,
    lda: usize,
    d_len: usize,
    e_len: usize,
    tauq_len: usize,
    taup_len: usize,
) -> Result<()> {
    validate_bidiagonal_dims(m, n)?;
    validate_matrix(m, n, a_len, lda)?;
    if d_len < n || e_len < n || tauq_len < n || taup_len < n {
        return Err(Error::InvalidVectorShape);
    }
    Ok(())
}

fn validate_orgbr_inputs(
    side: SideMode,
    m: usize,
    n: usize,
    k: usize,
    a_len: usize,
    lda: usize,
    tau_len: usize,
) -> Result<()> {
    if m == 0 || n == 0 || k == 0 {
        return Err(Error::InvalidMatrixShape);
    }
    validate_matrix(m, n, a_len, lda)?;
    if tau_len < k {
        return Err(Error::InvalidVectorShape);
    }
    match side {
        SideMode::Left if m < n || k > m => Err(Error::InvalidMatrixShape),
        SideMode::Right if n < m || k > n => Err(Error::InvalidMatrixShape),
        _ => Ok(()),
    }
}

fn validate_sytrd_inputs(
    n: usize,
    a_len: usize,
    lda: usize,
    d_len: usize,
    e_len: usize,
    tau_len: usize,
) -> Result<()> {
    validate_square_matrix(n, a_len, lda)?;
    let reflectors = n.saturating_sub(1);
    if d_len < n || e_len < reflectors || tau_len < reflectors {
        return Err(Error::InvalidVectorShape);
    }
    Ok(())
}

fn validate_orgtr_inputs(n: usize, a_len: usize, lda: usize, tau_len: usize) -> Result<()> {
    validate_square_matrix(n, a_len, lda)?;
    if tau_len < n.saturating_sub(1) {
        return Err(Error::InvalidVectorShape);
    }
    Ok(())
}

fn validate_ormtr_inputs(
    side: SideMode,
    m: usize,
    n: usize,
    a_len: usize,
    lda: usize,
    tau_len: usize,
    c_len: usize,
    ldc: usize,
) -> Result<()> {
    let nq = tridiagonal_order(side, m, n);
    validate_square_matrix(nq, a_len, lda)?;
    validate_matrix(m, n, c_len, ldc)?;
    if tau_len < nq.saturating_sub(1) {
        return Err(Error::InvalidVectorShape);
    }
    Ok(())
}

fn validate_batched_square_matrix_pointers<T>(
    n: usize,
    matrices: BatchedMatrixRef<'_, T>,
) -> Result<()> {
    if n == 0 || matrices.is_empty() {
        return Err(Error::InvalidMatrixShape);
    }
    if matrices.leading_dimension < n {
        return Err(Error::InvalidLeadingDimension);
    }
    Ok(())
}

fn validate_batched_vector_pointers<T>(n: usize, vectors: BatchedVectorRef<'_, T>) -> Result<()> {
    if n == 0 || vectors.is_empty() {
        return Err(Error::InvalidVectorShape);
    }
    if vectors.leading_dimension < n {
        return Err(Error::InvalidLeadingDimension);
    }
    Ok(())
}

fn validate_x_matrix(
    rows: usize,
    cols: usize,
    bytes: usize,
    lda: usize,
    data_type: DataType,
) -> Result<()> {
    if rows == 0 || cols == 0 {
        return Err(Error::InvalidMatrixShape);
    }
    if lda < rows {
        return Err(Error::InvalidLeadingDimension);
    }
    let required = lda
        .checked_mul(cols)
        .and_then(|count| count.checked_mul(data_type.size_in_bytes()))
        .ok_or(Error::InvalidMatrixShape)?;
    if bytes < required {
        return Err(Error::InvalidMatrixShape);
    }
    Ok(())
}

fn validate_x_vector(len: usize, bytes: usize, data_type: DataType) -> Result<()> {
    let required = len
        .checked_mul(data_type.size_in_bytes())
        .ok_or(Error::InvalidVectorShape)?;
    if bytes < required {
        return Err(Error::InvalidVectorShape);
    }
    Ok(())
}

fn validate_xlarft_inputs(
    n: usize,
    k: usize,
    storev: StorevMode,
    v_bytes: usize,
    ldv: usize,
    v_type: DataType,
    tau_bytes: usize,
    tau_type: DataType,
    t_bytes: usize,
    ldt: usize,
    t_type: DataType,
) -> Result<()> {
    if n == 0 || k == 0 || k > n {
        return Err(Error::InvalidMatrixShape);
    }
    if storev != StorevMode::Columnwise {
        return Err(Error::InvalidMatrixShape);
    }
    validate_x_matrix(n, k, v_bytes, ldv, v_type)?;
    validate_x_vector(k, tau_bytes, tau_type)?;
    validate_x_matrix(k, k, t_bytes, ldt, t_type)?;
    Ok(())
}