Struct hcomplex::Construct

pub struct Construct<T, U> { /* fields omitted */ }

Cayley–Dickson construction, a basic building block.

Structure takes two type parameters: + The first one, T: a scalar type the algebra is built over. + The second one, U: is a type of two components of the construction: re and im.

Implementations

impl<T, U> Construct<T, U>

pub fn new(re: U, im: U) -> Self

Create from real and imaginary parts.

pub fn split(self) -> (U, U)

Split by real and imaginary parts.

pub fn re_ref(&self) -> &U

pub fn im_ref(&self) -> &U

pub fn re_mut(&mut self) -> &mut U

pub fn im_mut(&mut self) -> &mut U

impl<T, U> Construct<T, U> where
    U: Clone, 

pub fn re(&self) -> U

pub fn im(&self) -> U

impl<T, U> Construct<T, U> where
    Self: Clone + Norm<Output = T> + Div<T, Output = Self>, 

pub fn normalize(self) -> Self

impl<T, U> Construct<T, Construct<T, U>>

pub fn new2(w: U, x: U, y: U, z: U) -> Self

Create from four parts.

impl<T, U> Construct<T, Construct<T, U>> where
    U: Clone,
    Construct<T, U>: Clone, 

pub fn w(&self) -> U

pub fn x(&self) -> U

pub fn y(&self) -> U

pub fn z(&self) -> U

impl<T, U> Construct<T, Construct<T, U>>

pub fn w_ref(&self) -> &U

pub fn x_ref(&self) -> &U

pub fn y_ref(&self) -> &U

pub fn z_ref(&self) -> &U

pub fn w_mut(&mut self) -> &mut U

pub fn x_mut(&mut self) -> &mut U

pub fn y_mut(&mut self) -> &mut U

pub fn z_mut(&mut self) -> &mut U

impl<T: Float> Construct<T, T>

pub fn into_num(self) -> NumComplex<T>

Convert into num_complex::Complex struct.

pub fn arg(self) -> T

Calculate the principal Arg of self.

pub fn exp(self) -> Self

Computes e^(self), where e is the base of the natural logarithm.

pub fn ln(self) -> Self

Computes the principal value of natural logarithm of self.

pub fn sqrt(self) -> Self

Computes the principal value of the square root of self.

pub fn cbrt(self) -> Self

Computes the principal value of the cube root of self.

Note that this does not match the usual result for the cube root of negative real numbers. For example, the real cube root of -8 is -2, but the principal complex cube root of -8 is 1 + i√3.

pub fn powu(self, exp: u32) -> Self

Raises self to an unsigned integer power.

pub fn powi(self, exp: i32) -> Self

Raises self to a signed integer power.

pub fn powf(self, exp: T) -> Self

Raises self to a floating point power.

pub fn powc(self, exp: Self) -> Self

Raises self to a complex power.

pub fn log(self, base: T) -> Self

Returns the logarithm of self with respect to an arbitrary base.

pub fn expf(self, base: T) -> Self

Raises a floating point number to the complex power self.

pub fn sin(self) -> Self

Computes the sine of self.

pub fn cos(self) -> Self

Computes the cosine of self.

pub fn tan(self) -> Self

Computes the tangent of self.

pub fn asin(self) -> Self

Computes the principal value of the inverse sine of self.

pub fn acos(self) -> Self

Computes the principal value of the inverse cosine of self.

pub fn atan(self) -> Self

Computes the principal value of the inverse tangent of self.

pub fn sinh(self) -> Self

Computes the hyperbolic sine of self.

pub fn cosh(self) -> Self

Computes the hyperbolic cosine of self.

pub fn tanh(self) -> Self

Computes the hyperbolic tangent of self.

pub fn asinh(self) -> Self

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

pub fn acosh(self) -> Self

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

pub fn atanh(self) -> Self

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

pub fn finv(self) -> Self

Returns 1/self using floating-point operations.

impl<T: Float + Clone> Construct<T, T> where
    Self: Norm<Output = T>, 

pub fn to_polar(self) -> (T, T)

Convert to polar form.

pub fn from_polar(r: T, theta: T) -> Self

Convert a polar representation into a complex number.

impl<T: One + Zero> Construct<T, T>

