Trait ComplexScalar 

pub trait ComplexScalar:
    Copy
    + Sized
    + Sealed {
    type Real: Copy + Default;

    // Required methods
    fn axpyi(
        alpha: Self,
        x: &[Self],
        indx: &[aoclsparse_int],
        y: &mut [Self],
    ) -> Result<()>;
    fn gthr(y: &[Self], indx: &[aoclsparse_int], x: &mut [Self]) -> Result<()>;
    fn sctr(x: &[Self], indx: &[aoclsparse_int], y: &mut [Self]) -> Result<()>;
    fn create_csr(
        base: IndexBase,
        m: usize,
        n: usize,
        nnz: usize,
        row_ptr: *mut aoclsparse_int,
        col_idx: *mut aoclsparse_int,
        val: *mut Self,
    ) -> Result<aoclsparse_matrix>;
    fn export_csr(
        mat: aoclsparse_matrix,
    ) -> Result<(IndexBase, usize, usize, usize, *mut aoclsparse_int, *mut aoclsparse_int, *mut Self)>;
    fn mv(
        op: Trans,
        alpha: Self,
        mat: aoclsparse_matrix,
        descr: &MatDescr,
        x: &[Self],
        beta: Self,
        y: &mut [Self],
    ) -> Result<()>;
    fn trsv(
        op: Trans,
        alpha: Self,
        mat: aoclsparse_matrix,
        descr: &MatDescr,
        b: &[Self],
        x: &mut [Self],
    ) -> Result<()>;
    fn ilu_smoother(
        op: Trans,
        a: aoclsparse_matrix,
        descr: &MatDescr,
        x: &mut [Self],
        b: &[Self],
    ) -> Result<()>;
    fn itsol_init(handle: &mut aoclsparse_itsol_handle) -> Result<()>;
    fn itsol_solve(
        handle: aoclsparse_itsol_handle,
        n: usize,
        mat: aoclsparse_matrix,
        descr: &MatDescr,
        b: &[Self],
        x: &mut [Self],
        rinfo: &mut [Self::Real; 100],
    ) -> Result<()>;
    fn csrmm(
        op: Trans,
        alpha: Self,
        a: aoclsparse_matrix,
        descr: &MatDescr,
        order: Order,
        b: &[Self],
        n: usize,
        ldb: usize,
        beta: Self,
        c: &mut [Self],
        ldc: usize,
    ) -> Result<()>;
    fn spmmd(
        op: Trans,
        a: aoclsparse_matrix,
        b: aoclsparse_matrix,
        layout: Order,
        c: &mut [Self],
        ldc: usize,
    ) -> Result<()>;
    fn sp2md(
        op_a: Trans,
        descr_a: &MatDescr,
        a: aoclsparse_matrix,
        op_b: Trans,
        descr_b: &MatDescr,
        b: aoclsparse_matrix,
        alpha: Self,
        beta: Self,
        c: &mut [Self],
        layout: Order,
        ldc: usize,
    ) -> Result<()>;
    unsafe fn add_ffi(
        op: aoclsparse_operation,
        a: aoclsparse_matrix,
        alpha: Self,
        b: aoclsparse_matrix,
        out: *mut aoclsparse_matrix,
    ) -> aoclsparse_status;
    fn sorv(
        sor_type: SorType,
        descr: &MatDescr,
        a: aoclsparse_matrix,
        omega: Self,
        alpha: Self,
        x: &mut [Self],
        b: &[Self],
    ) -> Result<()>;
}

Scalar element type for the complex sparse routines (c32, c64).

Required Associated Types

type Real: Copy + Default

Underlying real type — f32 for Complex32, f64 for Complex64. Used to type the rinfo[100] array returned by iterative solvers, which is real-valued even for complex problems.

Required Methods

fn axpyi( alpha: Self, x: &[Self], indx: &[aoclsparse_int], y: &mut [Self], ) -> Result<()>

y[indx] := α·x + y[indx] (sparse vector AXPY).

fn gthr(y: &[Self], indx: &[aoclsparse_int], x: &mut [Self]) -> Result<()>

x[i] := y[indx[i]] (gather).

fn sctr(x: &[Self], indx: &[aoclsparse_int], y: &mut [Self]) -> Result<()>

y[indx[i]] := x[i] (scatter).

fn create_csr( base: IndexBase, m: usize, n: usize, nnz: usize, row_ptr: *mut aoclsparse_int, col_idx: *mut aoclsparse_int, val: *mut Self, ) -> Result<aoclsparse_matrix>

Wrap raw CSR pointers in an aoclsparse_matrix handle.

fn export_csr( mat: aoclsparse_matrix, ) -> Result<(IndexBase, usize, usize, usize, *mut aoclsparse_int, *mut aoclsparse_int, *mut Self)>

Read out a library-owned CSR matrix’s metadata and array pointers.

fn mv( op: Trans, alpha: Self, mat: aoclsparse_matrix, descr: &MatDescr, x: &[Self], beta: Self, y: &mut [Self], ) -> Result<()>

y := α · op(A) · x + β · y via the high-level matrix handle.

fn trsv( op: Trans, alpha: Self, mat: aoclsparse_matrix, descr: &MatDescr, b: &[Self], x: &mut [Self], ) -> Result<()>

Solve op(A) · x = α · b where A is sparse triangular.

fn ilu_smoother( op: Trans, a: aoclsparse_matrix, descr: &MatDescr, x: &mut [Self], b: &[Self], ) -> Result<()>

One ILU(0) smoothing step against the matrix handle.

fn itsol_init(handle: &mut aoclsparse_itsol_handle) -> Result<()>

Initialise an iterative-solver handle for this scalar type.

fn itsol_solve( handle: aoclsparse_itsol_handle, n: usize, mat: aoclsparse_matrix, descr: &MatDescr, b: &[Self], x: &mut [Self], rinfo: &mut [Self::Real; 100], ) -> Result<()>

Run the iterative solver’s forward (direct) interface.

fn csrmm( op: Trans, alpha: Self, a: aoclsparse_matrix, descr: &MatDescr, order: Order, b: &[Self], n: usize, ldb: usize, beta: Self, c: &mut [Self], ldc: usize, ) -> Result<()>

C := α · op(A) · B + β · C where A is sparse (CSR via the matrix handle) and B, C are dense.

fn spmmd( op: Trans, a: aoclsparse_matrix, b: aoclsparse_matrix, layout: Order, c: &mut [Self], ldc: usize, ) -> Result<()>

C := op(A) · B where both A and B are sparse and C is dense.

fn sp2md( op_a: Trans, descr_a: &MatDescr, a: aoclsparse_matrix, op_b: Trans, descr_b: &MatDescr, b: aoclsparse_matrix, alpha: Self, beta: Self, c: &mut [Self], layout: Order, ldc: usize, ) -> Result<()>

C := α · op_A(A) · op_B(B) + β · C (sparse·sparse → dense).

unsafe fn add_ffi( op: aoclsparse_operation, a: aoclsparse_matrix, alpha: Self, b: aoclsparse_matrix, out: *mut aoclsparse_matrix, ) -> aoclsparse_status

Sparse-sparse C := α · op(A) + B.

Safety

Caller must adopt the resulting handle (e.g. via ComplexSparseMatrix::from_library_owned).

fn sorv( sor_type: SorType, descr: &MatDescr, a: aoclsparse_matrix, omega: Self, alpha: Self, x: &mut [Self], b: &[Self], ) -> Result<()>

One step of (S)SOR / forward / backward Gauss-Seidel relaxation.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl ComplexScalar for Complex32

type Real = f32

impl ComplexScalar for Complex64

type Real = f64