```
#[repr(C)]pub struct Complex<T> {
pub re: T,
pub im: T,
}
```

## Expand description

A complex number in Cartesian form.

### Representation and Foreign Function Interface Compatibility

`Complex<T>`

is memory layout compatible with an array `[T; 2]`

.

Note that `Complex<F>`

where F is a floating point type is **only** memory
layout compatible with C’s complex types, **not** necessarily calling
convention compatible. This means that for FFI you can only pass
`Complex<F>`

behind a pointer, not as a value.

### Examples

Example of extern function declaration.

```
use num_complex::Complex;
use std::os::raw::c_int;
extern "C" {
fn zaxpy_(n: *const c_int, alpha: *const Complex<f64>,
x: *const Complex<f64>, incx: *const c_int,
y: *mut Complex<f64>, incy: *const c_int);
}
```

## Fields§

§`re: T`

Real portion of the complex number

`im: T`

Imaginary portion of the complex number

## Implementations§

source§### impl<T> Complex<T>

### impl<T> Complex<T>

source§### impl<T> Complex<T>

### impl<T> Complex<T>

source#### pub fn l1_norm(&self) -> T

#### pub fn l1_norm(&self) -> T

Returns the L1 norm `|re| + |im|`

– the Manhattan distance from the origin.

## Trait Implementations§

source§### impl<'a, T> AddAssign<&'a Complex<T>> for Complex<T>

### impl<'a, T> AddAssign<&'a Complex<T>> for Complex<T>

source§#### fn add_assign(&mut self, other: &Complex<T>)

#### fn add_assign(&mut self, other: &Complex<T>)

`+=`

operation. Read moresource§### impl<'a, T> AddAssign<&'a T> for Complex<T>

### impl<'a, T> AddAssign<&'a T> for Complex<T>

source§#### fn add_assign(&mut self, other: &T)

#### fn add_assign(&mut self, other: &T)

`+=`

operation. Read moresource§### impl<T> AddAssign<T> for Complex<T>

### impl<T> AddAssign<T> for Complex<T>

source§#### fn add_assign(&mut self, other: T)

#### fn add_assign(&mut self, other: T)

`+=`

operation. Read moresource§### impl<T> AddAssign for Complex<T>

### impl<T> AddAssign for Complex<T>

source§#### fn add_assign(&mut self, other: Complex<T>)

#### fn add_assign(&mut self, other: Complex<T>)

`+=`

operation. Read moresource§### impl<T, U> AsPrimitive<U> for Complex<T>where
T: AsPrimitive<U>,
U: 'static + Copy,

### impl<T, U> AsPrimitive<U> for Complex<T>where
T: AsPrimitive<U>,
U: 'static + Copy,

source§### impl<N> ComplexField for Complex<N>where
N: RealField + PartialOrd,

### impl<N> ComplexField for Complex<N>where
N: RealField + PartialOrd,

source§#### fn ln(self) -> Complex<N>

#### fn ln(self) -> Complex<N>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn sqrt(self) -> Complex<N>

#### fn sqrt(self) -> Complex<N>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn powf(self, exp: <Complex<N> as ComplexField>::RealField) -> Complex<N>

#### fn powf(self, exp: <Complex<N> as ComplexField>::RealField) -> Complex<N>

Raises `self`

to a floating point power.

source§#### fn log(self, base: N) -> Complex<N>

#### fn log(self, base: N) -> Complex<N>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn asin(self) -> Complex<N>

#### fn asin(self) -> Complex<N>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn acos(self) -> Complex<N>

#### fn acos(self) -> Complex<N>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn atan(self) -> Complex<N>

#### fn atan(self) -> Complex<N>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn asinh(self) -> Complex<N>

#### fn asinh(self) -> Complex<N>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn acosh(self) -> Complex<N>

#### fn acosh(self) -> Complex<N>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn atanh(self) -> Complex<N>

#### fn atanh(self) -> Complex<N>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

#### type RealField = N

source§#### fn from_real(re: <Complex<N> as ComplexField>::RealField) -> Complex<N>

#### fn from_real(re: <Complex<N> as ComplexField>::RealField) -> Complex<N>

source§#### fn real(self) -> <Complex<N> as ComplexField>::RealField

#### fn real(self) -> <Complex<N> as ComplexField>::RealField

source§#### fn imaginary(self) -> <Complex<N> as ComplexField>::RealField

#### fn imaginary(self) -> <Complex<N> as ComplexField>::RealField

source§#### fn argument(self) -> <Complex<N> as ComplexField>::RealField

#### fn argument(self) -> <Complex<N> as ComplexField>::RealField

source§#### fn modulus(self) -> <Complex<N> as ComplexField>::RealField

#### fn modulus(self) -> <Complex<N> as ComplexField>::RealField

source§#### fn modulus_squared(self) -> <Complex<N> as ComplexField>::RealField

#### fn modulus_squared(self) -> <Complex<N> as ComplexField>::RealField

source§#### fn norm1(self) -> <Complex<N> as ComplexField>::RealField

#### fn norm1(self) -> <Complex<N> as ComplexField>::RealField

#### fn recip(self) -> Complex<N>

#### fn conjugate(self) -> Complex<N>

source§#### fn scale(self, factor: <Complex<N> as ComplexField>::RealField) -> Complex<N>

#### fn scale(self, factor: <Complex<N> as ComplexField>::RealField) -> Complex<N>

`factor`

.source§#### fn unscale(self, factor: <Complex<N> as ComplexField>::RealField) -> Complex<N>

#### fn unscale(self, factor: <Complex<N> as ComplexField>::RealField) -> Complex<N>

`factor`

.#### fn floor(self) -> Complex<N>

#### fn ceil(self) -> Complex<N>

#### fn round(self) -> Complex<N>

#### fn trunc(self) -> Complex<N>

#### fn fract(self) -> Complex<N>

#### fn mul_add(self, a: Complex<N>, b: Complex<N>) -> Complex<N>

source§#### fn abs(self) -> <Complex<N> as ComplexField>::RealField

#### fn abs(self) -> <Complex<N> as ComplexField>::RealField

`self / self.signum()`

. Read more#### fn exp2(self) -> Complex<N>

#### fn exp_m1(self) -> Complex<N>

#### fn ln_1p(self) -> Complex<N>

#### fn log2(self) -> Complex<N>

#### fn log10(self) -> Complex<N>

#### fn cbrt(self) -> Complex<N>

#### fn powi(self, n: i32) -> Complex<N>

#### fn is_finite(&self) -> bool

#### fn try_sqrt(self) -> Option<Complex<N>>

source§#### fn hypot(self, b: Complex<N>) -> <Complex<N> as ComplexField>::RealField

#### fn hypot(self, b: Complex<N>) -> <Complex<N> as ComplexField>::RealField

#### fn sin_cos(self) -> (Complex<N>, Complex<N>)

#### fn sinh_cosh(self) -> (Complex<N>, Complex<N>)

source§#### fn to_polar(self) -> (Self::RealField, Self::RealField)

#### fn to_polar(self) -> (Self::RealField, Self::RealField)

source§#### fn to_exp(self) -> (Self::RealField, Self)

#### fn to_exp(self) -> (Self::RealField, Self)

#### fn sinhc(self) -> Self

#### fn coshc(self) -> Self

source§### impl<'a, T> DivAssign<&'a Complex<T>> for Complex<T>

### impl<'a, T> DivAssign<&'a Complex<T>> for Complex<T>

source§#### fn div_assign(&mut self, other: &Complex<T>)

#### fn div_assign(&mut self, other: &Complex<T>)

`/=`

operation. Read moresource§### impl<'a, T> DivAssign<&'a T> for Complex<T>

### impl<'a, T> DivAssign<&'a T> for Complex<T>

source§#### fn div_assign(&mut self, other: &T)

#### fn div_assign(&mut self, other: &T)

`/=`

operation. Read moresource§### impl<T> DivAssign<T> for Complex<T>

### impl<T> DivAssign<T> for Complex<T>

source§#### fn div_assign(&mut self, other: T)

#### fn div_assign(&mut self, other: T)

`/=`

operation. Read moresource§### impl<T> DivAssign for Complex<T>

### impl<T> DivAssign for Complex<T>

source§#### fn div_assign(&mut self, other: Complex<T>)

#### fn div_assign(&mut self, other: Complex<T>)

`/=`

operation. Read moresource§### impl<T> FromPrimitive for Complex<T>where
T: FromPrimitive + Num,

### impl<T> FromPrimitive for Complex<T>where
T: FromPrimitive + Num,

source§#### fn from_usize(n: usize) -> Option<Complex<T>>

