Type Alias c64 

pub type c64 = Complex<f64>;

Alias for a Complex<f64>

Aliased Type

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

Fields

re: f64

Real portion of the complex number

im: f64

Imaginary portion of the complex number

Trait Implementations

impl Abs for c64

type Output = f64

Output type.

fn abs(self) -> Self::Output

Return the absolute value.

impl AbsSquare for c64

type Output = f64

Output type

fn abs_square(self) -> Self::Output

Return the square of the absolute value.

impl Ev for c64

fn ev( jobz: JobZEv, uplo: EvUplo, n: usize, a: &mut [Self], lda: usize, w: &mut [Self::Real], ) -> LapackResult<()>

Compute the eigenvalues and, optionally eigenvectors of a real symmetric or hermitian matrix. Arguments:

impl Gees for c64

fn gees( jobvs: JobVs, n: usize, a: &mut [Self], lda: usize, w: &mut [Self::Complex], vs: Option<&mut [Self]>, ldvs: usize, ) -> LapackResult<()>

Compute the eigenvalues and, optionally, the Schur form of a general matrix.

impl Geev for c64

fn geev( jobvl: JobVl, jobvr: JobVr, n: usize, a: &mut [Self], lda: usize, w: &mut [Self::Complex], vl: Option<&mut [Self::Complex]>, ldvl: usize, vr: Option<&mut [Self::Complex]>, ldvr: usize, ) -> LapackResult<()>

Compute the eigenvalues and, optionally, the eigenvectors of a general matrix.

impl Gels for c64

fn gels( trans: GelsTransMode, m: usize, n: usize, nrhs: usize, a: &mut [Self], lda: usize, b: &mut [Self], ldb: usize, ) -> LapackResult<()>

Solve the least squares problem A * X = B or A^H * X = B.

impl Gemm for c64

fn gemm( transa: TransMode, transb: TransMode, m: usize, n: usize, k: usize, alpha: Self, a: &[Self], rsa: usize, csa: usize, b: &[Self], rsb: usize, csb: usize, beta: Self, c: &mut [Self], rsc: usize, csc: usize, )

Gemm

impl Geqp3 for c64

fn geqp3( m: usize, n: usize, a: &mut [Self], lda: usize, jpvt: &mut Vec<i32>, tau: &mut Vec<Self>, ) -> LapackResult<()>

Perform column pivoted QR factorization of a matrix a with dimensions m x n.

impl Geqrf for c64

fn geqrf( m: usize, n: usize, a: &mut [Self], lda: usize, tau: &mut [Self], ) -> LapackResult<()>

Perform QR factorization of a matrix a with dimensions m x n.

impl Gesdd for c64

fn gesdd( jobz: JobZ, m: usize, n: usize, a: &mut [Self], lda: usize, s: &mut [Self::Real], u: Option<&mut [Self]>, ldu: usize, vt: Option<&mut [Self]>, ldvt: usize, ) -> LapackResult<()>

Perform a singular value decomposition (SVD) of a matrix a with dimensions m x n. If jobz is JobZ::N, the singular vectors are not computed and u and vt can be None.

impl Gesvd for c64

fn gesvd( jobu: JobU, jobvt: JobVt, m: usize, n: usize, a: &mut [Self], lda: usize, s: &mut [Self::Real], u: Option<&mut [Self]>, ldu: usize, vt: Option<&mut [Self]>, ldvt: usize, ) -> LapackResult<()>

Perform a singular value decomposition (SVD) of a matrix a with dimensions m x n. If either jobu or jobvt is JobU::N or JobVt::N, the corresponding singular vectors are not computed, and the array u or correspondingly vt is not referenced and can be None.

impl Getrf for c64

fn getrf( m: usize, n: usize, a: &mut [c64], lda: usize, ipiv: &mut [i32], ) -> LapackResult<()>

Perform LU factorization of a matrix a with dimensions m x n.

impl Getri for c64

fn getri(n: usize, a: &mut [Self], lda: usize, ipiv: &[i32]) -> LapackResult<()>

Compute the inverse of a matrix a using the LU factors and pivot indices.

impl Getrs for c64

fn getrs( trans: GetrsTransMode, n: usize, nrhs: usize, a: &[Self], lda: usize, ipiv: &[i32], b: &mut [Self], ldb: usize, ) -> LapackResult<()>

Solve a system of linear equations using LU factorization.

impl MmIdentifier for c64

const MMTYPE: &'static str = "complex"

Matrix market type

impl Mqr for c64

fn mqr( side: MqrSide, trans: MqrTransMode, m: usize, n: usize, k: usize, a: &[Self], lda: usize, tau: &[Self], c: &mut [Self], ldc: usize, ) -> LapackResult<()>

Apply an orthogonal or unitary matrix given through elementary reflectors.

impl<'a, Space: LinearSpace<F = c64>> Mul<&Element<'a, Space>> for c64

type Output = Element<'a, Space>

The resulting type after applying the * operator.

