Struct Perplex 

pub struct Perplex<T> {
    pub t: T,
    pub x: T,
}

The Perplex struct is a representation of hyperbolic numbers, also known as split-complex numbers, which consist of two components: a real part (t) and a hyperbolic part (x). These components correspond to the time and space coordinates in Minkowski space-time, respectively. See Sec. 4.1 Geometrical Representation of Hyperbolic Numbers in The Mathematics of Minkowski Space-Time. The implementation is generic over a type T, which allows it to be used with different numeric types (i.e., f32 or f64).

Fields

t: T

The real part of the perplex number, representing time.

x: T

The hyperbolic part of the perplex number, representing space.

Implementations

impl<T: Copy + RealField> Perplex<T>

pub fn as_matrix_form(&self) -> PerplexMatrixForm<T>

Creates a matrix form from a perplex number, resulting in a symmetric matrix.

impl<T> Perplex<T>

pub fn new(t: T, x: T) -> Self

Create a new Perplex number

impl<T: Copy + Num> Perplex<T>

pub fn h() -> Self

Returns hyperbolic unit.

pub fn real(&self) -> T

Returns the time component.

pub fn hyperbolic(&self) -> T

Returns the space component.

pub fn squared_distance(&self) -> T

Returns the squared distance D(z) in the hyperbolic plane.

pub fn scale(&self, factor: T) -> Self

Multiplies self by the scalar factor.

impl<T: Copy + Num + PartialOrd> Perplex<T>

pub fn is_time_like(&self) -> bool

Checks if the perplex number is time-like, i.e., the squared distance is positive.

pub fn is_space_like(&self) -> bool

Checks if the perplex number is space-like, i.e., the squared distance is negative.

pub fn is_light_like(&self) -> bool

Checks if the perplex number is light-like, i.e., the squared distance is zero.

impl<T: Copy + Num + Neg<Output = T>> Perplex<T>

pub fn conj(&self) -> Self

Returns the hyperbolic conjugate.

pub fn try_inverse(&self) -> Option<Self>

Returns the multiplicative inverse 1/self, if it exists, or None if not.

impl<T: Copy + Float> Perplex<T>

pub fn l1_norm(&self) -> T

Returns the L1 norm |t| + |x| (Manhattan distance) from the origin in the cartesian coordinate plane, see Eq. 2.49 in New characterizations of the ring of the split-complex numbers and the field C of complex numbers and their comparative analyses.

pub fn l2_norm(&self) -> T

Returns the L2 norm |t^2| + |x^2| (Euclidean distance) from the origin in the cartesian coordinate plane, see Eq. 2.50 in New characterizations of the ring of the split-complex numbers and the field C of complex numbers and their comparative analyses.

pub fn max_norm(&self) -> T

Returns the maximum norm ||z||_∞ = max(|t|, |x|) from the origin in the cartesian coordinate plane, see Eq. 2.51 in New characterizations of the ring of the split-complex numbers and the field C of complex numbers and their comparative analyses.

pub fn modulus(self) -> T

Returns the modulus of self.

pub fn norm(self) -> T

Returns the norm (modulus) of self.

pub fn magnitude(self) -> T

Returns the magnitude (modulus) of self.

pub fn exp(self) -> Self

Computes the hyperbolic exponential function for all sectors. Formula is extended to all sectors, see Sec 4.1.1 Hyperbolic Exponential Function and 7.4 The Elementary Functions of a Canonical Hyperbolic Variable in The Mathematics of Minkowski Space-Time.

pub fn ln(self) -> Option<Self>

Computes the inverse of the hyperbolic exponential function, i.e., the natural logarithm. Formula is extended to all sectors, see Sec. 7.4 The Elementary Functions of a Canonical Hyperbolic Variable in The Mathematics of Minkowski Space-Time.

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

Returns the logarithm of self with respect to an arbitrary base, if the natural logarithm of self exists, according to the formula ln(self) / ln(base).

pub fn sqrt(self) -> Option<Self>

Computes the square root of self if self lies in the right sector, or returns None if not. Formula is taken from Eq. 2.23 in New characterizations of the ring of the split-complex numbers and the field C of complex numbers and their comparative analyses.

pub fn sin(self) -> Self

Computes the sinus (circular trigonometric) of self. Formula is taken from Eq. 7.4.6 in The Mathematics of Minkowski Space-Time.

pub fn cos(self) -> Self

Computes the cosinus (circular trigonometric) of self. Formula is taken from Eq. 7.4.6 in The Mathematics of Minkowski Space-Time.