#### fn from_usize(n: usize) -> Option<Complex<T>>

`usize`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_isize(n: isize) -> Option<Complex<T>>

#### fn from_isize(n: isize) -> Option<Complex<T>>

`isize`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u8(n: u8) -> Option<Complex<T>>

#### fn from_u8(n: u8) -> Option<Complex<T>>

`u8`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u16(n: u16) -> Option<Complex<T>>

#### fn from_u16(n: u16) -> Option<Complex<T>>

`u16`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u32(n: u32) -> Option<Complex<T>>

#### fn from_u32(n: u32) -> Option<Complex<T>>

`u32`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u64(n: u64) -> Option<Complex<T>>

#### fn from_u64(n: u64) -> Option<Complex<T>>

`u64`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i8(n: i8) -> Option<Complex<T>>

#### fn from_i8(n: i8) -> Option<Complex<T>>

`i8`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i16(n: i16) -> Option<Complex<T>>

#### fn from_i16(n: i16) -> Option<Complex<T>>

`i16`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i32(n: i32) -> Option<Complex<T>>

#### fn from_i32(n: i32) -> Option<Complex<T>>

`i32`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i64(n: i64) -> Option<Complex<T>>

#### fn from_i64(n: i64) -> Option<Complex<T>>

`i64`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u128(n: u128) -> Option<Complex<T>>

#### fn from_u128(n: u128) -> Option<Complex<T>>

`u128`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned. Read moresource§#### fn from_i128(n: i128) -> Option<Complex<T>>

#### fn from_i128(n: i128) -> Option<Complex<T>>

`i128`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned. Read moresource§### impl<'a, 'b, T> MulAddAssign<&'a Complex<T>, &'b Complex<T>> for Complex<T>

### impl<'a, 'b, T> MulAddAssign<&'a Complex<T>, &'b Complex<T>> for Complex<T>

source§#### fn mul_add_assign(&mut self, other: &Complex<T>, add: &Complex<T>)

#### fn mul_add_assign(&mut self, other: &Complex<T>, add: &Complex<T>)

`*self = (*self * a) + b`

source§### impl<T> MulAddAssign for Complex<T>

### impl<T> MulAddAssign for Complex<T>

source§#### fn mul_add_assign(&mut self, other: Complex<T>, add: Complex<T>)

#### fn mul_add_assign(&mut self, other: Complex<T>, add: Complex<T>)

`*self = (*self * a) + b`

source§### impl<'a, T> MulAssign<&'a Complex<T>> for Complex<T>

### impl<'a, T> MulAssign<&'a Complex<T>> for Complex<T>

source§#### fn mul_assign(&mut self, other: &Complex<T>)

#### fn mul_assign(&mut self, other: &Complex<T>)

`*=`

operation. Read moresource§### impl<'a, T> MulAssign<&'a T> for Complex<T>

### impl<'a, T> MulAssign<&'a T> for Complex<T>

source§#### fn mul_assign(&mut self, other: &T)

#### fn mul_assign(&mut self, other: &T)

`*=`

operation. Read moresource§### impl<T> MulAssign<T> for Complex<T>

### impl<T> MulAssign<T> for Complex<T>

source§#### fn mul_assign(&mut self, other: T)

#### fn mul_assign(&mut self, other: T)

`*=`

operation. Read moresource§### impl<T> MulAssign for Complex<T>

### impl<T> MulAssign for Complex<T>

source§#### fn mul_assign(&mut self, other: Complex<T>)

#### fn mul_assign(&mut self, other: Complex<T>)

`*=`

operation. Read moresource§### impl<T: SimdRealField> Normed for Complex<T>

### impl<T: SimdRealField> Normed for Complex<T>

§#### type Norm = <T as SimdComplexField>::SimdRealField

#### type Norm = <T as SimdComplexField>::SimdRealField

source§#### fn norm(&self) -> T::SimdRealField

#### fn norm(&self) -> T::SimdRealField

source§#### fn norm_squared(&self) -> T::SimdRealField

#### fn norm_squared(&self) -> T::SimdRealField

source§#### fn unscale_mut(&mut self, n: Self::Norm)

#### fn unscale_mut(&mut self, n: Self::Norm)

`self`

by n.source§### impl<T> Num for Complex<T>

### impl<T> Num for Complex<T>

source§#### fn from_str_radix(
s: &str,
radix: u32
) -> Result<Complex<T>, <Complex<T> as Num>::FromStrRadixErr>

#### fn from_str_radix( s: &str, radix: u32 ) -> Result<Complex<T>, <Complex<T> as Num>::FromStrRadixErr>

Parses `a +/- bi`

; `ai +/- b`

; `a`

; or `bi`

where `a`

and `b`

are of type `T`

`radix`

must be <= 18; larger radix would include *i* and *j* as digits,
which cannot be supported.

The conversion returns an error if 18 <= radix <= 36; it panics if radix > 36.

The elements of `T`

are parsed using `Num::from_str_radix`

too, and errors
(or panics) from that are reflected here as well.

#### type FromStrRadixErr = ParseComplexError<<T as Num>::FromStrRadixErr>

source§### impl<T> PartialEq for Complex<T>where
T: PartialEq,

### impl<T> PartialEq for Complex<T>where
T: PartialEq,

source§### impl<'a, T> RemAssign<&'a Complex<T>> for Complex<T>

### impl<'a, T> RemAssign<&'a Complex<T>> for Complex<T>

source§#### fn rem_assign(&mut self, other: &Complex<T>)

#### fn rem_assign(&mut self, other: &Complex<T>)

`%=`

operation. Read moresource§### impl<'a, T> RemAssign<&'a T> for Complex<T>

### impl<'a, T> RemAssign<&'a T> for Complex<T>

source§#### fn rem_assign(&mut self, other: &T)

#### fn rem_assign(&mut self, other: &T)

`%=`

operation. Read moresource§### impl<T> RemAssign<T> for Complex<T>

### impl<T> RemAssign<T> for Complex<T>

source§#### fn rem_assign(&mut self, other: T)

#### fn rem_assign(&mut self, other: T)

`%=`

operation. Read moresource§### impl<T> RemAssign for Complex<T>

### impl<T> RemAssign for Complex<T>

source§#### fn rem_assign(&mut self, modulus: Complex<T>)

#### fn rem_assign(&mut self, modulus: Complex<T>)

`%=`

operation. Read moresource§### impl SimdComplexField for Complex<AutoSimd<[f32; 16]>>

### impl SimdComplexField for Complex<AutoSimd<[f32; 16]>>

source§#### fn simd_exp(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_exp(self) -> Complex<AutoSimd<[f32; 16]>>

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

source§#### fn simd_ln(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_ln(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn simd_powf(
self,
exp: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_powf( self, exp: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 16]>>

Raises `self`

to a floating point power.

source§#### fn simd_log(self, base: AutoSimd<[f32; 16]>) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_log(self, base: AutoSimd<[f32; 16]>) -> Complex<AutoSimd<[f32; 16]>>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn simd_powc(
self,
exp: Complex<AutoSimd<[f32; 16]>>
) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_powc( self, exp: Complex<AutoSimd<[f32; 16]>> ) -> Complex<AutoSimd<[f32; 16]>>

Raises `self`

to a complex power.

source§#### fn simd_asin(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_asin(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn simd_acos(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_acos(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn simd_atan(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_atan(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn simd_asinh(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_asinh(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn simd_acosh(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_acosh(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn simd_atanh(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_atanh(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

§#### type SimdRealField = AutoSimd<[f32; 16]>

#### type SimdRealField = AutoSimd<[f32; 16]>

source§#### fn simd_horizontal_sum(
self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdValue>::Element

#### fn simd_horizontal_sum( self ) -> <Complex<AutoSimd<[f32; 16]>> as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(
self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdValue>::Element

#### fn simd_horizontal_product( self ) -> <Complex<AutoSimd<[f32; 16]>> as SimdValue>::Element

`self`

.source§#### fn from_simd_real(
re: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 16]>>

#### fn from_simd_real( re: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 16]>>

source§#### fn simd_real(
self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

#### fn simd_real( self ) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(
self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

#### fn simd_imaginary( self ) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

source§#### fn simd_argument(
self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