fn mul(self, element: &Element<'a, Space>) -> Self::Output

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for c64

type Output = Array<ArrayScalarMult<Complex<f64>, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<'a, Space: LinearSpace<F = c64>> Mul<Element<'a, Space>> for c64

type Output = Element<'a, Space>

The resulting type after applying the * operator.

fn mul(self, element: Element<'a, Space>) -> Self::Output

Performs the * operation.

impl<OpImpl> Mul<Operator<OpImpl>> for c64

where OpImpl: OperatorBase, OpImpl::Range: LinearSpace<F = c64>,

type Output = Operator<OperatorScalarMul<Complex<f64>, OpImpl>>

The resulting type after applying the * operator.

fn mul(self, rhs: Operator<OpImpl>) -> Self::Output

Performs the * operation.

impl<I> Mul<SparseMatOpIterator<Complex<f64>, I>> for c64

where I: Iterator<Item = ([usize; 2], c64)>,

type Output = SparseMatOpIterator<Complex<f64>, ScalarMulIterator<Complex<f64>, I>>

The resulting type after applying the * operator.

fn mul(self, other: SparseMatOpIterator<c64, I>) -> Self::Output

Performs the * operation.

impl Orgqr for c64

fn orgqr( m: usize, n: usize, k: usize, a: &mut [Self], lda: usize, tau: &[Self], ) -> LapackResult<()>

Compute the matrix Q from the QR factorization of a matrix A.

impl Posv for c64

fn posv( uplo: PosvUplo, n: usize, nrhs: usize, a: &mut [Self], lda: usize, b: &mut [Self], ldb: usize, ) -> LapackResult<()>

Solve a positive definite system of linear equations with Cholesky factorization.

impl Potrf for c64

fn potrf( uplo: PotrfUplo, n: usize, a: &mut [Self], lda: usize, ) -> LapackResult<()>

Perform Cholesky factorization of a symmetric positive-definite matrix.

impl RandScalar for c64

fn random_scalar<R: Rng, D: Distribution<<Self as RlstScalar>::Real>>( rng: &mut R, dist: &D, ) -> Self

Returns a random number from a given random number generator rng and associated distribution dist.

impl RlstScalar for c64

type Real = f64

Real type

type Complex = Complex<f64>

Complex type

fn re(&self) -> Self::Real

Real part

fn im(&self) -> Self::Real

Imaginary part

fn from_real(re: Self::Real) -> Self

Create from a real number

fn pow(self, n: Self) -> Self

Raise to a power

fn powi(self, n: i32) -> Self

Raise to an integer power

fn powf(self, n: Self::Real) -> Self

Raise to a real power

fn powc(self, n: Self::Complex) -> Self::Complex

Raise to a complex power

fn real<T: ToPrimitive>(re: T) -> Self::Real

Create a new real number

fn complex<T: ToPrimitive>(re: T, im: T) -> Self::Complex

Create a new complex number

fn as_c(&self) -> Self::Complex

As a complex number

fn conj(&self) -> Self

Complex conjugate

fn square(self) -> Self::Real

Sqaure of absolute value

fn abs(self) -> Self::Real

Absolute value

fn rand(rng: &mut impl Rng) -> Self

Generate an random number from rand::distributions::Standard

fn recip(self) -> Self

Reciprocal

fn add_real(self, re: Self::Real) -> Self

Add a real number

fn sub_real(self, re: Self::Real) -> Self

Subtract a real number

fn mul_real(self, re: Self::Real) -> Self

Multiply by a real number

fn div_real(self, re: Self::Real) -> Self

Divide by a real number

fn add_complex(self, im: Self::Complex) -> Self::Complex

Add a complex number

fn sub_complex(self, im: Self::Complex) -> Self::Complex

Subtract a complex number

fn mul_complex(self, im: Self::Complex) -> Self::Complex

Multiply by a complex number

fn div_complex(self, im: Self::Complex) -> Self::Complex

Divide by a complex number

fn sqrt(self) -> Self

Square root

fn exp(self) -> Self

Exponential

fn ln(self) -> Self

Natural logarithm

fn sin(self) -> Self

Sine

fn cos(self) -> Self

Cosine

fn tan(self) -> Self

Tangeng

fn sinh(self) -> Self

Hyperbolic sine

fn cosh(self) -> Self

Hyperbolic cosine

fn tanh(self) -> Self

Hyperbolic tangent

fn asin(self) -> Self

Inverse sine

fn acos(self) -> Self

Inverse cosine

fn atan(self) -> Self

Inverse tangent

fn asinh(self) -> Self

Inverse hyperbolic sine

fn acosh(self) -> Self

Inverse hyperbolic cosine

fn atanh(self) -> Self

Inverse hyperbolic tangent

impl Trsm for c64

fn trsm( side: TrsmSide, uplo: TrsmUplo, transa: TrsmTransA, diag: TrsmDiag, m: usize, n: usize, alpha: Self, a: &mut [Self], lda: usize, b: &mut [Self], ldb: usize, ) -> LapackResult<()>

Solve a triangular system of linear equations.