pub fn i() -> Self

impl<T: One + Zero> Construct<T, Construct<T, T>>

pub fn i() -> Self

pub fn j() -> Self

pub fn k() -> Self

Trait Implementations

impl<T: Clone, U> AbsDiffEq<Construct<T, U>> for Construct<T, U> where
    T: AbsDiffEq<Epsilon = T>,
    U: AbsDiffEq<Epsilon = T>, 

type Epsilon = T

Used for specifying relative comparisons.

pub fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

pub fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

pub fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T, U> Add<Construct<T, Construct<T, U>>> for Construct<T, U> where
    Construct<T, U>: Add<Output = Construct<T, U>>, 

type Output = Construct<T, Construct<T, U>>

The resulting type after applying the + operator.

pub fn add(self, other: Construct<T, Construct<T, U>>) -> Self::Output

Performs the + operation.

impl<T, U> Add<Construct<T, U>> for Construct<T, U> where
    U: Add<Output = U>, 

type Output = Self

The resulting type after applying the + operator.

pub fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<T, U> Add<Construct<T, U>> for Construct<T, Construct<T, U>> where
    Construct<T, U>: Add<Output = Construct<T, U>>, 

type Output = Self

The resulting type after applying the + operator.

pub fn add(self, other: Construct<T, U>) -> Self::Output

Performs the + operation.

impl<U> Add<Construct<f32, U>> for f32 where
    Construct<f32, U>: Add<f32, Output = Construct<f32, U>>, 

Workaround for reverse addition.

type Output = Construct<f32, U>

The resulting type after applying the + operator.

pub fn add(self, other: Construct<f32, U>) -> Self::Output

Performs the + operation.

impl<U> Add<Construct<f64, U>> for f64 where
    Construct<f64, U>: Add<f64, Output = Construct<f64, U>>, 

Workaround for reverse addition.

type Output = Construct<f64, U>

The resulting type after applying the + operator.

pub fn add(self, other: Construct<f64, U>) -> Self::Output

Performs the + operation.

impl<T, U> Add<T> for Construct<T, U> where
    U: Add<T, Output = U>, 

type Output = Self

The resulting type after applying the + operator.

pub fn add(self, other: T) -> Self::Output

Performs the + operation.

impl<T, U> AddAssign<Construct<T, U>> for Construct<T, U> where
    U: AddAssign, 

pub fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T, U> AddAssign<Construct<T, U>> for Construct<T, Construct<T, U>> where
    Construct<T, U>: AddAssign, 

pub fn add_assign(&mut self, other: Construct<T, U>)

Performs the += operation.

impl<T, U> AddAssign<T> for Construct<T, U> where
    U: AddAssign<T>, 

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

Performs the += operation.

impl<T, U> Algebra<T> for Construct<T, U> where
    T: Algebra + Clone,
    U: Algebra<T> + Clone, 

impl<T: Clone, U: Clone> Clone for Construct<T, U>

pub fn clone(&self) -> Construct<T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, U> Conj for Construct<T, U> where
    U: Conj + Neg<Output = U>, 

pub fn conj(self) -> Self

Get conjugate value.

impl<T: Copy, U: Copy> Copy for Construct<T, U>

impl<T: Debug, U> Debug for Construct<T, U> where
    Self: Format<T>, 

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

Formats the value using the given formatter.

impl<T: Algebra + Clone> Deriv<Construct<T, T>> for Moebius<Complex<T>>

pub fn deriv(&self, p: Complex<T>) -> Complex<T>

Find the derivative of self at the specified point p.

impl<T: NumCast + Algebra + Dot<Output = T> + Clone> DerivDir<Construct<T, Construct<T, T>>> for Moebius<Complex<T>>

pub fn deriv_dir(&self, p: Quaternion<T>, v: Quaternion<T>) -> Quaternion<T>

Find the directinal derivative of self at the specified point p via the specified direction d.

impl<T: Display, U> Display for Construct<T, U> where
    Self: Format<T>, 

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

Formats the value using the given formatter.

impl<T, U> Distribution<Construct<T, U>> for StandardNormal where
    StandardNormal: Distribution<U>, 

pub fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Construct<T, U>

Generate a random value of T, using rng as the source of randomness.

pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<T: Float, U: NormSqr<Output = T> + Clone> Distribution<Construct<T, U>> for NonZero where
    StandardNormal: Distribution<Construct<T, U>>, 

pub fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Construct<T, U>

Generate a random value of T, using rng as the source of randomness.

pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<T: Float, U: NormSqr<Output = T> + Div<T, Output = U> + Clone> Distribution<Construct<T, U>> for Unit where
    NonZero: Distribution<Construct<T, U>>, 

pub fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Construct<T, U>

Generate a random value of T, using rng as the source of randomness.

pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<T, U> Div<Construct<T, Construct<T, U>>> for Construct<T, U> where
    Construct<T, Self>: Inv<Output = Construct<T, Self>>,
    Self: Mul<Construct<T, Self>, Output = Construct<T, Self>>, 

type Output = Construct<T, Construct<T, U>>

The resulting type after applying the / operator.

pub fn div(self, other: Construct<T, Construct<T, U>>) -> Self::Output

Performs the / operation.

impl<T, U> Div<Construct<T, U>> for Construct<T, U> where
    Self: Inv<Output = Self> + Mul<Output = Self>, 

type Output = Self

The resulting type after applying the / operator.

pub fn div(self, other: Self) -> Self::Output

Performs the / operation.

impl<T, U> Div<Construct<T, U>> for Construct<T, Construct<T, U>> where
    Construct<T, U>: Div<Output = Construct<T, U>> + Clone, 

type Output = Self

The resulting type after applying the / operator.

pub fn div(self, other: Construct<T, U>) -> Self::Output

Performs the / operation.

impl<U> Div<Construct<f32, U>> for f32 where
    Construct<f32, U>: Inv<Output = Construct<f32, U>> + Mul<f32, Output = Construct<f32, U>> + Clone, 

Workaround for reverse division.

type Output = Construct<f32, U>

The resulting type after applying the / operator.

pub fn div(self, other: Construct<f32, U>) -> Self::Output

Performs the / operation.

impl<U> Div<Construct<f64, U>> for f64 where
    Construct<f64, U>: Inv<Output = Construct<f64, U>> + Mul<f64, Output = Construct<f64, U>> + Clone, 

Workaround for reverse division.

type Output = Construct<f64, U>

The resulting type after applying the / operator.

pub fn div(self, other: Construct<f64, U>) -> Self::Output

Performs the / operation.

impl<T, U> Div<T> for Construct<T, U> where
    T: Clone,
    U: Div<T, Output = U>, 

type Output = Self

The resulting type after applying the / operator.

pub fn div(self, other: T) -> Self::Output

Performs the / operation.

impl<T, U> DivAssign<Construct<T, U>> for Construct<T, U> where
    Self: Clone + Div<Output = Self>, 

pub fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T, U> DivAssign<Construct<T, U>> for Construct<T, Construct<T, U>> where
    Self: Div<Construct<T, U>, Output = Self> + Clone, 

pub fn div_assign(&mut self, other: Construct<T, U>)

Performs the /= operation.

impl<T, U> DivAssign<T> for Construct<T, U> where
    Self: Clone + Div<T, Output = Self>, 

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

Performs the /= operation.

impl<T, U> Dot for Construct<T, U> where
    T: Add<Output = T>,
    U: Dot<Output = T>, 

type Output = T

Dot product output type.

pub fn dot(self, other: Self) -> T

Perform dot product.

impl<T, U> Format<T> for Construct<T, Construct<T, U>> where
    Construct<T, U>: Format<T>, 

pub fn level() -> usize