#### fn simd_argument( self ) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(
self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus( self ) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(
self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared( self ) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(
self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

#### fn simd_norm1( self ) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_conjugate(self) -> Complex<AutoSimd<[f32; 16]>>

source§#### fn simd_scale(
self,
factor: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_scale( self, factor: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 16]>>

`factor`

.source§#### fn simd_unscale(
self,
factor: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_unscale( self, factor: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 16]>>

`factor`

.#### fn simd_floor(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_ceil(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_round(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_trunc(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_fract(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_mul_add( self, a: Complex<AutoSimd<[f32; 16]>>, b: Complex<AutoSimd<[f32; 16]>> ) -> Complex<AutoSimd<[f32; 16]>>

source§#### fn simd_abs(
self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

#### fn simd_abs( self ) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read more#### fn simd_exp2(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_exp_m1(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_ln_1p(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_log2(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_log10(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_cbrt(self) -> Complex<AutoSimd<[f32; 16]>>

#### fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f32; 16]>>

source§#### fn simd_hypot(
self,
b: Complex<AutoSimd<[f32; 16]>>
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

#### fn simd_hypot( self, b: Complex<AutoSimd<[f32; 16]>> ) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

#### fn simd_sin_cos( self ) -> (Complex<AutoSimd<[f32; 16]>>, Complex<AutoSimd<[f32; 16]>>)

#### fn simd_sinh_cosh( self ) -> (Complex<AutoSimd<[f32; 16]>>, Complex<AutoSimd<[f32; 16]>>)

source§#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

source§#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

source§#### fn simd_signum(self) -> Self

#### fn simd_signum(self) -> Self

`self / self.modulus()`

#### fn simd_sinhc(self) -> Self

#### fn simd_coshc(self) -> Self

source§### impl SimdComplexField for Complex<AutoSimd<[f32; 2]>>

### impl SimdComplexField for Complex<AutoSimd<[f32; 2]>>

source§#### fn simd_exp(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_exp(self) -> Complex<AutoSimd<[f32; 2]>>

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

source§#### fn simd_ln(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_ln(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn simd_powf(
self,
exp: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_powf( self, exp: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 2]>>

Raises `self`

to a floating point power.

source§#### fn simd_log(self, base: AutoSimd<[f32; 2]>) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_log(self, base: AutoSimd<[f32; 2]>) -> Complex<AutoSimd<[f32; 2]>>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn simd_powc(
self,
exp: Complex<AutoSimd<[f32; 2]>>
) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_powc( self, exp: Complex<AutoSimd<[f32; 2]>> ) -> Complex<AutoSimd<[f32; 2]>>

Raises `self`

to a complex power.

source§#### fn simd_asin(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_asin(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn simd_acos(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_acos(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn simd_atan(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_atan(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn simd_asinh(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_asinh(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn simd_acosh(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_acosh(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn simd_atanh(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_atanh(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

§#### type SimdRealField = AutoSimd<[f32; 2]>

#### type SimdRealField = AutoSimd<[f32; 2]>

source§#### fn simd_horizontal_sum(
self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdValue>::Element

#### fn simd_horizontal_sum( self ) -> <Complex<AutoSimd<[f32; 2]>> as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(
self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdValue>::Element

#### fn simd_horizontal_product( self ) -> <Complex<AutoSimd<[f32; 2]>> as SimdValue>::Element

`self`

.source§#### fn from_simd_real(
re: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 2]>>

#### fn from_simd_real( re: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 2]>>

