Struct Complex32 

#[repr(C)]
pub struct Complex32 {
    pub re: f32,
    pub im: f32,
}

Single-precision complex number, ABI-compatible with the C struct { float real; float imag; } used by BLIS’s scomplex, LAPACK’s lapack_complex_float, and FFTW’s fftwf_complex.

Fields

re: f32

Real part.

im: f32

Imaginary part.

Implementations

impl Complex32

pub const ZERO: Complex32

0 + 0i.

pub const ONE: Complex32

1 + 0i.

pub const I: Complex32

0 + 1i.

pub const fn new(re: f32, im: f32) -> Complex32

Create a complex number re + im·i.

pub fn norm_sqr(&self) -> f32

Modulus squared re² + im² (avoids the square root of abs).

pub fn abs(&self) -> f32

Modulus √(re² + im²).

pub fn conj(&self) -> Complex32

Complex conjugate.

Trait Implementations

impl Clone for Complex32

fn clone(&self) -> Complex32

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ComplexScalar for Complex32

type Real = f32

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.

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 [f32; 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.

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.

impl Debug for Complex32

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<[f32; 2]> for Complex32

fn from(a: [f32; 2]) -> Complex32

Converts to this type from the input type.

impl From<(f32, f32)> for Complex32

fn from(_: (f32, f32)) -> Complex32

Converts to this type from the input type.

impl From<f32> for Complex32

fn from(re: f32) -> Complex32

Converts to this type from the input type.

impl PartialEq for Complex32

fn eq(&self, other: &Complex32) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Complex32

impl Sealed for Complex32

impl StructuralPartialEq for Complex32