Struct Complex64 

#[repr(C)]
pub struct Complex64 {
    pub re: f64,
    pub im: f64,
}

Double-precision complex number, ABI-compatible with the C struct { double real; double imag; } used by BLIS’s dcomplex, LAPACK’s lapack_complex_double, and FFTW’s fftw_complex.

Fields

re: f64

Real part.

im: f64

Imaginary part.

Implementations

impl Complex64

pub const ZERO: Complex64

0 + 0i.

pub const ONE: Complex64

1 + 0i.

pub const I: Complex64

0 + 1i.

pub const fn new(re: f64, im: f64) -> Complex64

Create a complex number re + im·i.

pub fn norm_sqr(&self) -> f64

Modulus squared re² + im².

pub fn abs(&self) -> f64

Modulus √(re² + im²).

pub fn conj(&self) -> Complex64

Complex conjugate.

Trait Implementations

impl Clone for Complex64

fn clone(&self) -> Complex64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComplexScalar for Complex64

type Real = f64

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 [f64; 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 Complex64

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

Formats the value using the given formatter.

impl From<[f64; 2]> for Complex64

fn from(a: [f64; 2]) -> Complex64

Converts to this type from the input type.

impl From<(f64, f64)> for Complex64

fn from(_: (f64, f64)) -> Complex64

Converts to this type from the input type.

impl From<f64> for Complex64

fn from(re: f64) -> Complex64

Converts to this type from the input type.

impl PartialEq for Complex64

fn eq(&self, other: &Complex64) -> 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 Complex64

impl Sealed for Complex64

impl StructuralPartialEq for Complex64