source§#### fn simd_real(
self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_real( self ) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(
self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_imaginary( self ) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

source§#### fn simd_argument(
self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_argument( self ) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(
self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus( self ) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(
self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared( self ) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(
self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_norm1( self ) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_conjugate(self) -> Complex<AutoSimd<[f32; 2]>>

source§#### fn simd_scale(
self,
factor: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_scale( self, factor: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 2]>>

`factor`

.source§#### fn simd_unscale(
self,
factor: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_unscale( self, factor: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 2]>>

`factor`

.#### fn simd_floor(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_ceil(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_round(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_trunc(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_fract(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_mul_add( self, a: Complex<AutoSimd<[f32; 2]>>, b: Complex<AutoSimd<[f32; 2]>> ) -> Complex<AutoSimd<[f32; 2]>>

source§#### fn simd_abs(
self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_abs( self ) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read more#### fn simd_exp2(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_exp_m1(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_ln_1p(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_log2(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_log10(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_cbrt(self) -> Complex<AutoSimd<[f32; 2]>>

#### fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f32; 2]>>

source§#### fn simd_hypot(
self,
b: Complex<AutoSimd<[f32; 2]>>
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_hypot( self, b: Complex<AutoSimd<[f32; 2]>> ) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_sin_cos( self ) -> (Complex<AutoSimd<[f32; 2]>>, Complex<AutoSimd<[f32; 2]>>)

#### fn simd_sinh_cosh( self ) -> (Complex<AutoSimd<[f32; 2]>>, Complex<AutoSimd<[f32; 2]>>)

source§#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

source§#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

source§#### fn simd_signum(self) -> Self

#### fn simd_signum(self) -> Self

`self / self.modulus()`

#### fn simd_sinhc(self) -> Self

#### fn simd_coshc(self) -> Self

source§### impl SimdComplexField for Complex<AutoSimd<[f32; 4]>>

### impl SimdComplexField for Complex<AutoSimd<[f32; 4]>>

source§#### fn simd_exp(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_exp(self) -> Complex<AutoSimd<[f32; 4]>>

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

source§#### fn simd_ln(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_ln(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn simd_powf(
self,
exp: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_powf( self, exp: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 4]>>

Raises `self`

to a floating point power.

source§#### fn simd_log(self, base: AutoSimd<[f32; 4]>) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_log(self, base: AutoSimd<[f32; 4]>) -> Complex<AutoSimd<[f32; 4]>>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn simd_powc(
self,
exp: Complex<AutoSimd<[f32; 4]>>
) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_powc( self, exp: Complex<AutoSimd<[f32; 4]>> ) -> Complex<AutoSimd<[f32; 4]>>

Raises `self`

to a complex power.

source§#### fn simd_asin(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_asin(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn simd_acos(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_acos(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn simd_atan(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_atan(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn simd_asinh(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_asinh(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn simd_acosh(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_acosh(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn simd_atanh(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_atanh(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

§#### type SimdRealField = AutoSimd<[f32; 4]>

#### type SimdRealField = AutoSimd<[f32; 4]>

source§#### fn simd_horizontal_sum(
self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdValue>::Element

#### fn simd_horizontal_sum( self ) -> <Complex<AutoSimd<[f32; 4]>> as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(
self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdValue>::Element

#### fn simd_horizontal_product( self ) -> <Complex<AutoSimd<[f32; 4]>> as SimdValue>::Element

`self`

.source§#### fn from_simd_real(
re: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 4]>>

#### fn from_simd_real( re: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 4]>>

source§#### fn simd_real(
self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_real( self ) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(
self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_imaginary( self ) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

source§#### fn simd_argument(
self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_argument( self ) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(
self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus( self ) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(
self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared( self ) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(
self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_norm1( self ) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_conjugate(self) -> Complex<AutoSimd<[f32; 4]>>

source§#### fn simd_scale(
self,
factor: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_scale( self, factor: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 4]>>

`factor`

.source§#### fn simd_unscale(
self,
factor: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_unscale( self, factor: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 4]>>

`factor`

.#### fn simd_floor(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_ceil(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_round(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_trunc(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_fract(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_mul_add( self, a: Complex<AutoSimd<[f32; 4]>>, b: Complex<AutoSimd<[f32; 4]>> ) -> Complex<AutoSimd<[f32; 4]>>

source§#### fn simd_abs(
self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_abs( self ) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read more#### fn simd_exp2(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_exp_m1(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_ln_1p(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_log2(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_log10(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_cbrt(self) -> Complex<AutoSimd<[f32; 4]>>

#### fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f32; 4]>>

source§#### fn simd_hypot(
self,
b: Complex<AutoSimd<[f32; 4]>>
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_hypot( self, b: Complex<AutoSimd<[f32; 4]>> ) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_sin_cos( self ) -> (Complex<AutoSimd<[f32; 4]>>, Complex<AutoSimd<[f32; 4]>>)

#### fn simd_sinh_cosh( self ) -> (Complex<AutoSimd<[f32; 4]>>, Complex<AutoSimd<[f32; 4]>>)

source§#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

source§#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

source§#### fn simd_signum(self) -> Self

#### fn simd_signum(self) -> Self

`self / self.modulus()`

#### fn simd_sinhc(self) -> Self

#### fn simd_coshc(self) -> Self

source§### impl SimdComplexField for Complex<AutoSimd<[f32; 8]>>

### impl SimdComplexField for Complex<AutoSimd<[f32; 8]>>

source§#### fn simd_exp(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_exp(self) -> Complex<AutoSimd<[f32; 8]>>

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

source§#### fn simd_ln(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_ln(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn simd_powf(
self,
exp: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_powf( self, exp: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 8]>>

Raises `self`

to a floating point power.

source§#### fn simd_log(self, base: AutoSimd<[f32; 8]>) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_log(self, base: AutoSimd<[f32; 8]>) -> Complex<AutoSimd<[f32; 8]>>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn simd_powc(
self,
exp: Complex<AutoSimd<[f32; 8]>>
) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_powc( self, exp: Complex<AutoSimd<[f32; 8]>> ) -> Complex<AutoSimd<[f32; 8]>>

Raises `self`

to a complex power.

source§#### fn simd_asin(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_asin(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn simd_acos(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_acos(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn simd_atan(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_atan(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn simd_asinh(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_asinh(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn simd_acosh(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_acosh(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn simd_atanh(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_atanh(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

§#### type SimdRealField = AutoSimd<[f32; 8]>

#### type SimdRealField = AutoSimd<[f32; 8]>

source§#### fn simd_horizontal_sum(
self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdValue>::Element

#### fn simd_horizontal_sum( self ) -> <Complex<AutoSimd<[f32; 8]>> as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(
self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdValue>::Element

#### fn simd_horizontal_product( self ) -> <Complex<AutoSimd<[f32; 8]>> as SimdValue>::Element

`self`

.source§#### fn from_simd_real(
re: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 8]>>

#### fn from_simd_real( re: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 8]>>

source§#### fn simd_real(
self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_real( self ) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(
self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_imaginary( self ) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

source§#### fn simd_argument(
self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_argument( self ) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(
self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus( self ) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(
self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared( self ) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(
self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_norm1( self ) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_conjugate(self) -> Complex<AutoSimd<[f32; 8]>>

source§#### fn simd_scale(
self,
factor: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_scale( self, factor: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 8]>>

`factor`

.source§#### fn simd_unscale(
self,
factor: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_unscale( self, factor: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f32; 8]>>

`factor`

.#### fn simd_floor(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_ceil(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_round(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_trunc(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_fract(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_mul_add( self, a: Complex<AutoSimd<[f32; 8]>>, b: Complex<AutoSimd<[f32; 8]>> ) -> Complex<AutoSimd<[f32; 8]>>

source§#### fn simd_abs(
self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_abs( self ) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read more#### fn simd_exp2(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_exp_m1(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_ln_1p(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_log2(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_log10(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_cbrt(self) -> Complex<AutoSimd<[f32; 8]>>

#### fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f32; 8]>>

source§#### fn simd_hypot(
self,
b: Complex<AutoSimd<[f32; 8]>>
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_hypot( self, b: Complex<AutoSimd<[f32; 8]>> ) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_sin_cos( self ) -> (Complex<AutoSimd<[f32; 8]>>, Complex<AutoSimd<[f32; 8]>>)

#### fn simd_sinh_cosh( self ) -> (Complex<AutoSimd<[f32; 8]>>, Complex<AutoSimd<[f32; 8]>>)

source§#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

source§#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

source§#### fn simd_signum(self) -> Self

#### fn simd_signum(self) -> Self

`self / self.modulus()`

#### fn simd_sinhc(self) -> Self

#### fn simd_coshc(self) -> Self

source§### impl SimdComplexField for Complex<AutoSimd<[f64; 2]>>

### impl SimdComplexField for Complex<AutoSimd<[f64; 2]>>

source§#### fn simd_exp(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_exp(self) -> Complex<AutoSimd<[f64; 2]>>

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

source§#### fn simd_ln(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_ln(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn simd_sqrt(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_sqrt(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn simd_powf(
self,
exp: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_powf( self, exp: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 2]>>

Raises `self`

to a floating point power.

source§#### fn simd_log(self, base: AutoSimd<[f64; 2]>) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_log(self, base: AutoSimd<[f64; 2]>) -> Complex<AutoSimd<[f64; 2]>>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn simd_powc(
self,
exp: Complex<AutoSimd<[f64; 2]>>
) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_powc( self, exp: Complex<AutoSimd<[f64; 2]>> ) -> Complex<AutoSimd<[f64; 2]>>

Raises `self`

to a complex power.

source§#### fn simd_asin(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_asin(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn simd_acos(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_acos(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn simd_atan(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_atan(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn simd_asinh(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_asinh(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn simd_acosh(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_acosh(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn simd_atanh(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_atanh(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

§#### type SimdRealField = AutoSimd<[f64; 2]>

#### type SimdRealField = AutoSimd<[f64; 2]>

source§#### fn simd_horizontal_sum(
self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdValue>::Element

#### fn simd_horizontal_sum( self ) -> <Complex<AutoSimd<[f64; 2]>> as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(
self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdValue>::Element

#### fn simd_horizontal_product( self ) -> <Complex<AutoSimd<[f64; 2]>> as SimdValue>::Element

`self`

.source§#### fn from_simd_real(
re: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 2]>>

#### fn from_simd_real( re: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 2]>>

source§#### fn simd_real(
self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_real( self ) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(
self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_imaginary( self ) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

source§#### fn simd_argument(
self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_argument( self ) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(
self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus( self ) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(
self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared( self ) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(
self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_norm1( self ) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_conjugate(self) -> Complex<AutoSimd<[f64; 2]>>

source§#### fn simd_scale(
self,
factor: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_scale( self, factor: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 2]>>

`factor`

.source§#### fn simd_unscale(
self,
factor: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_unscale( self, factor: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 2]>>

`factor`

.#### fn simd_floor(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_ceil(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_round(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_trunc(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_fract(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_mul_add( self, a: Complex<AutoSimd<[f64; 2]>>, b: Complex<AutoSimd<[f64; 2]>> ) -> Complex<AutoSimd<[f64; 2]>>

source§#### fn simd_abs(
self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_abs( self ) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read more#### fn simd_exp2(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_exp_m1(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_ln_1p(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_log2(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_log10(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_cbrt(self) -> Complex<AutoSimd<[f64; 2]>>

#### fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f64; 2]>>

source§#### fn simd_hypot(
self,
b: Complex<AutoSimd<[f64; 2]>>
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_hypot( self, b: Complex<AutoSimd<[f64; 2]>> ) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

#### fn simd_sin_cos( self ) -> (Complex<AutoSimd<[f64; 2]>>, Complex<AutoSimd<[f64; 2]>>)

#### fn simd_sinh_cosh( self ) -> (Complex<AutoSimd<[f64; 2]>>, Complex<AutoSimd<[f64; 2]>>)

source§#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

source§#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

source§#### fn simd_signum(self) -> Self

#### fn simd_signum(self) -> Self

`self / self.modulus()`

#### fn simd_sinhc(self) -> Self

#### fn simd_coshc(self) -> Self

source§### impl SimdComplexField for Complex<AutoSimd<[f64; 4]>>

### impl SimdComplexField for Complex<AutoSimd<[f64; 4]>>

source§#### fn simd_exp(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_exp(self) -> Complex<AutoSimd<[f64; 4]>>

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

source§#### fn simd_ln(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_ln(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn simd_sqrt(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_sqrt(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn simd_powf(
self,
exp: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_powf( self, exp: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 4]>>

Raises `self`

to a floating point power.

source§#### fn simd_log(self, base: AutoSimd<[f64; 4]>) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_log(self, base: AutoSimd<[f64; 4]>) -> Complex<AutoSimd<[f64; 4]>>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn simd_powc(
self,
exp: Complex<AutoSimd<[f64; 4]>>
) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_powc( self, exp: Complex<AutoSimd<[f64; 4]>> ) -> Complex<AutoSimd<[f64; 4]>>

Raises `self`

to a complex power.

source§#### fn simd_asin(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_asin(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn simd_acos(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_acos(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn simd_atan(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_atan(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn simd_asinh(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_asinh(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn simd_acosh(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_acosh(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn simd_atanh(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_atanh(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

§#### type SimdRealField = AutoSimd<[f64; 4]>

#### type SimdRealField = AutoSimd<[f64; 4]>

source§#### fn simd_horizontal_sum(
self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdValue>::Element

#### fn simd_horizontal_sum( self ) -> <Complex<AutoSimd<[f64; 4]>> as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(
self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdValue>::Element

#### fn simd_horizontal_product( self ) -> <Complex<AutoSimd<[f64; 4]>> as SimdValue>::Element

`self`

.source§#### fn from_simd_real(
re: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 4]>>

#### fn from_simd_real( re: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 4]>>

source§#### fn simd_real(
self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_real( self ) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(
self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_imaginary( self ) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

source§#### fn simd_argument(
self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_argument( self ) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(
self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus( self ) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(
self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared( self ) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(
self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_norm1( self ) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_conjugate(self) -> Complex<AutoSimd<[f64; 4]>>

source§#### fn simd_scale(
self,
factor: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_scale( self, factor: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 4]>>

`factor`

.source§#### fn simd_unscale(
self,
factor: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_unscale( self, factor: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 4]>>

`factor`

.#### fn simd_floor(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_ceil(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_round(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_trunc(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_fract(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_mul_add( self, a: Complex<AutoSimd<[f64; 4]>>, b: Complex<AutoSimd<[f64; 4]>> ) -> Complex<AutoSimd<[f64; 4]>>

source§#### fn simd_abs(
self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_abs( self ) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read more#### fn simd_exp2(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_exp_m1(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_ln_1p(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_log2(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_log10(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_cbrt(self) -> Complex<AutoSimd<[f64; 4]>>

#### fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f64; 4]>>

source§#### fn simd_hypot(
self,
b: Complex<AutoSimd<[f64; 4]>>
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_hypot( self, b: Complex<AutoSimd<[f64; 4]>> ) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

#### fn simd_sin_cos( self ) -> (Complex<AutoSimd<[f64; 4]>>, Complex<AutoSimd<[f64; 4]>>)

#### fn simd_sinh_cosh( self ) -> (Complex<AutoSimd<[f64; 4]>>, Complex<AutoSimd<[f64; 4]>>)

source§#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

source§#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

source§#### fn simd_signum(self) -> Self

#### fn simd_signum(self) -> Self

`self / self.modulus()`

#### fn simd_sinhc(self) -> Self

#### fn simd_coshc(self) -> Self

source§### impl SimdComplexField for Complex<AutoSimd<[f64; 8]>>

### impl SimdComplexField for Complex<AutoSimd<[f64; 8]>>

source§#### fn simd_exp(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_exp(self) -> Complex<AutoSimd<[f64; 8]>>

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

source§#### fn simd_ln(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_ln(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn simd_sqrt(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_sqrt(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn simd_powf(
self,
exp: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_powf( self, exp: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 8]>>

Raises `self`

to a floating point power.

source§#### fn simd_log(self, base: AutoSimd<[f64; 8]>) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_log(self, base: AutoSimd<[f64; 8]>) -> Complex<AutoSimd<[f64; 8]>>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn simd_powc(
self,
exp: Complex<AutoSimd<[f64; 8]>>
) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_powc( self, exp: Complex<AutoSimd<[f64; 8]>> ) -> Complex<AutoSimd<[f64; 8]>>

Raises `self`

to a complex power.

source§#### fn simd_asin(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_asin(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn simd_acos(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_acos(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn simd_atan(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_atan(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn simd_asinh(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_asinh(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn simd_acosh(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_acosh(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn simd_atanh(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_atanh(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

§#### type SimdRealField = AutoSimd<[f64; 8]>

#### type SimdRealField = AutoSimd<[f64; 8]>

source§#### fn simd_horizontal_sum(
self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdValue>::Element

#### fn simd_horizontal_sum( self ) -> <Complex<AutoSimd<[f64; 8]>> as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(
self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdValue>::Element

#### fn simd_horizontal_product( self ) -> <Complex<AutoSimd<[f64; 8]>> as SimdValue>::Element

`self`

.source§#### fn from_simd_real(
re: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 8]>>

#### fn from_simd_real( re: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 8]>>

source§#### fn simd_real(
self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_real( self ) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(
self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_imaginary( self ) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

source§#### fn simd_argument(
self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_argument( self ) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(
self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus( self ) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(
self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared( self ) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(
self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_norm1( self ) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_conjugate(self) -> Complex<AutoSimd<[f64; 8]>>

source§#### fn simd_scale(
self,
factor: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_scale( self, factor: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 8]>>

`factor`

.source§#### fn simd_unscale(
self,
factor: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_unscale( self, factor: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField ) -> Complex<AutoSimd<[f64; 8]>>

`factor`

.#### fn simd_floor(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_ceil(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_round(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_trunc(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_fract(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_mul_add( self, a: Complex<AutoSimd<[f64; 8]>>, b: Complex<AutoSimd<[f64; 8]>> ) -> Complex<AutoSimd<[f64; 8]>>

source§#### fn simd_abs(
self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_abs( self ) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read more#### fn simd_exp2(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_exp_m1(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_ln_1p(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_log2(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_log10(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_cbrt(self) -> Complex<AutoSimd<[f64; 8]>>

#### fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f64; 8]>>

source§#### fn simd_hypot(
self,
b: Complex<AutoSimd<[f64; 8]>>
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_hypot( self, b: Complex<AutoSimd<[f64; 8]>> ) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

#### fn simd_sin_cos( self ) -> (Complex<AutoSimd<[f64; 8]>>, Complex<AutoSimd<[f64; 8]>>)

#### fn simd_sinh_cosh( self ) -> (Complex<AutoSimd<[f64; 8]>>, Complex<AutoSimd<[f64; 8]>>)

source§#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

source§#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

source§#### fn simd_signum(self) -> Self

#### fn simd_signum(self) -> Self

`self / self.modulus()`

#### fn simd_sinhc(self) -> Self

#### fn simd_coshc(self) -> Self

source§### impl SimdComplexField for Complex<WideF32x4>

### impl SimdComplexField for Complex<WideF32x4>

source§#### fn simd_exp(self) -> Complex<WideF32x4>

#### fn simd_exp(self) -> Complex<WideF32x4>

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

source§#### fn simd_ln(self) -> Complex<WideF32x4>

#### fn simd_ln(self) -> Complex<WideF32x4>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn simd_sqrt(self) -> Complex<WideF32x4>

#### fn simd_sqrt(self) -> Complex<WideF32x4>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn simd_powf(
self,
exp: <Complex<WideF32x4> as SimdComplexField>::SimdRealField
) -> Complex<WideF32x4>

#### fn simd_powf( self, exp: <Complex<WideF32x4> as SimdComplexField>::SimdRealField ) -> Complex<WideF32x4>

Raises `self`

to a floating point power.

source§#### fn simd_log(self, base: WideF32x4) -> Complex<WideF32x4>

#### fn simd_log(self, base: WideF32x4) -> Complex<WideF32x4>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn simd_powc(self, exp: Complex<WideF32x4>) -> Complex<WideF32x4>

#### fn simd_powc(self, exp: Complex<WideF32x4>) -> Complex<WideF32x4>

Raises `self`

to a complex power.

source§#### fn simd_asin(self) -> Complex<WideF32x4>

#### fn simd_asin(self) -> Complex<WideF32x4>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn simd_acos(self) -> Complex<WideF32x4>

#### fn simd_acos(self) -> Complex<WideF32x4>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn simd_atan(self) -> Complex<WideF32x4>

#### fn simd_atan(self) -> Complex<WideF32x4>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn simd_asinh(self) -> Complex<WideF32x4>

#### fn simd_asinh(self) -> Complex<WideF32x4>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn simd_acosh(self) -> Complex<WideF32x4>

#### fn simd_acosh(self) -> Complex<WideF32x4>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn simd_atanh(self) -> Complex<WideF32x4>

#### fn simd_atanh(self) -> Complex<WideF32x4>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

§#### type SimdRealField = WideF32x4

#### type SimdRealField = WideF32x4

source§#### fn simd_horizontal_sum(self) -> <Complex<WideF32x4> as SimdValue>::Element

#### fn simd_horizontal_sum(self) -> <Complex<WideF32x4> as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(self) -> <Complex<WideF32x4> as SimdValue>::Element

#### fn simd_horizontal_product(self) -> <Complex<WideF32x4> as SimdValue>::Element

`self`

.source§#### fn from_simd_real(
re: <Complex<WideF32x4> as SimdComplexField>::SimdRealField
) -> Complex<WideF32x4>

#### fn from_simd_real( re: <Complex<WideF32x4> as SimdComplexField>::SimdRealField ) -> Complex<WideF32x4>

source§#### fn simd_real(self) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

#### fn simd_real(self) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(
self
) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

#### fn simd_imaginary( self ) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

source§#### fn simd_argument(
self
) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

#### fn simd_argument( self ) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(self) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

#### fn simd_modulus(self) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(
self
) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared( self ) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(self) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

#### fn simd_norm1(self) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> Complex<WideF32x4>

#### fn simd_conjugate(self) -> Complex<WideF32x4>

source§#### fn simd_scale(
self,
factor: <Complex<WideF32x4> as SimdComplexField>::SimdRealField
) -> Complex<WideF32x4>

#### fn simd_scale( self, factor: <Complex<WideF32x4> as SimdComplexField>::SimdRealField ) -> Complex<WideF32x4>

`factor`

.source§#### fn simd_unscale(
self,
factor: <Complex<WideF32x4> as SimdComplexField>::SimdRealField
) -> Complex<WideF32x4>

#### fn simd_unscale( self, factor: <Complex<WideF32x4> as SimdComplexField>::SimdRealField ) -> Complex<WideF32x4>

`factor`

.#### fn simd_floor(self) -> Complex<WideF32x4>

#### fn simd_ceil(self) -> Complex<WideF32x4>

#### fn simd_round(self) -> Complex<WideF32x4>

#### fn simd_trunc(self) -> Complex<WideF32x4>

#### fn simd_fract(self) -> Complex<WideF32x4>

#### fn simd_mul_add( self, a: Complex<WideF32x4>, b: Complex<WideF32x4> ) -> Complex<WideF32x4>

source§#### fn simd_abs(self) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

#### fn simd_abs(self) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read more#### fn simd_exp2(self) -> Complex<WideF32x4>

#### fn simd_exp_m1(self) -> Complex<WideF32x4>

#### fn simd_ln_1p(self) -> Complex<WideF32x4>

#### fn simd_log2(self) -> Complex<WideF32x4>

#### fn simd_log10(self) -> Complex<WideF32x4>

#### fn simd_cbrt(self) -> Complex<WideF32x4>

#### fn simd_powi(self, n: i32) -> Complex<WideF32x4>

source§#### fn simd_hypot(
self,
b: Complex<WideF32x4>
) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

#### fn simd_hypot( self, b: Complex<WideF32x4> ) -> <Complex<WideF32x4> as SimdComplexField>::SimdRealField

#### fn simd_sin_cos(self) -> (Complex<WideF32x4>, Complex<WideF32x4>)

#### fn simd_sinh_cosh(self) -> (Complex<WideF32x4>, Complex<WideF32x4>)

source§#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

source§#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

source§#### fn simd_signum(self) -> Self

#### fn simd_signum(self) -> Self

`self / self.modulus()`

#### fn simd_sinhc(self) -> Self

#### fn simd_coshc(self) -> Self

source§### impl SimdComplexField for Complex<WideF32x8>

### impl SimdComplexField for Complex<WideF32x8>

source§#### fn simd_exp(self) -> Complex<WideF32x8>

#### fn simd_exp(self) -> Complex<WideF32x8>

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

source§#### fn simd_ln(self) -> Complex<WideF32x8>

#### fn simd_ln(self) -> Complex<WideF32x8>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn simd_sqrt(self) -> Complex<WideF32x8>

#### fn simd_sqrt(self) -> Complex<WideF32x8>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn simd_powf(
self,
exp: <Complex<WideF32x8> as SimdComplexField>::SimdRealField
) -> Complex<WideF32x8>

#### fn simd_powf( self, exp: <Complex<WideF32x8> as SimdComplexField>::SimdRealField ) -> Complex<WideF32x8>

Raises `self`

to a floating point power.

source§#### fn simd_log(self, base: WideF32x8) -> Complex<WideF32x8>

#### fn simd_log(self, base: WideF32x8) -> Complex<WideF32x8>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn simd_powc(self, exp: Complex<WideF32x8>) -> Complex<WideF32x8>

#### fn simd_powc(self, exp: Complex<WideF32x8>) -> Complex<WideF32x8>

Raises `self`

to a complex power.

source§#### fn simd_asin(self) -> Complex<WideF32x8>

#### fn simd_asin(self) -> Complex<WideF32x8>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn simd_acos(self) -> Complex<WideF32x8>

#### fn simd_acos(self) -> Complex<WideF32x8>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn simd_atan(self) -> Complex<WideF32x8>

#### fn simd_atan(self) -> Complex<WideF32x8>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn simd_asinh(self) -> Complex<WideF32x8>

#### fn simd_asinh(self) -> Complex<WideF32x8>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn simd_acosh(self) -> Complex<WideF32x8>

#### fn simd_acosh(self) -> Complex<WideF32x8>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn simd_atanh(self) -> Complex<WideF32x8>

#### fn simd_atanh(self) -> Complex<WideF32x8>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

§#### type SimdRealField = WideF32x8

#### type SimdRealField = WideF32x8

source§#### fn simd_horizontal_sum(self) -> <Complex<WideF32x8> as SimdValue>::Element

#### fn simd_horizontal_sum(self) -> <Complex<WideF32x8> as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(self) -> <Complex<WideF32x8> as SimdValue>::Element

#### fn simd_horizontal_product(self) -> <Complex<WideF32x8> as SimdValue>::Element

`self`

.source§#### fn from_simd_real(
re: <Complex<WideF32x8> as SimdComplexField>::SimdRealField
) -> Complex<WideF32x8>

#### fn from_simd_real( re: <Complex<WideF32x8> as SimdComplexField>::SimdRealField ) -> Complex<WideF32x8>

source§#### fn simd_real(self) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

#### fn simd_real(self) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(
self
) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

#### fn simd_imaginary( self ) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

source§#### fn simd_argument(
self
) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

#### fn simd_argument( self ) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(self) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

#### fn simd_modulus(self) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(
self
) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared( self ) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(self) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

#### fn simd_norm1(self) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> Complex<WideF32x8>

#### fn simd_conjugate(self) -> Complex<WideF32x8>

source§#### fn simd_scale(
self,
factor: <Complex<WideF32x8> as SimdComplexField>::SimdRealField
) -> Complex<WideF32x8>