pub fn tan(self) -> Option<Self>

Computes the tangens (circular trigonometric) of self by the formula sin(self) / cos(self). Returns None if cos(self) is light-like.

pub fn sinh(self) -> Self

Computes the sinh (hyperbolic trigonometric) of self. Formula is taken from Eq. 7.4.5 in The Mathematics of Minkowski Space-Time.

pub fn cosh(self) -> Self

Computes the cosh (hyperbolic trigonometric) of self. Formula is taken from Eq. 7.4.5 in The Mathematics of Minkowski Space-Time.

pub fn tanh(self) -> Option<Self>

Computes the tanh (hyperbolic trigonometric) of self by the formula sinh(self) / cosh(self). Returns None if cosh(self) is light-like.

impl<T: FloatCore> Perplex<T>

pub fn is_nan(self) -> bool

Checks if the given perplex number is NaN

pub fn is_infinite(self) -> bool

Checks if the given perplex number is infinite

pub fn is_finite(self) -> bool

Checks if the given perplex number is finite

pub fn is_normal(self) -> bool

Checks if the given perplex number is normal

impl<T: Copy + Float> Perplex<T>

pub fn cis(theta: T) -> Self

Creates a new Perplex number z with a given hyperbolic angle theta such that z= exp(h theta).

It is used to create a Perplex number with a given phase, using hyperbolic cosine and sine.

pub fn arg(self) -> T

Calculates the hyperbolic argument of self.

The argument is the angle in the hyperbolic plane from the positive time axis to the line connecting the origin to self. It is defined by a piecewise function, with special cases for light-like perplex numbers, whereby lines x=t and x=-t are mapped to ∞ and -∞, respectively, according to Sec. 4.1 in New characterizations of the ring of the split-complex numbers and the field C of complex numbers and their comparative analyses. The formula is taken from Eq. 4.1.6 in Sec 4.1.1 Hyperbolic Exponential Function and Hyperbolic Polar Transformation in The Mathematics of Minkowski Space-Time.

pub fn klein(self) -> Option<Self>

Calculate the Klein index of self for space- or time-like numbers. Returns None for light-like numbers.

The Klein index is determined by the sector of the hyperbolic plane in which self resides. Formula is taken from Tab. 1 and Appendix B in Hyperbolic trigonometry in two-dimensional space-time geometry.

pub fn sector(&self) -> HyperbolicSector<T>

Retrieves the hyperbolic sector of the perplex number.

Examples

use perplex_num::{Perplex, HyperbolicSector};

let perplex = Perplex::new(1.0, 0.5);
assert_eq!(perplex.sector(), HyperbolicSector::Right);

pub fn polar(&self) -> HyperbolicPolar<T>

Retrieves the hyperbolic polar form from a perplex number.

Examples

use perplex_num::{Perplex, HyperbolicPolar};

let perplex = Perplex::new(1.0, 0.5);
let polar = perplex.polar();
assert_eq!(polar.rho, perplex.norm());
assert_eq!(polar.theta, perplex.arg());

impl<T: Copy + Num + Neg<Output = T>> Perplex<T>

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

Raises self to an unsigned integer power.

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

Raises self to a signed integer power.

Trait Implementations

impl<T: AbsDiffEq> AbsDiffEq for Perplex<T>

where T::Epsilon: Copy,

type Epsilon = <T as AbsDiffEq>::Epsilon

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: Copy + Num> Add<T> for Perplex<T>

type Output = Perplex<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Copy + Num> Add for Perplex<T>

type Output = Perplex<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Copy + NumAssign> AddAssign<T> for Perplex<T>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: Copy + NumAssign> AddAssign for Perplex<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone> Clone for Perplex<T>

fn clone(&self) -> Perplex<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Perplex<T>

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

Formats the value using the given formatter.

impl<T: Copy + Num> Default for Perplex<T>

fn default() -> Self

Defaults to the neutral element of multiplication.

impl<T: Copy + Neg<Output = T> + PartialOrd + Num + Display> Display for Perplex<T>

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

Formats the value using the given formatter.

impl<T: Copy + Num> Div<T> for Perplex<T>

type Output = Perplex<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Copy + Num> Div for Perplex<T>

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

Divides self by rhs. Division by a light-like number yields None, otherwise Some(self / rhs).

type Output = Option<Perplex<T>>

The resulting type after applying the / operator.

impl<T: Copy + NumAssign> DivAssign<T> for Perplex<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Copy + NumAssign> DivAssign for Perplex<T>

fn div_assign(&mut self, rhs: Self)