pub fn write_content_debug(&self, f: &mut Formatter<'_>) -> FmtResult where
    T: Debug, 

pub fn write_content_display(&self, f: &mut Formatter<'_>) -> FmtResult where
    T: Display, 

pub fn write_name(f: &mut Formatter<'_>) -> FmtResult

impl<T> Format<T> for Construct<T, T>

pub fn level() -> usize

pub fn write_content_debug(&self, f: &mut Formatter<'_>) -> FmtResult where
    T: Debug, 

pub fn write_content_display(&self, f: &mut Formatter<'_>) -> FmtResult where
    T: Display, 

pub fn write_name(f: &mut Formatter<'_>) -> FmtResult

impl<T, U> Inv for Construct<T, U> where
    Self: Clone + Conj + NormSqr<Output = T> + Div<T, Output = Self>, 

type Output = Self

The result after applying the operator.

pub fn inv(self) -> Self

Returns the multiplicative inverse of self.

impl<T, U> Mul<Construct<T, Construct<T, U>>> for Construct<T, U> where
    Construct<T, U>: Mul<Output = Construct<T, U>> + Clone, 

type Output = Construct<T, Construct<T, U>>

The resulting type after applying the * operator.

pub fn mul(self, other: Construct<T, Construct<T, U>>) -> Self::Output

Performs the * operation.

impl<T, U> Mul<Construct<T, U>> for Construct<T, U> where
    U: Clone + Conj + Mul<Output = U> + Add<Output = U> + Sub<Output = U>, 

type Output = Self

The resulting type after applying the * operator.

pub fn mul(self, other: Self) -> Self::Output

Performs the * operation.

impl<T, U> Mul<Construct<T, U>> for Construct<T, Construct<T, U>> where
    Construct<T, U>: Mul<Output = Construct<T, U>> + Clone, 

type Output = Self

The resulting type after applying the * operator.

pub fn mul(self, other: Construct<T, U>) -> Self::Output

Performs the * operation.

impl<U> Mul<Construct<f32, U>> for f32 where
    Construct<f32, U>: Mul<f32, Output = Construct<f32, U>>, 

Workaround for reverse multiplication.

type Output = Construct<f32, U>

The resulting type after applying the * operator.

pub fn mul(self, other: Construct<f32, U>) -> Self::Output

Performs the * operation.

impl<U> Mul<Construct<f64, U>> for f64 where
    Construct<f64, U>: Mul<f64, Output = Construct<f64, U>>, 

Workaround for reverse multiplication.

type Output = Construct<f64, U>

The resulting type after applying the * operator.

pub fn mul(self, other: Construct<f64, U>) -> Self::Output

Performs the * operation.

impl<T, U> Mul<T> for Construct<T, U> where
    T: Clone,
    U: Mul<T, Output = U>, 

type Output = Self

The resulting type after applying the * operator.

pub fn mul(self, other: T) -> Self::Output

Performs the * operation.

impl<T, U> MulAssign<Construct<T, U>> for Construct<T, U> where
    Self: Clone + Mul<Output = Self>, 

pub fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T, U> MulAssign<Construct<T, U>> for Construct<T, Construct<T, U>> where
    Self: Mul<Construct<T, U>, Output = Self> + Clone, 

pub fn mul_assign(&mut self, other: Construct<T, U>)

Performs the *= operation.

impl<T, U> MulAssign<T> for Construct<T, U> where
    Self: Clone + Mul<T, Output = Self>, 

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

Performs the *= operation.

impl<T, U> Neg for Construct<T, U> where
    U: Neg<Output = U>, 

type Output = Self

The resulting type after applying the - operator.

pub fn neg(self) -> Self

Performs the unary - operation.

impl<T, U> Norm for Construct<T, U> where
    T: Float,
    Self: NormSqr<Output = T>, 

type Output = T

pub fn norm(self) -> T

Get the norm of the self.

pub fn abs(self) -> Self::Output

Alias to norm.

impl<T, U> NormL1 for Construct<T, U> where
    T: Add<Output = T>,
    U: NormL1<Output = T>, 

type Output = T

pub fn norm_l1(self) -> T

Get the L1 norm of the self.

impl<T, U> NormSqr for Construct<T, U> where
    T: Add<Output = T>,
    U: NormSqr<Output = T>, 

type Output = T

pub fn norm_sqr(self) -> T

Get square of the norm of the self.

pub fn abs_sqr(self) -> Self::Output

Alias to norm_sqr.

impl<T: Num + Algebra + Clone, U: Num + Algebra<T> + Clone> Num for Construct<T, U>

Not implemented yet.

type FromStrRadixErr = ()

pub fn from_str_radix(
    _str: &str,
    _radix: u32
) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl<T, U> One for Construct<T, U> where
    U: Zero + One,
    Self: Mul<Output = Self>, 

pub fn one() -> Self

Returns the multiplicative identity element of Self, 1.

pub fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

pub fn is_one(&self) -> bool where
    Self: PartialEq<Self>, 

Returns true if self is equal to the multiplicative identity.

impl<T: PartialEq, U: PartialEq> PartialEq<Construct<T, U>> for Construct<T, U>

pub fn eq(&self, other: &Construct<T, U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Construct<T, U>) -> bool

This method tests for !=.

impl<T: Clone, U> RelativeEq<Construct<T, U>> for Construct<T, U> where
    T: RelativeEq<Epsilon = T>,
    U: RelativeEq<Epsilon = T>, 

pub fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

pub fn relative_eq(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

pub fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T: Num + Algebra + Clone, U: Num + Algebra<T> + Clone> Rem<Construct<T, U>> for Construct<T, U>

Not implemented yet.

type Output = Self

The resulting type after applying the % operator.

pub fn rem(self, _other: Self) -> Self::Output

Performs the % operation.

impl<T, U> StructuralPartialEq for Construct<T, U>

impl<T, U> Sub<Construct<T, Construct<T, U>>> for Construct<T, U> where
    Construct<T, U>: Sub<Output = Construct<T, U>>, 

type Output = Construct<T, Construct<T, U>>

The resulting type after applying the - operator.

pub fn sub(self, other: Construct<T, Construct<T, U>>) -> Self::Output

Performs the - operation.

impl<T, U> Sub<Construct<T, U>> for Construct<T, U> where
    U: Sub<Output = U>, 

type Output = Self

The resulting type after applying the - operator.

pub fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<T, U> Sub<Construct<T, U>> for Construct<T, Construct<T, U>> where
    Construct<T, U>: Sub<Output = Construct<T, U>>, 

type Output = Self

The resulting type after applying the - operator.

pub fn sub(self, other: Construct<T, U>) -> Self::Output

Performs the - operation.

impl<U> Sub<Construct<f32, U>> for f32 where
    Construct<f32, U>: Neg<Output = Construct<f32, U>> + Add<f32, Output = Construct<f32, U>>, 

Workaround for reverse subtraction.

type Output = Construct<f32, U>

The resulting type after applying the - operator.

pub fn sub(self, other: Construct<f32, U>) -> Self::Output

Performs the - operation.

impl<U> Sub<Construct<f64, U>> for f64 where
    Construct<f64, U>: Neg<Output = Construct<f64, U>> + Add<f64, Output = Construct<f64, U>>, 

Workaround for reverse subtraction.

type Output = Construct<f64, U>

The resulting type after applying the - operator.

pub fn sub(self, other: Construct<f64, U>) -> Self::Output

Performs the - operation.

impl<T, U> Sub<T> for Construct<T, U> where
    U: Sub<T, Output = U>, 

type Output = Self

The resulting type after applying the - operator.

pub fn sub(self, other: T) -> Self::Output

Performs the - operation.

impl<T, U> SubAssign<Construct<T, U>> for Construct<T, U> where
    U: SubAssign, 

pub fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T, U> SubAssign<Construct<T, U>> for Construct<T, Construct<T, U>> where
    Construct<T, U>: SubAssign, 

pub fn sub_assign(&mut self, other: Construct<T, U>)

Performs the -= operation.

impl<T, U> SubAssign<T> for Construct<T, U> where
    U: SubAssign<T>, 

pub fn sub_assign(&mut self, other: T)

Performs the -= operation.

impl<T: Algebra + Clone, U: Algebra<T> + Clone> Transform<Construct<T, Construct<T, U>>> for Moebius<Construct<T, U>>

pub fn apply(
    &self,
    x: Construct<T, Construct<T, U>>
) -> Construct<T, Construct<T, U>>

Apply the transformation.

impl<T: Clone, U> UlpsEq<Construct<T, U>> for Construct<T, U> where
    T: UlpsEq<Epsilon = T>,
    U: UlpsEq<Epsilon = T>, 

pub fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

pub fn ulps_eq(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_ulps: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

pub fn ulps_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_ulps: u32
) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T, U> Zero for Construct<T, U> where
    U: Zero, 

pub fn zero() -> Self

Returns the additive identity element of Self, 0.

pub fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

pub fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.