#### fn simd_scale( self, factor: <Complex<WideF32x8> as SimdComplexField>::SimdRealField ) -> Complex<WideF32x8>

`factor`

.source§#### fn simd_unscale(
self,
factor: <Complex<WideF32x8> as SimdComplexField>::SimdRealField
) -> Complex<WideF32x8>

#### fn simd_unscale( self, factor: <Complex<WideF32x8> as SimdComplexField>::SimdRealField ) -> Complex<WideF32x8>

`factor`

.#### fn simd_floor(self) -> Complex<WideF32x8>

#### fn simd_ceil(self) -> Complex<WideF32x8>

#### fn simd_round(self) -> Complex<WideF32x8>

#### fn simd_trunc(self) -> Complex<WideF32x8>

#### fn simd_fract(self) -> Complex<WideF32x8>

#### fn simd_mul_add( self, a: Complex<WideF32x8>, b: Complex<WideF32x8> ) -> Complex<WideF32x8>

source§#### fn simd_abs(self) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

#### fn simd_abs(self) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read more#### fn simd_exp2(self) -> Complex<WideF32x8>

#### fn simd_exp_m1(self) -> Complex<WideF32x8>

#### fn simd_ln_1p(self) -> Complex<WideF32x8>

#### fn simd_log2(self) -> Complex<WideF32x8>