Divides self by rhs in place. Division by a light-like number yields a Perplex number with NaN components.

impl<T: Copy + Float> From<HyperbolicPolar<T>> for Perplex<T>

fn from(polar: HyperbolicPolar<T>) -> Self

Converts a hyperbolic polar representation back to a perplex number.

This method applies the inverse of the hyperbolic polar conversion, reconstructing the original perplex number from its modulus, argument, and sector.

impl<T: Copy + RealField> From<Matrix<T, Const<2>, Const<2>, ArrayStorage<T, 2, 2>>> for Perplex<T>

fn from(m: PerplexMatrixForm<T>) -> Self

Converts a matrix form to a perplex number, assuming a symmetric matrix.

impl<T: Copy + Float> From<Perplex<T>> for HyperbolicPolar<T>

fn from(z: Perplex<T>) -> Self

Converts a perplex number to hyperbolic polar form.

The conversion takes into account the sector of the hyperbolic plane the number is in and uses the appropriate hyperbolic trigonometric functions.

impl<T: Copy + Float> From<Perplex<T>> for HyperbolicSector<T>

fn from(z: Perplex<T>) -> Self

Converts a perplex number into its corresponding hyperbolic sector.

Light-like numbers are converted to the Diagonal variant, while others are categorized based on the magnitude and sign of their time and space components.

impl<T: Copy + RealField> From<Perplex<T>> for PerplexMatrixForm<T>

fn from(z: Perplex<T>) -> Self

Returns the matrix form of the perplex number.

impl<T: Copy + Num> From<T> for Perplex<T>

fn from(t: T) -> Self

Conversion of a number t into a Perplex yields time-component t with zero space component.

impl<T: Hash> Hash for Perplex<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Copy + Num + Neg<Output = T>> Inv for Perplex<T>

type Output = Option<Perplex<T>>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl<T: Copy + Num> Mul<T> for Perplex<T>

type Output = Perplex<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Num> Mul for Perplex<T>

type Output = Perplex<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Num + MulAdd<Output = T>> MulAdd for Perplex<T>

type Output = Perplex<T>

The resulting type after applying the fused multiply-add.

fn mul_add(self, other: Perplex<T>, add: Perplex<T>) -> Self

Performs the fused multiply-add operation (self * a) + b

impl<T: Copy + NumAssign + MulAddAssign> MulAddAssign for Perplex<T>

fn mul_add_assign(&mut self, other: Self, add: Self)

Performs the fused multiply-add assignment operation *self = (*self * a) + b

impl<T: Copy + NumAssign> MulAssign<T> for Perplex<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Copy + NumAssign> MulAssign for Perplex<T>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: Copy + Num + Neg<Output = T>> Neg for Perplex<T>

type Output = Perplex<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Copy + Num> One for Perplex<T>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

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

impl<T: Ord> Ord for Perplex<T>

fn cmp(&self, other: &Perplex<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for Perplex<T>

fn eq(&self, other: &Perplex<T>) -> 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: PartialOrd> PartialOrd for Perplex<T>

fn partial_cmp(&self, other: &Perplex<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Copy + Num + Neg<Output = T>> Pow<i32> for Perplex<T>

fn pow(self, exp: i32) -> Self::Output

Performs exponentiation for both positive and negative integer exponents. For negative exponents, it calculates the multiplicative inverse before exponentiation.

Arguments

• exp - The exponent to raise the perplex number to.

Returns

An Option containing the result of raising the perplex number to the power of exp. Returns None if the perplex number cannot be inverted (i.e., it is light-like).

type Output = Option<Perplex<T>>

The result after applying the operator.

impl<T: Copy + Num> Pow<u32> for Perplex<T>

fn pow(self, exp: u32) -> Self::Output

Performs exponentiation by squaring, an efficient algorithm for raising numbers to a power. This method is an iterative implementation of the algorithm described at Exponentiation by Squaring.

Arguments

• exp - The exponent to raise the perplex number to.

Returns

The result of raising the perplex number to the power of exp.

type Output = Perplex<T>

The result after applying the operator.

impl<T: Copy + Num> Sub<T> for Perplex<T>

type Output = Perplex<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Copy + Num> Sub for Perplex<T>

type Output = Perplex<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Copy + NumAssign> SubAssign<T> for Perplex<T>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: Copy + NumAssign> SubAssign for Perplex<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Copy + Num> Zero for Perplex<T>

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: Copy> Copy for Perplex<T>

impl<T: Eq> Eq for Perplex<T>

impl<T> StructuralPartialEq for Perplex<T>