Struct Construct

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

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, U> AbsDiffEq for Construct<T, U>

where T: AbsDiffEq<Epsilon = T> + Clone, U: AbsDiffEq<Epsilon = T>,

type Epsilon = T

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

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.

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.

fn add(self, other: Construct<T, Construct<T, U>>) -> 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 = Construct<T, Construct<T, U>>

The resulting type after applying the + operator.

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.

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.

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 = Construct<T, U>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where U: Add<Output = U>,

type Output = Construct<T, U>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where Construct<T, U>: AddAssign,

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>,

fn add_assign(&mut self, other: T)

Performs the += operation.

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

where U: AddAssign,

fn add_assign(&mut self, other: Self)

Performs the += operation.

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

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

Returns a copy of the value.

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>,

fn conj(self) -> Self

Get conjugate value.

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

where Self: Format<T>,

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>>

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>>

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>,

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

Formats the value using the given formatter.

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

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

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.

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

where R: Rng, Self: Sized,

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

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

where StandardNormal: Distribution<U>,

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.

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

where R: Rng, Self: Sized,

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>>,

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.

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

where R: Rng, Self: Sized,

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.

fn div(self, other: Construct<T, Construct<T, U>>) -> 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 = Construct<T, Construct<T, U>>

The resulting type after applying the / operator.

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.

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.

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 = Construct<T, U>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where Self: Inv<Output = Self> + Mul<Output = Self>,

type Output = Construct<T, U>

The resulting type after applying the / operator.

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

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,

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>,

fn div_assign(&mut self, other: T)

Performs the /= operation.

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

where Self: Clone + Div<Output = Self>,

fn div_assign(&mut self, other: Self)

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.

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>,

fn level() -> usize

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

where T: Debug,

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

where T: Display,

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

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

fn level() -> usize

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

where T: Debug,

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

where T: Display,

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 = Construct<T, U>

The result after applying the operator.

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.

fn mul(self, other: Construct<T, Construct<T, U>>) -> 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 = Construct<T, Construct<T, U>>

The resulting type after applying the * operator.

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.

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.

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 = Construct<T, U>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where U: Clone + Conj + Mul<Output = U> + Add<Output = U> + Sub<Output = U>,

type Output = Construct<T, U>

The resulting type after applying the * operator.

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

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,

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>,

fn mul_assign(&mut self, other: T)

Performs the *= operation.

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

where Self: Clone + Mul<Output = Self>,

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

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

where U: Neg<Output = U>,

type Output = Construct<T, U>

The resulting type after applying the - operator.

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

fn norm(self) -> T

Get the norm of the self.

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

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

fn norm_sqr(self) -> T

Get square of the norm of the self.

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 = ()

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>,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

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

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

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

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

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

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

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

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

where T: RelativeEq<Epsilon = T> + Clone, U: RelativeEq<Epsilon = T>,

fn default_max_relative() -> Self::Epsilon

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

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.

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 for Construct<T, U>

Not implemented yet.

type Output = Construct<T, U>

The resulting type after applying the % operator.

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

Performs the % operation.

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.

fn sub(self, other: Construct<T, Construct<T, U>>) -> 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 = Construct<T, Construct<T, U>>

The resulting type after applying the - operator.

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.

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.

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 = Construct<T, U>

The resulting type after applying the - operator.

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

Performs the - operation.

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

where U: Sub<Output = U>,

type Output = Construct<T, U>

The resulting type after applying the - operator.

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

Performs the - operation.

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

where Construct<T, U>: SubAssign,

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>,

fn sub_assign(&mut self, other: T)

Performs the -= operation.

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

where U: SubAssign,

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

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

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

Apply the transformation.

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

where T: UlpsEq<Epsilon = T> + Clone, U: UlpsEq<Epsilon = T>,

fn default_max_ulps() -> u32

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

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.

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,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

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

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

where T: Algebra + Clone, U: Algebra<T> + Clone,

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

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