#### fn simd_log10(self) -> Complex<WideF32x8>

#### fn simd_cbrt(self) -> Complex<WideF32x8>

#### fn simd_powi(self, n: i32) -> Complex<WideF32x8>

source§#### fn simd_hypot(
self,
b: Complex<WideF32x8>
) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

#### fn simd_hypot( self, b: Complex<WideF32x8> ) -> <Complex<WideF32x8> as SimdComplexField>::SimdRealField

#### fn simd_sin_cos(self) -> (Complex<WideF32x8>, Complex<WideF32x8>)

#### fn simd_sinh_cosh(self) -> (Complex<WideF32x8>, Complex<WideF32x8>)

source§#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

source§#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

source§#### fn simd_signum(self) -> Self

#### fn simd_signum(self) -> Self

`self / self.modulus()`

#### fn simd_sinhc(self) -> Self

#### fn simd_coshc(self) -> Self

source§### impl SimdComplexField for Complex<WideF64x4>

### impl SimdComplexField for Complex<WideF64x4>

source§#### fn simd_exp(self) -> Complex<WideF64x4>

#### fn simd_exp(self) -> Complex<WideF64x4>

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

source§#### fn simd_ln(self) -> Complex<WideF64x4>

#### fn simd_ln(self) -> Complex<WideF64x4>

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

source§#### fn simd_sqrt(self) -> Complex<WideF64x4>

#### fn simd_sqrt(self) -> Complex<WideF64x4>

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

source§#### fn simd_powf(
self,
exp: <Complex<WideF64x4> as SimdComplexField>::SimdRealField
) -> Complex<WideF64x4>

#### fn simd_powf( self, exp: <Complex<WideF64x4> as SimdComplexField>::SimdRealField ) -> Complex<WideF64x4>

Raises `self`

to a floating point power.

source§#### fn simd_log(self, base: WideF64x4) -> Complex<WideF64x4>

#### fn simd_log(self, base: WideF64x4) -> Complex<WideF64x4>

Returns the logarithm of `self`

with respect to an arbitrary base.

source§#### fn simd_powc(self, exp: Complex<WideF64x4>) -> Complex<WideF64x4>

#### fn simd_powc(self, exp: Complex<WideF64x4>) -> Complex<WideF64x4>

Raises `self`

to a complex power.

source§#### fn simd_asin(self) -> Complex<WideF64x4>

#### fn simd_asin(self) -> Complex<WideF64x4>

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

source§#### fn simd_acos(self) -> Complex<WideF64x4>

#### fn simd_acos(self) -> Complex<WideF64x4>

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

source§#### fn simd_atan(self) -> Complex<WideF64x4>

#### fn simd_atan(self) -> Complex<WideF64x4>

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

source§#### fn simd_asinh(self) -> Complex<WideF64x4>

#### fn simd_asinh(self) -> Complex<WideF64x4>

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

source§#### fn simd_acosh(self) -> Complex<WideF64x4>

#### fn simd_acosh(self) -> Complex<WideF64x4>

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

source§#### fn simd_atanh(self) -> Complex<WideF64x4>

#### fn simd_atanh(self) -> Complex<WideF64x4>

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

§#### type SimdRealField = WideF64x4

#### type SimdRealField = WideF64x4

source§#### fn simd_horizontal_sum(self) -> <Complex<WideF64x4> as SimdValue>::Element

#### fn simd_horizontal_sum(self) -> <Complex<WideF64x4> as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(self) -> <Complex<WideF64x4> as SimdValue>::Element

#### fn simd_horizontal_product(self) -> <Complex<WideF64x4> as SimdValue>::Element

`self`

.source§#### fn from_simd_real(
re: <Complex<WideF64x4> as SimdComplexField>::SimdRealField
) -> Complex<WideF64x4>

#### fn from_simd_real( re: <Complex<WideF64x4> as SimdComplexField>::SimdRealField ) -> Complex<WideF64x4>

source§#### fn simd_real(self) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

#### fn simd_real(self) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(
self
) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

#### fn simd_imaginary( self ) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

source§#### fn simd_argument(
self
) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

#### fn simd_argument( self ) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(self) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

#### fn simd_modulus(self) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(
self
) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared( self ) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(self) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

#### fn simd_norm1(self) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> Complex<WideF64x4>

#### fn simd_conjugate(self) -> Complex<WideF64x4>

source§#### fn simd_scale(
self,
factor: <Complex<WideF64x4> as SimdComplexField>::SimdRealField
) -> Complex<WideF64x4>

#### fn simd_scale( self, factor: <Complex<WideF64x4> as SimdComplexField>::SimdRealField ) -> Complex<WideF64x4>

`factor`

.source§#### fn simd_unscale(
self,
factor: <Complex<WideF64x4> as SimdComplexField>::SimdRealField
) -> Complex<WideF64x4>

#### fn simd_unscale( self, factor: <Complex<WideF64x4> as SimdComplexField>::SimdRealField ) -> Complex<WideF64x4>

`factor`

.#### fn simd_floor(self) -> Complex<WideF64x4>

#### fn simd_ceil(self) -> Complex<WideF64x4>

#### fn simd_round(self) -> Complex<WideF64x4>

#### fn simd_trunc(self) -> Complex<WideF64x4>

#### fn simd_fract(self) -> Complex<WideF64x4>

#### fn simd_mul_add( self, a: Complex<WideF64x4>, b: Complex<WideF64x4> ) -> Complex<WideF64x4>

source§#### fn simd_abs(self) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

#### fn simd_abs(self) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read more#### fn simd_exp2(self) -> Complex<WideF64x4>

#### fn simd_exp_m1(self) -> Complex<WideF64x4>

#### fn simd_ln_1p(self) -> Complex<WideF64x4>

#### fn simd_log2(self) -> Complex<WideF64x4>

#### fn simd_log10(self) -> Complex<WideF64x4>

#### fn simd_cbrt(self) -> Complex<WideF64x4>

#### fn simd_powi(self, n: i32) -> Complex<WideF64x4>

source§#### fn simd_hypot(
self,
b: Complex<WideF64x4>
) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

#### fn simd_hypot( self, b: Complex<WideF64x4> ) -> <Complex<WideF64x4> as SimdComplexField>::SimdRealField

#### fn simd_sin_cos(self) -> (Complex<WideF64x4>, Complex<WideF64x4>)

#### fn simd_sinh_cosh(self) -> (Complex<WideF64x4>, Complex<WideF64x4>)

source§#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

#### fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

source§#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

#### fn simd_to_exp(self) -> (Self::SimdRealField, Self)

source§#### fn simd_signum(self) -> Self

#### fn simd_signum(self) -> Self

`self / self.modulus()`

#### fn simd_sinhc(self) -> Self

#### fn simd_coshc(self) -> Self

source§### impl<N> SimdValue for Complex<N>where
N: SimdValue,

### impl<N> SimdValue for Complex<N>where
N: SimdValue,

§#### type Element = Complex<<N as SimdValue>::Element>

#### type Element = Complex<<N as SimdValue>::Element>

§#### type SimdBool = <N as SimdValue>::SimdBool

#### type SimdBool = <N as SimdValue>::SimdBool

`self`

.source§#### fn splat(val: <Complex<N> as SimdValue>::Element) -> Complex<N>

#### fn splat(val: <Complex<N> as SimdValue>::Element) -> Complex<N>

`val`

.source§#### fn extract(&self, i: usize) -> <Complex<N> as SimdValue>::Element

#### fn extract(&self, i: usize) -> <Complex<N> as SimdValue>::Element

`self`

. Read moresource§#### unsafe fn extract_unchecked(
&self,
i: usize
) -> <Complex<N> as SimdValue>::Element

#### unsafe fn extract_unchecked( &self, i: usize ) -> <Complex<N> as SimdValue>::Element

`self`

without bound-checking.source§### impl<'a, T> SubAssign<&'a Complex<T>> for Complex<T>

### impl<'a, T> SubAssign<&'a Complex<T>> for Complex<T>

source§#### fn sub_assign(&mut self, other: &Complex<T>)

#### fn sub_assign(&mut self, other: &Complex<T>)

`-=`

operation. Read moresource§### impl<'a, T> SubAssign<&'a T> for Complex<T>

### impl<'a, T> SubAssign<&'a T> for Complex<T>

source§#### fn sub_assign(&mut self, other: &T)

#### fn sub_assign(&mut self, other: &T)

`-=`

operation. Read moresource§### impl<T> SubAssign<T> for Complex<T>

### impl<T> SubAssign<T> for Complex<T>

source§#### fn sub_assign(&mut self, other: T)

#### fn sub_assign(&mut self, other: T)

`-=`

operation. Read moresource§### impl<T> SubAssign for Complex<T>

### impl<T> SubAssign for Complex<T>

source§#### fn sub_assign(&mut self, other: Complex<T>)

#### fn sub_assign(&mut self, other: Complex<T>)

`-=`

operation. Read moresource§### impl<N1, N2> SubsetOf<Complex<N2>> for Complex<N1>where
N2: SupersetOf<N1>,

### impl<N1, N2> SubsetOf<Complex<N2>> for Complex<N1>where
N2: SupersetOf<N1>,

source§#### fn to_superset(&self) -> Complex<N2>

#### fn to_superset(&self) -> Complex<N2>

`self`

to the equivalent element of its superset.source§#### fn from_superset_unchecked(element: &Complex<N2>) -> Complex<N1>

#### fn from_superset_unchecked(element: &Complex<N2>) -> Complex<N1>

`self.to_superset`

but without any property checks. Always succeeds.source§#### fn is_in_subset(c: &Complex<N2>) -> bool

#### fn is_in_subset(c: &Complex<N2>) -> bool

`element`

is actually part of the subset `Self`

(and can be converted to it).source§### impl<T> ToPrimitive for Complex<T>where
T: ToPrimitive + Num,

### impl<T> ToPrimitive for Complex<T>where
T: ToPrimitive + Num,

source§#### fn to_usize(&self) -> Option<usize>

#### fn to_usize(&self) -> Option<usize>

`self`

to a `usize`

. If the value cannot be
represented by a `usize`

, then `None`

is returned.source§#### fn to_isize(&self) -> Option<isize>

#### fn to_isize(&self) -> Option<isize>

`self`

to an `isize`

. If the value cannot be
represented by an `isize`

, then `None`

is returned.source§#### fn to_u8(&self) -> Option<u8>

#### fn to_u8(&self) -> Option<u8>

`self`

to a `u8`

. If the value cannot be
represented by a `u8`

, then `None`

is returned.source§#### fn to_u16(&self) -> Option<u16>

#### fn to_u16(&self) -> Option<u16>

`self`

to a `u16`

. If the value cannot be
represented by a `u16`

, then `None`

is returned.source§#### fn to_u32(&self) -> Option<u32>

#### fn to_u32(&self) -> Option<u32>

`self`

to a `u32`

. If the value cannot be
represented by a `u32`

, then `None`

is returned.source§#### fn to_u64(&self) -> Option<u64>

#### fn to_u64(&self) -> Option<u64>

`self`

to a `u64`

. If the value cannot be
represented by a `u64`

, then `None`

is returned.source§#### fn to_i8(&self) -> Option<i8>

#### fn to_i8(&self) -> Option<i8>

`self`

to an `i8`

. If the value cannot be
represented by an `i8`

, then `None`

is returned.source§#### fn to_i16(&self) -> Option<i16>

#### fn to_i16(&self) -> Option<i16>

`self`

to an `i16`

. If the value cannot be
represented by an `i16`

, then `None`

is returned.source§#### fn to_i32(&self) -> Option<i32>

#### fn to_i32(&self) -> Option<i32>

`self`

to an `i32`

. If the value cannot be
represented by an `i32`

, then `None`

is returned.source§#### fn to_i64(&self) -> Option<i64>

#### fn to_i64(&self) -> Option<i64>

`self`

to an `i64`

. If the value cannot be
represented by an `i64`

, then `None`

is returned.source§#### fn to_u128(&self) -> Option<u128>

#### fn to_u128(&self) -> Option<u128>

`self`

to a `u128`

. If the value cannot be
represented by a `u128`

(`u64`

under the default implementation), then
`None`

is returned. Read moresource§#### fn to_i128(&self) -> Option<i128>

#### fn to_i128(&self) -> Option<i128>

`self`

to an `i128`

. If the value cannot be
represented by an `i128`

(`i64`

under the default implementation), then
`None`

is returned. Read more### impl<T> Copy for Complex<T>where
T: Copy,

### impl<T> Eq for Complex<T>where
T: Eq,

### impl<N> Field for Complex<N>

### impl<N> PrimitiveSimdValue for Complex<N>where
N: PrimitiveSimdValue,

### impl<T> StructuralEq for Complex<T>

### impl<T> StructuralPartialEq for Complex<T>

## Auto Trait Implementations§

### impl<T> RefUnwindSafe for Complex<T>where
T: RefUnwindSafe,

### impl<T> Send for Complex<T>where
T: Send,

### impl<T> Sync for Complex<T>where
T: Sync,

### impl<T> Unpin for Complex<T>where
T: Unpin,

### impl<T> UnwindSafe for Complex<T>where
T: UnwindSafe,

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

source§### impl<T> SimdComplexField for Twhere
T: ComplexField,

### impl<T> SimdComplexField for Twhere
T: ComplexField,

§#### type SimdRealField = <T as ComplexField>::RealField

#### type SimdRealField = <T as ComplexField>::RealField

source§#### fn from_simd_real(re: <T as SimdComplexField>::SimdRealField) -> T

#### fn from_simd_real(re: <T as SimdComplexField>::SimdRealField) -> T

source§#### fn simd_real(self) -> <T as SimdComplexField>::SimdRealField

#### fn simd_real(self) -> <T as SimdComplexField>::SimdRealField

source§#### fn simd_imaginary(self) -> <T as SimdComplexField>::SimdRealField

#### fn simd_imaginary(self) -> <T as SimdComplexField>::SimdRealField

source§#### fn simd_modulus(self) -> <T as SimdComplexField>::SimdRealField

#### fn simd_modulus(self) -> <T as SimdComplexField>::SimdRealField

source§#### fn simd_modulus_squared(self) -> <T as SimdComplexField>::SimdRealField

#### fn simd_modulus_squared(self) -> <T as SimdComplexField>::SimdRealField

source§#### fn simd_argument(self) -> <T as SimdComplexField>::SimdRealField

#### fn simd_argument(self) -> <T as SimdComplexField>::SimdRealField

source§#### fn simd_norm1(self) -> <T as SimdComplexField>::SimdRealField

#### fn simd_norm1(self) -> <T as SimdComplexField>::SimdRealField

source§#### fn simd_scale(self, factor: <T as SimdComplexField>::SimdRealField) -> T

#### fn simd_scale(self, factor: <T as SimdComplexField>::SimdRealField) -> T

`factor`

.source§#### fn simd_unscale(self, factor: <T as SimdComplexField>::SimdRealField) -> T

#### fn simd_unscale(self, factor: <T as SimdComplexField>::SimdRealField) -> T

`factor`

.source§#### fn simd_to_polar(
self
) -> (<T as SimdComplexField>::SimdRealField, <T as SimdComplexField>::SimdRealField)

#### fn simd_to_polar( self ) -> (<T as SimdComplexField>::SimdRealField, <T as SimdComplexField>::SimdRealField)

source§#### fn simd_to_exp(self) -> (<T as SimdComplexField>::SimdRealField, T)

#### fn simd_to_exp(self) -> (<T as SimdComplexField>::SimdRealField, T)

source§#### fn simd_signum(self) -> T

#### fn simd_signum(self) -> T

`self / self.modulus()`

#### fn simd_floor(self) -> T

#### fn simd_ceil(self) -> T

#### fn simd_round(self) -> T

#### fn simd_trunc(self) -> T

#### fn simd_fract(self) -> T

#### fn simd_mul_add(self, a: T, b: T) -> T

source§#### fn simd_abs(self) -> <T as SimdComplexField>::SimdRealField

#### fn simd_abs(self) -> <T as SimdComplexField>::SimdRealField

`self / self.signum()`

. Read moresource§#### fn simd_hypot(self, other: T) -> <T as SimdComplexField>::SimdRealField

#### fn simd_hypot(self, other: T) -> <T as SimdComplexField>::SimdRealField

#### fn simd_recip(self) -> T

#### fn simd_conjugate(self) -> T

#### fn simd_sin(self) -> T

#### fn simd_cos(self) -> T

#### fn simd_sin_cos(self) -> (T, T)

#### fn simd_sinh_cosh(self) -> (T, T)

#### fn simd_tan(self) -> T

#### fn simd_asin(self) -> T

#### fn simd_acos(self) -> T

#### fn simd_atan(self) -> T

#### fn simd_sinh(self) -> T

#### fn simd_cosh(self) -> T

#### fn simd_tanh(self) -> T

#### fn simd_asinh(self) -> T

#### fn simd_acosh(self) -> T

#### fn simd_atanh(self) -> T

#### fn simd_sinhc(self) -> T

#### fn simd_coshc(self) -> T

#### fn simd_log(self, base: <T as SimdComplexField>::SimdRealField) -> T

#### fn simd_log2(self) -> T

#### fn simd_log10(self) -> T

#### fn simd_ln(self) -> T

#### fn simd_ln_1p(self) -> T

#### fn simd_sqrt(self) -> T

#### fn simd_exp(self) -> T

#### fn simd_exp2(self) -> T

#### fn simd_exp_m1(self) -> T

#### fn simd_powi(self, n: i32) -> T

#### fn simd_powf(self, n: <T as SimdComplexField>::SimdRealField) -> T

#### fn simd_powc(self, n: T) -> T

#### fn simd_cbrt(self) -> T

source§#### fn simd_horizontal_sum(self) -> <T as SimdValue>::Element

#### fn simd_horizontal_sum(self) -> <T as SimdValue>::Element

`self`

.source§#### fn simd_horizontal_product(self) -> <T as SimdValue>::Element

#### fn simd_horizontal_product(self) -> <T as SimdValue>::Element

`self`

.source§### impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,

### impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,

source§#### fn to_subset(&self) -> Option<SS>

#### fn to_subset(&self) -> Option<SS>

`self`

from the equivalent element of its
superset. Read moresource§#### fn is_in_subset(&self) -> bool

#### fn is_in_subset(&self) -> bool

`self`

is actually part of its subset `T`

(and can be converted to it).source§#### fn to_subset_unchecked(&self) -> SS

#### fn to_subset_unchecked(&self) -> SS

`self.to_subset`

but without any property checks. Always succeeds.source§#### fn from_subset(element: &SS) -> SP

#### fn from_subset(element: &SS) -> SP

`self`

to the equivalent element of its superset.