diff --git a/README.md b/README.md new file mode 100644 index 0000000..c7af7f0 --- /dev/null +++ b/README.md @@ -0,0 +1,8 @@ +# Sigils # +A mathematics library. + +The code in this library uses macros pretty heavily. As such, +please check the trait's documentation for a function since the +macro definition will not really be documented. This was not +done to make documentation difficult, but to make coding the +library easier and to make it easier to maintain. diff --git a/src/bounded.rs b/src/bounded.rs new file mode 100644 index 0000000..cf01366 --- /dev/null +++ b/src/bounded.rs @@ -0,0 +1,61 @@ +use std::{u8, u16, u32, u64, usize, i8, i16, i32, i64, isize, f32, f64}; + + +/// Primitive types that have upper and lower bounds. +pub trait Bounded +{ + // TODO: I would love for this to be associated consts, but + // they are not currently working inside macros. + // It causes rust's stack to explode. + // Check this on later versions of rustc. + // + // Last version checked: rustc v1.3.0 + /// The minimum value for this type. + //const MIN: Self; + fn min_value() -> Self; + + /// The maximum value for this type. + //const MAX: Self; + fn max_value() -> Self; +} + + +/// A macro for making implementation of +/// the Bounded trait easier. +macro_rules! bounded_trait_impl +{ + ($T: ty, $minVal: expr, $maxVal: expr) => + { + impl Bounded for $T + { + //const MIN: $T = $minVal; + fn min_value() -> $T + { + $minVal + } + + //const MAX: $T = $maxVal; + fn max_value() -> $T + { + $maxVal + } + } + } +} + + +// Implement the Bounded for all the primitive types. +bounded_trait_impl!(u8, u8::MIN, u8::MAX); +bounded_trait_impl!(u16, u16::MIN, u16::MAX); +bounded_trait_impl!(u32, u32::MIN, u32::MAX); +bounded_trait_impl!(u64, u64::MIN, u64::MAX); +bounded_trait_impl!(usize, usize::MIN, usize::MAX); + +bounded_trait_impl!(i8, i8::MIN, i8::MAX); +bounded_trait_impl!(i16, i16::MIN, i16::MAX); +bounded_trait_impl!(i32, i32::MIN, i32::MAX); +bounded_trait_impl!(i64, i64::MIN, i64::MAX); +bounded_trait_impl!(isize, isize::MIN, isize::MAX); + +bounded_trait_impl!(f32, f32::MIN, f32::MAX); +bounded_trait_impl!(f64, f64::MIN, f64::MAX); diff --git a/src/constants.rs b/src/constants.rs new file mode 100644 index 0000000..72eec71 --- /dev/null +++ b/src/constants.rs @@ -0,0 +1,289 @@ +use std::{f32, f64}; + + +// Create the Constants trait so that we can use +// associated constants to define Mathematical constants for +// the f32 and f64 types. +/// Defines Mathematical constants. +pub trait Constants +{ + /// The square root of 2. + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::SQRT_2; + /// let val64: f64 = Constants::SQRT_2; + /// # assert_eq!(val32, std::f32::consts::SQRT_2); + /// # assert_eq!(val64, std::f64::consts::SQRT_2); + ///``` + const SQRT_2: Self; + + /// The square root of 3. + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::SQRT_3; + /// let val64: f64 = Constants::SQRT_3; + /// # assert_eq!(val32, 1.73205080756887729352f32); + /// # assert_eq!(val64, 1.73205080756887729352f64); + ///``` + const SQRT_3: Self; + + /// The inverse of the square root of 2 + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::INVERSE_SQRT_2; + /// let val64: f64 = Constants::INVERSE_SQRT_2; + /// # assert_eq!(val32, 1.0f32 / std::f32::consts::SQRT_2); + /// # assert_eq!(val64, 1.0f64 / std::f64::consts::SQRT_2); + ///``` + const INVERSE_SQRT_2: Self; + + /// The inverse of the square root of 3. + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::INVERSE_SQRT_3; + /// let val64: f64 = Constants::INVERSE_SQRT_3; + /// # assert_eq!(val32, 1.0f32 / 1.73205080756887729352f32); + /// # assert_eq!(val64, 1.0f64 / 1.73205080756887729352f64); + ///``` + const INVERSE_SQRT_3: Self; + + /// The mathematical constant [E][1]. Also known as [Euler's number][1]. + /// [1]: https://en.wikipedia.org/wiki/E_(mathematical_constant) + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::E; + /// let val64: f64 = Constants::E; + /// # assert_eq!(val32, std::f32::consts::E); + /// # assert_eq!(val64, std::f64::consts::E); + ///``` + const E: Self; + + /// The log base 2 of E. + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::LOG2_E; + /// let val64: f64 = Constants::LOG2_E; + /// # assert_eq!(val32, std::f32::consts::LOG2_E); + /// # assert_eq!(val64, std::f64::consts::LOG2_E); + ///``` + const LOG2_E: Self; + + /// The log base 10 of E. + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::LOG10_E; + /// let val64: f64 = Constants::LOG10_E; + /// # assert_eq!(val32, std::f32::consts::LOG10_E); + /// # assert_eq!(val64, std::f64::consts::LOG10_E); + ///``` + const LOG10_E: Self; + + /// The natural log(ln) of 2. + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::LOGE_2; + /// let val64: f64 = Constants::LOGE_2; + /// # assert_eq!(val32, 2.0f32.ln()); + /// # assert_eq!(val64, 2.0f64.ln()); + ///``` + const LOGE_2: Self; + + /// The natural log(ln) of 10. + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::LOGE_10; + /// let val64: f64 = Constants::LOGE_10; + /// # assert_eq!(val32, 10.0f32.ln()); + /// # assert_eq!(val64, 10.0f64.ln()); + ///``` + const LOGE_10: Self; + + /// Two times the value of PI. + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::TWO_PI; + /// let val64: f64 = Constants::TWO_PI; + /// # assert_eq!(val32, std::f32::consts::PI * 2.0f32); + /// # assert_eq!(val64, std::f64::consts::PI * 2.0f64); + ///``` + const TWO_PI: Self; + + /// [PI][1]. The ratio of a circles circumference to its diameter. + /// [1]: https://en.wikipedia.org/wiki/Pi + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::PI; + /// let val64: f64 = Constants::PI; + /// # assert_eq!(val32, std::f32::consts::PI); + /// # assert_eq!(val64, std::f64::consts::PI); + ///``` + const PI: Self; + + /// One half of PI. (PI/2) + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::HALF_PI; + /// let val64: f64 = Constants::HALF_PI; + /// # assert_eq!(val32, std::f32::consts::PI / 2.0f32); + /// # assert_eq!(val64, std::f64::consts::PI / 2.0f64); + ///``` + const HALF_PI: Self; + + /// One third of PI. (PI/3) + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::THIRD_PI; + /// let val64: f64 = Constants::THIRD_PI; + /// # assert_eq!(val32, std::f32::consts::PI / 3.0f32); + /// # assert_eq!(val64, std::f64::consts::PI / 3.0f64); + ///``` + const THIRD_PI: Self; + + /// One forth of PI. (PI/4) + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::QUARTER_PI; + /// let val64: f64 = Constants::QUARTER_PI; + /// # assert_eq!(val32, std::f32::consts::PI / 4.0f32); + /// # assert_eq!(val64, std::f64::consts::PI / 4.0f64); + ///``` + const QUARTER_PI: Self; + + /// One sixth of PI. (PI/6) + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::SIXTH_PI; + /// let val64: f64 = Constants::SIXTH_PI; + /// # assert_eq!(val32, std::f32::consts::PI / 6.0f32); + /// # assert_eq!(val64, std::f64::consts::PI / 6.0f64); + ///``` + const SIXTH_PI: Self; + + /// One eighth of PI. (PI/8) + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::EIGHTH_PI; + /// let val64: f64 = Constants::EIGHTH_PI; + /// # assert_eq!(val32, std::f32::consts::PI / 8.0f32); + /// # assert_eq!(val64, std::f64::consts::PI / 8.0f64); + ///``` + const EIGHTH_PI: Self; + + /// The inverse of PI. (1/PI) + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::INVERSE_PI; + /// let val64: f64 = Constants::INVERSE_PI; + /// # assert_eq!(val32, 1.0f32 / std::f32::consts::PI); + /// # assert_eq!(val64, 1.0f64 / std::f64::consts::PI); + ///``` + const INVERSE_PI: Self; + + /// Two times the inverse of PI. (2/PI) + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::TWO_INVERSE_PI; + /// let val64: f64 = Constants::TWO_INVERSE_PI; + /// # assert_eq!(val32, 2.0f32 / std::f32::consts::PI); + /// # assert_eq!(val64, 2.0f64 / std::f64::consts::PI); + ///``` + const TWO_INVERSE_PI: Self; + + /// Two times the inverse of the square root of PI. (2/sqrt(PI)) + /// + ///``` + /// use sigils::Constants; + /// + /// let val32: f32 = Constants::TWO_INVERSE_SQRT_PI; + /// let val64: f64 = Constants::TWO_INVERSE_SQRT_PI; + /// # assert_eq!(val32, 2.0f32 * (std::f32::consts::PI).sqrt().recip()); + /// # assert_eq!(val64, 2.0f64 * (std::f64::consts::PI).sqrt().recip()); + ///``` + const TWO_INVERSE_SQRT_PI: Self; +} + + +// Implement a macro to simplify defining these constants +// for the two different types, f32 and f64. +macro_rules! constants_trait_impl +{ + ($T: ty, $sqrt2: expr, $sqrt3: expr, $e: expr, + $log2e: expr, $log10e: expr, $loge2: expr, $loge10: expr, + $pi: expr, $sqrtPI: expr) => + { + impl Constants for $T + { + const SQRT_2: $T = $sqrt2; + const SQRT_3: $T = $sqrt3; + const INVERSE_SQRT_2: $T = 1.0 / $sqrt2; + const INVERSE_SQRT_3: $T = 1.0 / $sqrt3; + + const E: $T = $e; + + const LOG2_E: $T = $log2e; + const LOG10_E: $T = $log10e; + const LOGE_2: $T = $loge2; + const LOGE_10: $T = $loge10; + + const TWO_PI: $T = 2.0 * $pi; + const PI: $T = $pi; + const HALF_PI: $T = $pi / 2.0; + const THIRD_PI: $T = $pi / 3.0; + const QUARTER_PI: $T = $pi / 4.0; + const SIXTH_PI: $T = $pi / 6.0; + const EIGHTH_PI: $T = $pi / 8.0; + const INVERSE_PI: $T = 1.0 / $pi; + const TWO_INVERSE_PI: $T = 2.0 / $pi; + const TWO_INVERSE_SQRT_PI: $T = 2.0 / $sqrtPI; + } + } +} + + +// Implement the math Constants. +constants_trait_impl!(f32, f32::consts::SQRT_2, 1.73205080756887729352f32, + f32::consts::E, f32::consts::LOG2_E, + f32::consts::LOG10_E, f32::consts::LN_2, + f32::consts::LN_10, f32::consts::PI, + 1.7724538509055159f32); +constants_trait_impl!(f64, f64::consts::SQRT_2, 1.73205080756887729352f64, + f64::consts::E, f64::consts::LOG2_E, + f64::consts::LOG10_E, f64::consts::LN_2, + f64::consts::LN_10, f64::consts::PI, + 1.7724538509055159f64); diff --git a/src/lib.rs b/src/lib.rs index 909cc3d..bc83066 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,16 +1,28 @@ +//! A mathematical library. +//! License: Proprietary +//! +//! #![feature(zero_one)] #![feature(float_from_str_radix)] +#![feature(float_extras)] +#![feature(associated_consts)] +mod bounded; mod number; mod whole; mod integer; mod real; +mod constants; +pub mod trig; pub mod vector; +pub mod matrix; +pub mod quaternion; -pub use self::vector::Vector; -pub use self::vector::Vector2; -pub use self::vector::Vector3; -pub use self::vector::Vector4; +pub use self::number::Number; +pub use self::whole::Whole; +pub use self::integer::Integer; +pub use self::real::Real; +pub use self::constants::Constants; diff --git a/src/matrix.rs b/src/matrix.rs new file mode 100644 index 0000000..44448f3 --- /dev/null +++ b/src/matrix.rs @@ -0,0 +1 @@ +//! This module defines the 2x2, 3x3, and 4x4 Matrix structures. diff --git a/src/number.rs b/src/number.rs index 7f9c2c2..ce5129f 100644 --- a/src/number.rs +++ b/src/number.rs @@ -1,7 +1,10 @@ use std::cmp::PartialEq; +use std::mem::size_of; use std::num::{Zero, One}; use std::ops::{Add, Sub, Mul, Div, Rem}; +use super::bounded::Bounded; + /// A trait that defines what is required to be considered /// a number. @@ -12,34 +15,751 @@ pub trait Number : Zero + One + Add + Sub + type StrRadixError; /// Create a number from a given string and base radix. + /// + ///``` + /// // Parse the hex value "FF" into an i32. + /// // Hex values have a radix (base) of 16. + /// use sigils::Number; + /// + /// let x: i32 = Number::from_str_radix("FF", 16u32).unwrap(); + /// # assert_eq!(x, 255i32); + ///``` fn from_str_radix(src: &str, radix: u32) -> Result; } - -// Create some macros to ease typing and reading. -/// A macro to make implementing the trait easier for all the -/// base integer types in rust. -macro_rules! int_trait_impl +/// A trait that defines converting something to a Number. +pub trait ToNumber { - ($traitName: ident for $($varType: ty)*) => - ($( - impl Number for $varType - { - type StrRadixError = ::std::num::ParseIntError; + /// Convert this to an u8. + /// None is returned if the conversion is not possible. + fn to_u8(&self) -> Option + { + let option: Option; - fn from_str_radix(src: &str, radix: u32) -> - Result - { - <$varType>::from_str_radix(src, radix) - } + option = self.to_u64(); + match option + { + Some(val) => + { + val.to_u8() } - )*) + + None => + { + None + } + } + } + + /// Convert this to an u16. + /// None is returned if the conversion is not possible. + fn to_u16(&self) -> Option + { + let option: Option; + + option = self.to_u64(); + match option + { + Some(val) => + { + val.to_u16() + } + + None => + { + None + } + } + } + + /// Convert this to an u32. + /// None is returned if the conversion is not possible. + fn to_u32(&self) -> Option + { + let option: Option; + + option = self.to_u64(); + match option + { + Some(val) => + { + val.to_u32() + } + + None => + { + None + } + } + } + + /// Convert this to an u64. + /// None is returned if the conversion is not possible. + fn to_u64(&self) -> Option; + + /// Convert this to an usize. + /// None is returned if the conversion is not possible. + fn to_usize(&self) -> Option + { + let option: Option; + + option = self.to_u64(); + match option + { + Some(val) => + { + val.to_usize() + } + + None => + { + None + } + } + } + + + /// Convert this to an i8. + /// None is returned if the conversion is not possible. + fn to_i8(&self) -> Option + { + let option: Option; + + option = self.to_i64(); + match option + { + Some(val) => + { + val.to_i8() + } + + None => + { + None + } + } + } + + /// Convert this to an i16. + /// None is returned if the conversion is not possible. + fn to_i16(&self) -> Option + { + let option: Option; + + option = self.to_i64(); + match option + { + Some(val) => + { + val.to_i16() + } + + None => + { + None + } + } + } + + /// Convert this to an i32. + /// None is returned if the conversion is not possible. + fn to_i32(&self) -> Option + { + let option: Option; + + option = self.to_i64(); + match option + { + Some(val) => + { + val.to_i32() + } + + None => + { + None + } + } + } + + /// Convert this to an i64. + /// None is returned if the conversion is not possible. + fn to_i64(&self) -> Option; + + /// Convert this to an isize. + /// None is returned if the conversion is not possible. + fn to_isize(&self) -> Option + { + let option: Option; + + option = self.to_i64(); + match option + { + Some(val) => + { + val.to_isize() + } + + None => + { + None + } + } + } + + + /// Convert this to an f32. + /// None is returned if the conversion is not possible. + fn to_f32(&self) -> Option + { + let option: Option; + + option = self.to_f64(); + match option + { + Some(val) => + { + val.to_f32() + } + + None => + { + None + } + } + } + + /// Convert this to an f64. + /// None is returned if the conversion is not possible. + fn to_f64(&self) -> Option + { + let option: Option; + + option = self.to_i64(); + match option + { + Some(val) => + { + val.to_f64() + } + + None => + { + None + } + } + } } -/// A macro to make implementing the trait easier for all the +/// A trait that defines convertung a Number to something else. +pub trait FromNumber : Sized +{ + /// Convert an i8 to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_i8(number: i8) -> Option + { + FromNumber::from_i64(number as i64) + } + + /// Convert an i16 to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_i16(number: i16) -> Option + { + FromNumber::from_i64(number as i64) + } + + /// Convert an i32 to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_i32(number: i32) -> Option + { + FromNumber::from_i64(number as i64) + } + + /// Convert an i64 to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_i64(number: i64) -> Option; + + /// Convert an isize to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_isize(number: isize) -> Option + { + FromNumber::from_i64(number as i64) + } + + + /// Convert an u8 to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_u8(number: u8) -> Option + { + FromNumber::from_u64(number as u64) + } + + /// Convert an u16 to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_u16(number: u16) -> Option + { + FromNumber::from_u64(number as u64) + } + + /// Convert an u32 to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_u32(number: u32) -> Option + { + FromNumber::from_u64(number as u64) + } + + /// Convert an u64 to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_u64(number: u64) -> Option; + + /// Convert an usize to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_usize(number: usize) -> Option + { + FromNumber::from_u64(number as u64) + } + + + /// Convert an f32 to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_f32(number: f32) -> Option + { + FromNumber::from_f64(number as f64) + } + + /// Convert an f64 to an optional value of this type. + /// None is returned if the conversion is not possible. + fn from_f64(number: f64) -> Option + { + FromNumber::from_i64(number as i64) + } +} + + +// Create some macros to ease typing and reading. +macro_rules! convert_int_to_int +{ + ($srcType: ty, $dstType: ty, $val: expr) => + { + { + let num: i64; + let min_value: $dstType; + let max_value: $dstType; + + num = $val as i64; + min_value = Bounded::min_value(); + max_value = Bounded::max_value(); + + if (min_value as i64) <= num && num <= (max_value as i64) + { + Some($val as $dstType) + } + else + { + None + } + } + } +} + +macro_rules! convert_int_to_uint +{ + ($srcType: ty, $dstType: ty, $val: expr) => + { + { + let zero: $srcType; + let max_value: $dstType; + + zero = Zero::zero(); + max_value = Bounded::max_value(); + + if zero <= $val && ($val as u64) <= (max_value as u64) + { + Some($val as $dstType) + } + else + { + None + } + } + } +} + +macro_rules! convert_uint_to_int +{ + ($dstType: ty, $val: expr) => + { + { + let max_value: $dstType; + + max_value = Bounded::max_value(); + if ($val as u64) <= (max_value as u64) + { + Some($val as $dstType) + } + else + { + None + } + } + } +} + +macro_rules! convert_uint_to_uint +{ + ($srcType: ty, $dstType: ty, $val: expr) => + { + if size_of::<$srcType>() <= size_of::<$dstType>() + { + Some($val as $dstType) + } + else + { + let zero: $srcType; + let max_value: $dstType; + + zero = Zero::zero(); + max_value = Bounded::max_value(); + + if zero <= $val && ($val as u64) <= (max_value as u64) + { + Some($val as $dstType) + } + else + { + None + } + } + } +} + +macro_rules! convert_float_to_float +{ + ($srcType: ty, $dstType: ty, $val: expr) => + { + if size_of::<$srcType>() <= size_of::<$dstType>() + { + Some($val as $dstType) + } + else + { + let num: f64; + let min_value: $srcType; + let max_value: $srcType; + + num = $val as f64; + min_value = Bounded::min_value(); + max_value = Bounded::max_value(); + + if (min_value as f64) <= num && num <= (max_value as f64) + { + Some($val as $dstType) + } + else + { + None + } + } + } +} + +macro_rules! int_to_number_impl +{ + ($traitName: ident for $($varType: ty)*) => + ($( + impl $traitName for $varType + { + fn to_u8(&self) -> Option + { + convert_int_to_uint!($varType, u8, *self) + } + + fn to_u16(&self) -> Option + { + convert_int_to_uint!($varType, u16, *self) + } + + fn to_u32(&self) -> Option + { + convert_int_to_uint!($varType, u32, *self) + } + + fn to_u64(&self) -> Option + { + convert_int_to_uint!($varType, u64, *self) + } + + fn to_usize(&self) -> Option + { + convert_int_to_uint!($varType, usize, *self) + } + + + fn to_i8(&self) -> Option + { + convert_int_to_int!($varType, i8, *self) + } + + fn to_i16(&self) -> Option + { + convert_int_to_int!($varType, i16, *self) + } + + fn to_i32(&self) -> Option + { + convert_int_to_int!($varType, i32, *self) + } + + fn to_i64(&self) -> Option + { + convert_int_to_int!($varType, i64, *self) + } + + fn to_isize(&self) -> Option + { + convert_int_to_int!($varType, isize, *self) + } + + + fn to_f32(&self) -> Option + { + Some(*self as f32) + } + + fn to_f64(&self) -> Option + { + Some(*self as f64) + } + } + )*) +} + +macro_rules! uint_to_number_impl +{ + ($traitName: ident for $($varType: ty)*) => + ($( + impl $traitName for $varType + { + fn to_u8(&self) -> Option + { + convert_uint_to_uint!($varType, u8, *self) + } + + fn to_u16(&self) -> Option + { + convert_uint_to_uint!($varType, u16, *self) + } + + fn to_u32(&self) -> Option + { + convert_uint_to_uint!($varType, u32, *self) + } + + fn to_u64(&self) -> Option + { + convert_uint_to_uint!($varType, u64, *self) + } + + fn to_usize(&self) -> Option + { + convert_uint_to_uint!($varType, usize, *self) + } + + + fn to_i8(&self) -> Option + { + convert_uint_to_int!(i8, *self) + } + + fn to_i16(&self) -> Option + { + convert_uint_to_int!(i16, *self) + } + + fn to_i32(&self) -> Option + { + convert_uint_to_int!(i32, *self) + } + + fn to_i64(&self) -> Option + { + convert_uint_to_int!(i64, *self) + } + + fn to_isize(&self) -> Option + { + convert_uint_to_int!(isize, *self) + } + + + fn to_f32(&self) -> Option + { + Some(*self as f32) + } + + fn to_f64(&self) -> Option + { + Some(*self as f64) + } + } + )*) +} + +macro_rules! float_to_number_impl +{ + ($traitName: ident for $($varType: ty)*) => + ($( + impl $traitName for $varType + { + fn to_u8(&self) -> Option + { + Some(*self as u8) + } + + fn to_u16(&self) -> Option + { + Some(*self as u16) + } + + fn to_u32(&self) -> Option + { + Some(*self as u32) + } + + fn to_u64(&self) -> Option + { + Some(*self as u64) + } + + fn to_usize(&self) -> Option + { + Some(*self as usize) + } + + + fn to_i8(&self) -> Option + { + Some(*self as i8) + } + + fn to_i16(&self) -> Option + { + Some(*self as i16) + } + + fn to_i32(&self) -> Option + { + Some(*self as i32) + } + + fn to_i64(&self) -> Option + { + Some(*self as i64) + } + + fn to_isize(&self) -> Option + { + Some(*self as isize) + } + + + fn to_f32(&self) -> Option + { + convert_float_to_float!($varType, f32, *self) + } + + fn to_f64(&self) -> Option + { + convert_float_to_float!($varType, f64, *self) + } + } + )*) +} + +macro_rules! from_number_impl +{ + ($varType: ty, $toTypeFunc: ident) => + { + impl FromNumber for $varType + { + fn from_u8(number: u8) -> Option<$varType> + { + number.$toTypeFunc() + } + + fn from_u16(number: u16) -> Option<$varType> + { + number.$toTypeFunc() + } + + fn from_u32(number: u32) -> Option<$varType> + { + number.$toTypeFunc() + } + + fn from_u64(number: u64) -> Option<$varType> + { + number.$toTypeFunc() + } + + + fn from_i8(number: i8) -> Option<$varType> + { + number.$toTypeFunc() + } + + fn from_i16(number: i16) -> Option<$varType> + { + number.$toTypeFunc() + } + + fn from_i32(number: i32) -> Option<$varType> + { + number.$toTypeFunc() + } + + fn from_i64(number: i64) -> Option<$varType> + { + number.$toTypeFunc() + } + + + fn from_f32(number: f32) -> Option<$varType> + { + number.$toTypeFunc() + } + + fn from_f64(number: f64) -> Option<$varType> + { + number.$toTypeFunc() + } + } + } +} + +/// A macro to make implementing the Number trait easier for all the +/// base integer types in rust. +macro_rules! int_number_trait_impl +{ + ($traitName: ident for $($varType: ty)*) => + ($( + impl $traitName for $varType + { + type StrRadixError = ::std::num::ParseIntError; + + fn from_str_radix(src: &str, radix: u32) -> + Result + { + <$varType>::from_str_radix(src, radix) + } + } + )*) +} + +/// A macro to make implementing the Number trait easier for all the /// base float types in rust. -macro_rules! float_trait_impl +macro_rules! float_number_trait_impl { ($traitName: ident for $($varType: ty)*) => ($( @@ -57,7 +777,30 @@ macro_rules! float_trait_impl } -// Implement the trait for the types that are Numbers. -int_trait_impl!(Number for u8 u16 u32 u64 usize); -int_trait_impl!(Number for i8 i16 i32 i64 isize); -float_trait_impl!(Number for f32 f64); +// Implement the Number trait for the types that are Numbers. +int_number_trait_impl!(Number for u8 u16 u32 u64 usize); +int_number_trait_impl!(Number for i8 i16 i32 i64 isize); +float_number_trait_impl!(Number for f32 f64); + +// Implement the ToNumber and FromNumber traits for +// the types that are Numbers. The FromNumber trait needs +// to be defined after ToNumber since FromNumber uses +// ToNumber definitions. +uint_to_number_impl!(ToNumber for u8 u16 u32 u64 usize); +int_to_number_impl!(ToNumber for i8 i16 i32 i64 isize); +float_to_number_impl!(ToNumber for f32 f64); + +from_number_impl!(u8, to_u8); +from_number_impl!(u16, to_u16); +from_number_impl!(u32, to_u32); +from_number_impl!(u64, to_u64); +from_number_impl!(usize, to_usize); + +from_number_impl!(i8, to_i8); +from_number_impl!(i16, to_i16); +from_number_impl!(i32, to_i32); +from_number_impl!(i64, to_i64); +from_number_impl!(isize, to_isize); + +from_number_impl!(f32, to_f32); +from_number_impl!(f64, to_f64); diff --git a/src/quaternion.rs b/src/quaternion.rs new file mode 100644 index 0000000..33f21ba --- /dev/null +++ b/src/quaternion.rs @@ -0,0 +1,5 @@ +//! This module defines the [Quaternion][1] and +//! [DualQuaternion][2] structures. +//! +//! [1]: https://en.wikipedia.org/wiki/Quaternion +//! [2]: https://en.wikipedia.org/wiki/Dual_quaternion diff --git a/src/real.rs b/src/real.rs index 93ab240..d6eae8a 100644 --- a/src/real.rs +++ b/src/real.rs @@ -1,24 +1,1111 @@ +use std::num::FpCategory; + use super::number::Number; +// TODO: Double check these examples. Most are OK, +// but I wanted to have f32 and f64 examples and +// I'm not sure if all of them work correctly. /// A trait that defines what is required to be considered /// a Real number. [List of types of numbers][1] /// +/// This is meant to have all the similarities between +/// [f32][2] and [f64][3]. Most of the comments and documentation +/// were taken from the [rust-lang std docs][4]. +/// /// [1]: https://en.wikipedia.org/wiki/List_of_types_of_numbers -trait Real : Number +/// [2]: https://doc.rust-lang.org/std/primitive.f32.html +/// [3]: https://doc.rust-lang.org/std/primitive.f64.html +/// [4]: https://doc.rust-lang.org/std/index.html +pub trait Real : Number { + /// Returns the `NaN` value. + /// + /// ``` + /// use sigils::Real; + /// + /// let nan32: f32 = Real::nan(); + /// let nan64: f64 = Real::nan(); + /// + /// # assert!(nan32.is_nan()); + /// # assert!(nan64.is_nan()); + /// ``` + fn nan() -> Self; + + /// Returns the infinite value. + /// + /// ``` + /// use std::{f32, f64}; + /// use sigils::Real; + /// + /// let infinity32: f32 = Real::infinity(); + /// let infinity64: f64 = Real::infinity(); + /// + /// # assert!(infinity32.is_infinite()); + /// # assert!(!infinity32.is_finite()); + /// # assert!(infinity32 > f32::MAX); + /// + /// # assert!(infinity64.is_infinite()); + /// # assert!(!infinity64.is_finite()); + /// # assert!(infinity64 > f64::MAX); + /// ``` + fn infinity() -> Self; + + /// Returns the negative infinite value. + /// + /// ``` + /// use std::{f32, f64}; + /// use sigils::Real; + /// + /// let neg_infinity32: f32 = Real::neg_infinity(); + /// let neg_infinity64: f64 = Real::neg_infinity(); + /// + /// # assert!(neg_infinity32.is_infinite()); + /// # assert!(!neg_infinity32.is_finite()); + /// # assert!(neg_infinity32 < f32::MIN); + /// + /// # assert!(neg_infinity64.is_infinite()); + /// # assert!(!neg_infinity64.is_finite()); + /// # assert!(neg_infinity64 < f64::MIN); + /// ``` + fn neg_infinity() -> Self; + + /// Returns `true` if this value is `NaN` and false otherwise. + /// + /// ``` + /// use std::{f32, f64}; + /// use sigils::Real; + /// + /// let nan32 = f32::NAN; + /// let nan64 = f64::NAN; + /// let val32 = 7.0f32; + /// let val64 = 7.0f64; + /// + /// assert!(nan32.is_nan()); + /// assert!(nan64.is_nan()); + /// assert!(!val32.is_nan()); + /// assert!(!val64.is_nan()); + /// ``` + fn is_nan(self) -> bool; + + /// Returns `true` if this value is positive + /// infinity or negative infinity and false otherwise. + /// + /// ``` + /// use std::{f32, f64}; + /// use sigils::Real; + /// + /// let val32 = 7.0f32; + /// let inf32: f32 = Real::infinity(); + /// let neg_inf32: f32 = Real::neg_infinity(); + /// let nan32: f32 = f32::NAN; + /// + /// let val64 = 7.0f64; + /// let inf64: f64 = Real::infinity(); + /// let neg_inf64: f64 = Real::neg_infinity(); + /// let nan64: f64 = f64::NAN; + /// + /// assert!(!val32.is_infinite()); + /// assert!(!nan32.is_infinite()); + /// assert!(inf32.is_infinite()); + /// assert!(neg_inf32.is_infinite()); + /// + /// assert!(!val64.is_infinite()); + /// assert!(!nan64.is_infinite()); + /// assert!(inf64.is_infinite()); + /// assert!(neg_inf64.is_infinite()); + /// ``` + fn is_infinite(self) -> bool; + + /// Returns `true` if this number is neither infinite nor `NaN`. + /// + /// ``` + /// use std::{f32, f64}; + /// use sigils::Real; + /// + /// let val32 = 7.0f32; + /// let inf32: f32 = Real::infinity(); + /// let neg_inf32: f32 = Real::neg_infinity(); + /// let nan32: f32 = f32::NAN; + /// + /// let val64 = 7.0f64; + /// let inf64: f64 = Real::infinity(); + /// let neg_inf64: f64 = Real::neg_infinity(); + /// let nan64: f64 = f64::NAN; + /// + /// assert!(val32.is_finite()); + /// assert!(!nan32.is_finite()); + /// assert!(!inf32.is_finite()); + /// assert!(!neg_inf32.is_finite()); + /// + /// assert!(val64.is_finite()); + /// assert!(!nan64.is_finite()); + /// assert!(!inf64.is_finite()); + /// assert!(!neg_inf64.is_finite()); + /// ``` + fn is_finite(self) -> bool; + + /// Returns `true` if the number is neither zero, infinite, + /// subnormal, or `NaN`. + /// + /// ``` + /// use std::{f32, f64}; + /// use sigils::Real; + /// + /// let min32 = f32::MIN_POSITIVE; + /// let max32 = f32::MAX; + /// let lower_than_min32 = 1.0e-40_f32; + /// let zero32 = 0.0f32; + /// + /// let min64 = f64::MIN_POSITIVE; + /// let max64 = f64::MAX; + /// let lower_than_min64 = 1.0e-40_f64; + /// let zero64 = 0.0f64; + /// + /// // Values between `0` and `min` are Subnormal. + /// assert!(min32.is_normal()); + /// assert!(max32.is_normal()); + /// assert!(!zero32.is_normal()); + /// assert!(!f32::NAN.is_normal()); + /// assert!(!f32::INFINITY.is_normal()); + /// assert!(!lower_than_min32.is_normal()); + /// + /// assert!(min64.is_normal()); + /// assert!(max64.is_normal()); + /// assert!(!zero64.is_normal()); + /// assert!(!f64::NAN.is_normal()); + /// assert!(!f64::INFINITY.is_normal()); + /// //assert!(!lower_than_min64.is_normal()); + /// ``` + fn is_normal(self) -> bool; + + /// Returns the floating point category of the number. + /// If only one property is going to be tested, it is + /// generally faster to use the specific predicate instead. + /// + /// ``` + /// use std::{f32, f64}; + /// use std::num::FpCategory; + /// use sigils::Real; + /// + /// let num32 = 12.4f32; + /// let inf32 = f32::INFINITY; + /// + /// let num64 = 12.4f64; + /// let inf64 = f64::INFINITY; + /// + /// assert_eq!(num32.classify(), FpCategory::Normal); + /// assert_eq!(inf32.classify(), FpCategory::Infinite); + /// + /// assert_eq!(num64.classify(), FpCategory::Normal); + /// assert_eq!(inf64.classify(), FpCategory::Infinite); + /// ``` + fn classify(self) -> FpCategory; + + // TODO: Fix/check this example. + /// Returns the mantissa, base 2 exponent, and sign as + /// integers, respectively. The original number can be + /// recovered by `sign * mantissa * 2 ^ exponent`. + /// + /// ``` + /// use sigils::Real; + /// + /// let num = 2.0f32; + /// + /// // (8388608, -22, 1) + /// let (mantissa, exponent, sign) = Real::integer_decode(num); + /// let sign_f = sign as f32; + /// let mantissa_f = mantissa as f32; + /// let exponent_f = num.powf(exponent as f32); + /// + /// // 1 * 8388608 * 2^(-22) == 2 + /// let abs_difference = + /// (sign_f * mantissa_f * exponent_f - num).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn integer_decode(self) -> (u64, i16, i8); + + /// Returns the largest integer less than or equal to a number. + /// + /// ``` + /// use sigils::Real; + /// + /// let f_val32 = 3.99f32; + /// let g_val32 = 3.0f32; + /// + /// let f_val64 = 3.99f64; + /// let g_val64 = 3.0f64; + /// + /// assert_eq!(f_val32.floor(), 3.0f32); + /// assert_eq!(g_val32.floor(), 3.0f32); + /// + /// assert_eq!(f_val64.floor(), 3.0f64); + /// assert_eq!(g_val64.floor(), 3.0f64); + /// ``` + fn floor(self) -> Self; + + /// Returns the smallest integer greater than or equal to a number. + /// + /// ``` + /// use sigils::Real; + /// + /// let f_val32 = 3.01f32; + /// let g_val32 = 4.0f32; + /// + /// let f_val64 = 3.01f64; + /// let g_val64 = 4.0f64; + /// + /// assert_eq!(f_val32.ceil(), 4.0f32); + /// assert_eq!(g_val32.ceil(), 4.0f32); + /// + /// assert_eq!(f_val64.ceil(), 4.0f64); + /// assert_eq!(g_val64.ceil(), 4.0f64); + /// ``` + fn ceil(self) -> Self; + + /// Returns the nearest integer to a number. Round + /// half-way cases away from `0.0`. + /// + /// ``` + /// use sigils::Real; + /// + /// let f_val32 = 3.3f32; + /// let g_val32 = -3.3f32; + /// + /// let f_val64 = 3.3f64; + /// let g_val64 = -3.3f64; + /// + /// assert_eq!(f_val32.round(), 3.0f32); + /// assert_eq!(g_val32.round(), -3.0f32); + /// + /// assert_eq!(f_val64.round(), 3.0f64); + /// assert_eq!(g_val64.round(), -3.0f64); + /// ``` + fn round(self) -> Self; + + /// Return the integer part of a number. + /// + /// ``` + /// use sigils::Real; + /// + /// let f_val32 = 3.3f32; + /// let g_val32 = -3.7f32; + /// + /// let f_val64 = 3.3f64; + /// let g_val64 = -3.7f64; + /// + /// assert_eq!(f_val32.trunc(), 3.0f32); + /// assert_eq!(g_val32.trunc(), -3.0f32); + /// + /// assert_eq!(f_val64.trunc(), 3.0f64); + /// assert_eq!(g_val64.trunc(), -3.0f64); + /// ``` + fn trunc(self) -> Self; + + /// Returns the fractional part of a number. + /// + /// ``` + /// use sigils::Real; + /// + /// let x32 = 3.5f32; + /// let y32 = -3.5f32; + /// let abs_difference_x32 = (x32.fract() - 0.5f32).abs(); + /// let abs_difference_y32 = (y32.fract() - (-0.5f32)).abs(); + /// + /// let x64 = 3.5f64; + /// let y64 = -3.5f64; + /// let abs_difference_x64 = (x64.fract() - 0.5f64).abs(); + /// let abs_difference_y64 = (y64.fract() - (-0.5f64)).abs(); + /// + /// assert!(abs_difference_x32 < 1e-10); + /// assert!(abs_difference_y32 < 1e-10); + /// + /// assert!(abs_difference_x64 < 1e-10); + /// assert!(abs_difference_y64 < 1e-10); + /// ``` + fn fract(self) -> Self; + + /// Computes the absolute value of `self`. Returns `Real::nan()` if the + /// number is `NaN`. + /// + /// ``` + /// use std::{f32, f64}; + /// use sigils::Real; + /// + /// let x32 = 3.5f32; + /// let y32 = -3.5f32; + /// let abs_difference_x32 = (x32.abs() - x32).abs(); + /// let abs_difference_y32 = (y32.abs() - (-y32)).abs(); + /// + /// let x64 = 3.5f64; + /// let y64 = -3.5f64; + /// let abs_difference_x64 = (x64.abs() - x64).abs(); + /// let abs_difference_y64 = (y64.abs() - (-y64)).abs(); + /// + /// assert!(abs_difference_x32 < 1e-10); + /// assert!(abs_difference_y32 < 1e-10); + /// assert!(f32::NAN.abs().is_nan()); + /// + /// assert!(abs_difference_x64 < 1e-10); + /// assert!(abs_difference_y64 < 1e-10); + /// assert!(f64::NAN.abs().is_nan()); + /// ``` + fn abs(self) -> Self; + + /// Returns a number that represents the sign of `self`. + /// + /// - `1.0` if the number is positive, `+0.0` or `Real::infinity()` + /// - `-1.0` if the number is negative, `-0.0` or `Real::neg_infinity()` + /// - `Real::nan()` if the number is `Real::nan()` + /// + /// ``` + /// use std::{f32, f64}; + /// use sigils::Real; + /// + /// let val32 = 3.5f32; + /// + /// let val64 = 3.5f64; + /// + /// assert_eq!(val32.signum(), 1.0f32); + /// assert_eq!(f32::NEG_INFINITY.signum(), -1.0f32); + /// assert!(f32::NAN.signum().is_nan()); + /// + /// assert_eq!(val64.signum(), 1.0f64); + /// assert_eq!(f64::NEG_INFINITY.signum(), -1.0f64); + /// assert!(f64::NAN.signum().is_nan()); + /// ``` + fn signum(self) -> Self; + + /// Returns `true` if `self` is positive, including `+0.0` and + /// `Real::infinity()`. + /// + /// ``` + /// use std::{f32, f64}; + /// use sigils::Real; + /// + /// let nan32: f32 = f32::NAN; + /// let f_val32 = 7.0f32; + /// let g_val32 = -7.0f32; + /// + /// let nan64: f64 = f64::NAN; + /// let f_val64 = 7.0f64; + /// let g_val64 = -7.0f64; + /// + /// // Requires both tests to determine if is `NaN` + /// assert!(f_val32.is_sign_positive()); + /// assert!(!g_val32.is_sign_positive()); + /// assert!(!nan32.is_sign_positive() && !nan32.is_sign_negative()); + /// + /// assert!(f_val64.is_sign_positive()); + /// assert!(!g_val64.is_sign_positive()); + /// assert!(!nan64.is_sign_positive() && !nan64.is_sign_negative()); + /// ``` + fn is_sign_positive(self) -> bool; + + /// Returns `true` if `self` is negative, including `-0.0` and + /// `Real::neg_infinity()`. + /// + /// ``` + /// use std::{f32, f64}; + /// use sigils::Real; + /// + /// let nan32: f32 = f32::NAN; + /// let f_val32 = 7.0f32; + /// let g_val32 = -7.0f32; + /// + /// let nan64: f64 = f64::NAN; + /// let f_val64 = 7.0f64; + /// let g_val64 = -7.0f64; + /// + /// // Requires both tests to determine if is `NaN` + /// assert!(!f_val32.is_sign_negative()); + /// assert!(g_val32.is_sign_negative()); + /// assert!(!nan32.is_sign_positive() && !nan32.is_sign_negative()); + /// + /// assert!(!f_val64.is_sign_negative()); + /// assert!(g_val64.is_sign_negative()); + /// assert!(!nan64.is_sign_positive() && !nan64.is_sign_negative()); + /// ``` + fn is_sign_negative(self) -> bool; + + /// Fused multiply-add. Computes `(self * a) + b` with + /// only one rounding error. This produces a more accurate + /// result with better performance than a separate + /// multiplication operation followed by an add. + /// + /// ``` + /// use sigils::Real; + /// + /// let m32 = 10.0f32; + /// let x32 = 4.0f32; + /// let b32 = 60.0f32; + /// let abs_difference32 = + /// (m32.mul_add(x32, b32) - (m32*x32 + b32)).abs(); + /// + /// let m64 = 10.0f64; + /// let x64 = 4.0f64; + /// let b64 = 60.0f64; + /// let abs_difference64 = + /// (m64.mul_add(x64, b64) - (m64*x64 + b64)).abs(); + /// + /// assert!(abs_difference32 < 1e-10); + /// assert!(abs_difference64 < 1e-10); + /// ``` + fn mul_add(self, a: Self, b: Self) -> Self; + + /// Take the reciprocal (inverse) of a number, `1/x`. + /// + /// ``` + /// use sigils::Real; + /// + /// let x32 = 2.0f32; + /// let abs_difference32 = + /// (x32.recip() - (1.0f32/x32)).abs(); + /// + /// let x64 = 2.0f64; + /// let abs_difference64 = + /// (x64.recip() - (1.0f64/x64)).abs(); + /// + /// assert!(abs_difference32 < 1e-10); + /// assert!(abs_difference64 < 1e-10); + /// ``` + fn recip(self) -> Self; + + /// Raise a number to an integer power. + /// + /// Using this function is generally faster than using `powf` + /// + /// ``` + /// use sigils::Real; + /// + /// let x32 = 2.0f32; + /// let abs_difference32 = (x32.powi(2i32) - x32*x32).abs(); + /// + /// let x64 = 2.0f64; + /// let abs_difference64 = (x64.powi(2i32) - x64*x64).abs(); + /// + /// assert!(abs_difference32 < 1e-10); + /// assert!(abs_difference64 < 1e-10); + /// ``` + fn powi(self, n: i32) -> Self; + + /// Raise a number to a floating point power. + /// + /// ``` + /// use sigils::Real; + /// + /// let x32 = 2.0f32; + /// let abs_difference32 = (x32.powf(2.0f32) - x32*x32).abs(); + /// + /// let x64 = 2.0f64; + /// let abs_difference64 = (x64.powf(2.0f64) - x64*x64).abs(); + /// + /// assert!(abs_difference32 < 1e-10); + /// assert!(abs_difference64 < 1e-10); + /// ``` + fn powf(self, n: Self) -> Self; + + /// Take the square root of a number. + /// + /// Returns NaN if `self` is a negative number. + /// + /// ``` + /// use sigils::Real; + /// + /// let positive = 4.0; + /// let negative = -4.0; + /// + /// let abs_difference = (positive.sqrt() - 2.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// assert!(negative.sqrt().is_nan()); + /// ``` + fn sqrt(self) -> Self; + + /// Returns `e^(self)`, (the exponential function). + /// + /// ``` + /// use sigils::Real; + /// + /// let one = 1.0; + /// // e^1 + /// let e = one.exp(); + /// + /// // ln(e) - 1 == 0 + /// let abs_difference = (e.ln() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn exp(self) -> Self; + + /// Returns `2^(self)`. + /// + /// ``` + /// use sigils::Real; + /// + /// let f = 2.0; + /// + /// // 2^2 - 4 == 0 + /// let abs_difference = (f.exp2() - 4.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn exp2(self) -> Self; + + /// Returns the natural logarithm of the number. + /// + /// ``` + /// use sigils::Real; + /// + /// let one = 1.0; + /// // e^1 + /// let e = one.exp(); + /// + /// // ln(e) - 1 == 0 + /// let abs_difference = (e.ln() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn ln(self) -> Self; + + /// Returns the logarithm of the number with respect to an arbitrary base. + /// + /// ``` + /// use sigils::Real; + /// + /// let ten = 10.0; + /// let two = 2.0; + /// + /// // log10(10) - 1 == 0 + /// let abs_difference_10 = (ten.log(10.0) - 1.0).abs(); + /// + /// // log2(2) - 1 == 0 + /// let abs_difference_2 = (two.log(2.0) - 1.0).abs(); + /// + /// assert!(abs_difference_10 < 1e-10); + /// assert!(abs_difference_2 < 1e-10); + /// ``` + fn log(self, base: Self) -> Self; + + /// Returns the base 2 logarithm of the number. + /// + /// ``` + /// use sigils::Real; + /// + /// let two = 2.0; + /// + /// // log2(2) - 1 == 0 + /// let abs_difference = (two.log2() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn log2(self) -> Self; + + /// Returns the base 10 logarithm of the number. + /// + /// ``` + /// use sigils::Real; + /// + /// let ten = 10.0; + /// + /// // log10(10) - 1 == 0 + /// let abs_difference = (ten.log10() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn log10(self) -> Self; + + /// Returns the maximum of the two numbers. + /// + /// ``` + /// use sigils::Real; + /// + /// let x = 1.0; + /// let y = 2.0; + /// + /// assert_eq!(x.max(y), y); + /// ``` + fn max(self, other: Self) -> Self; + + /// Returns the minimum of the two numbers. + /// + /// ``` + /// use sigils::Real; + /// + /// let x = 1.0; + /// let y = 2.0; + /// + /// assert_eq!(x.min(y), x); + /// ``` + fn min(self, other: Self) -> Self; + + /// The positive difference of two numbers. + /// + /// * If `self <= other`: `0:0` + /// * Else: `self - other` + /// + /// ``` + /// use sigils::Real; + /// + /// let x = 3.0; + /// let y = -3.0; + /// + /// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs(); + /// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs(); + /// + /// assert!(abs_difference_x < 1e-10); + /// assert!(abs_difference_y < 1e-10); + /// ``` + fn abs_sub(self, other: Self) -> Self; + + /// Take the cubic root of a number. + /// + /// ``` + /// use sigils::Real; + /// + /// let x = 8.0; + /// + /// // x^(1/3) - 2 == 0 + /// let abs_difference = (x.cbrt() - 2.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn cbrt(self) -> Self; + + /// Computes the sine of a number (in radians). + /// + /// ``` + /// use sigils::Real; + /// use std::f64; + /// + /// let x = f64::consts::PI/2.0; + /// + /// let abs_difference = (x.sin() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn sin(self) -> Self; + + /// Computes the cosine of a number (in radians). + /// + /// ``` + /// use sigils::Real; + /// use std::f64; + /// + /// let x = 2.0*f64::consts::PI; + /// + /// let abs_difference = (x.cos() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn cos(self) -> Self; + + /// Computes the tangent of a number (in radians). + /// + /// ``` + /// use sigils::Real; + /// use std::f64; + /// + /// let x = f64::consts::PI/4.0; + /// let abs_difference = (x.tan() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-14); + /// ``` + fn tan(self) -> Self; + + /// Computes the arcsine of a number. Return value is in radians in + /// the range [-pi/2, pi/2] or NaN if the number is outside the range + /// [-1, 1]. + /// + /// ``` + /// use sigils::Real; + /// use std::f64; + /// + /// let f = f64::consts::PI / 2.0; + /// + /// // asin(sin(pi/2)) + /// let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn asin(self) -> Self; + + /// Computes the arccosine of a number. Return value is in radians in + /// the range [0, pi] or NaN if the number is outside the range + /// [-1, 1]. + /// + /// ``` + /// use sigils::Real; + /// use std::f64; + /// + /// let f = f64::consts::PI / 4.0; + /// + /// // acos(cos(pi/4)) + /// let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn acos(self) -> Self; + + /// Computes the arctangent of a number. Return value is in radians in the + /// range [-pi/2, pi/2]; + /// + /// ``` + /// use sigils::Real; + /// + /// let f = 1.0; + /// + /// // atan(tan(1)) + /// let abs_difference = (f.tan().atan() - 1.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn atan(self) -> Self; + + /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`). + /// + /// * `x = 0`, `y = 0`: `0` + /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]` + /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]` + /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)` + /// + /// ``` + /// use sigils::Real; + /// use std::f64; + /// + /// let pi = f64::consts::PI; + /// // All angles from horizontal right (+x) + /// // 45 deg counter-clockwise + /// let x1 = 3.0; + /// let y1 = -3.0; + /// + /// // 135 deg clockwise + /// let x2 = -3.0; + /// let y2 = 3.0; + /// + /// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs(); + /// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs(); + /// + /// assert!(abs_difference_1 < 1e-10); + /// assert!(abs_difference_2 < 1e-10); + /// ``` + fn atan2(self, other: Self) -> Self; + + /// Simultaneously computes the sine and cosine of the number, `x`. Returns + /// `(sin(x), cos(x))`. + /// + /// ``` + /// use sigils::Real; + /// use std::f64; + /// + /// let x = f64::consts::PI/4.0; + /// let f = x.sin_cos(); + /// + /// let abs_difference_0 = (f.0 - x.sin()).abs(); + /// let abs_difference_1 = (f.1 - x.cos()).abs(); + /// + /// assert!(abs_difference_0 < 1e-10); + /// assert!(abs_difference_0 < 1e-10); + /// ``` + fn sin_cos(self) -> (Self, Self); + + /// Returns `e^(self) - 1` in a way that is accurate even if the + /// number is close to zero. + /// + /// ``` + /// use sigils::Real; + /// + /// let x = 7.0; + /// + /// // e^(ln(7)) - 1 + /// let abs_difference = (x.ln().exp_m1() - 6.0).abs(); + /// + /// assert!(abs_difference < 1e-10); + /// ``` + fn exp_m1(self) -> Self; + + /// Returns `ln(1+n)` (natural logarithm) more accurately than if + /// the operations were performed separately. + /// + /// ``` + /// use sigils::Real; + /// use sigils::Constants; + /// + /// // ln(1 + (e - 1)) == ln(e) == 1 + /// let mut x32: f32 = Constants::E; + /// x32 -= 1.0f32; + /// let abs_difference32 = (x32.ln_1p() - 1.0f32).abs(); + /// + /// let mut x64: f64 = Constants::E; + /// x64 -= 1.0f64; + /// let abs_difference64 = (x64.ln_1p() - 1.0f64).abs(); + /// + /// //assert!(abs_difference32 < 1e-10); + /// assert!(abs_difference64 < 1e-10); + /// ``` + fn ln_1p(self) -> Self; + + /// Hyperbolic sine function. + /// + /// ``` + /// use sigils::Real; + /// use sigils::Constants; + /// + /// let e32: f32 = Constants::E; + /// let x32: f32 = 1.0f32; + /// + /// let f_val32 = x32.sinh(); + /// let g_val32 = (e32*e32 - 1.0f32)/(2.0f32*e32); + /// let abs_difference32 = (f_val32 - g_val32).abs(); + /// + /// let e64: f64 = Constants::E; + /// let x64: f64 = 1.0f64; + /// + /// let f_val64 = x64.sinh(); + /// let g_val64 = (e64*e64 - 1.0f64)/(2.0f64*e64); + /// let abs_difference64 = (f_val64 - g_val64).abs(); + /// + /// // Solving sinh() at 1 gives `(e^2-1)/(2e)` + /// //assert!(abs_difference32 < 1e-10); + /// assert!(abs_difference64 < 1e-10); + /// ``` + fn sinh(self) -> Self; + + /// Hyperbolic cosine function. + /// + /// ``` + /// use sigils::Real; + /// use sigils::Constants; + /// + /// let e32: f32 = Constants::E; + /// let x32: f32 = 1.0f32; + /// let f_val32 = x32.cosh(); + /// let g_val32 = (e32*e32 + 1.0f32)/(2.0f32*e32); + /// let abs_difference32 = (f_val32 - g_val32).abs(); + /// + /// let e64: f64 = Constants::E; + /// let x64: f64 = 1.0f64; + /// let f_val64 = x64.cosh(); + /// let g_val64 = (e64*e64 + 1.0f64)/(2.0f64*e64); + /// let abs_difference64 = (f_val64 - g_val64).abs(); + /// + /// // Solving cosh() at 1 gives this result + /// //assert!(abs_difference32 < 1.0e-10); + /// assert!(abs_difference64 < 1.0e-10); + /// ``` + fn cosh(self) -> Self; + + /// Hyperbolic tangent function. + /// + /// ``` + /// use sigils::Real; + /// use sigils::Constants; + /// + /// let e32: f32 = Constants::E; + /// let x32: f32 = 1.0f32; + /// + /// let f_val32 = x32.tanh(); + /// let g_val32 = (1.0f32 - e32.powi(-2i32))/(1.0f32 + e32.powi(-2i32)); + /// let abs_difference32 = (f_val32 - g_val32).abs(); + /// + /// let e64: f64 = Constants::E; + /// let x64: f64 = 1.0f64; + /// + /// let f_val64 = x64.tanh(); + /// let g_val64 = (1.0f64 - e64.powi(-2i32))/(1.0f64 + e64.powi(-2i32)); + /// let abs_difference64 = (f_val64 - g_val64).abs(); + /// + /// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))` + /// //assert!(abs_difference32 < 1.0e-10); + /// assert!(abs_difference64 < 1.0e-10); + /// ``` + fn tanh(self) -> Self; + + /// Inverse hyperbolic sine function. + /// + /// ``` + /// use sigils::Real; + /// + /// let x = 1.0; + /// let f = x.sinh().asinh(); + /// + /// let abs_difference = (f - x).abs(); + /// + /// assert!(abs_difference < 1.0e-10); + /// ``` + fn asinh(self) -> Self; + + /// Inverse hyperbolic cosine function. + /// + /// ``` + /// use sigils::Real; + /// + /// let x = 1.0; + /// let f = x.cosh().acosh(); + /// + /// let abs_difference = (f - x).abs(); + /// + /// assert!(abs_difference < 1.0e-10); + /// ``` + fn acosh(self) -> Self; + + /// Inverse hyperbolic tangent function. + /// + /// ``` + /// use sigils::Real; + /// use sigils::Constants; + /// + /// let e32: f32 = Constants::E; + /// let f_val32 = e32.tanh().atanh(); + /// let abs_difference32 = (f_val32 - e32).abs(); + /// + /// let e64: f64 = Constants::E; + /// let f_val64 = e64.tanh().atanh(); + /// let abs_difference64 = (f_val64 - e64).abs(); + /// + /// //assert!(abs_difference32 < 1.0e-10); + /// assert!(abs_difference64 < 1.0e-10); + /// ``` + fn atanh(self) -> Self; } // Create a macro to ease typing and reading. +/// +macro_rules! define_self_func +{ + ($varType: ident, $funcName: ident) => + { + fn $funcName(self) -> $varType + { + <$varType>::$funcName(self) + } + } +} + +/// +macro_rules! define_self_bool_func +{ + ($varType: ident, $funcName: ident) => + { + fn $funcName(self) -> bool + { + <$varType>::$funcName(self) + } + } +} + +/// +macro_rules! define_self_other_func +{ + ($varType: ident, $funcName: ident) => + { + fn $funcName(self, other: $varType) -> $varType + { + <$varType>::$funcName(self, other) + } + } +} + /// A macro to make implementing the trait easier for all the /// base float types in rust. macro_rules! real_trait_impl { - ($traitName: ident for $($varType: ty)*) => + ($traitName: ident for $($varType: ident)*) => ($( impl Real for $varType { + fn nan() -> $varType + { + ::std::$varType::NAN + } + + fn infinity() -> $varType + { + ::std::$varType::INFINITY + } + + fn neg_infinity() -> $varType + { + ::std::$varType::NEG_INFINITY + } + + fn classify(self) -> FpCategory + { + <$varType>::classify(self) + } + + fn integer_decode(self) -> (u64, i16, i8) + { + <$varType>::integer_decode(self) + } + + fn mul_add(self, a: $varType, b: $varType) -> $varType + { + <$varType>::mul_add(self, a, b) + } + + fn powi(self, n: i32) -> $varType + { + <$varType>::powi(self, n) + } + + fn powf(self, n: $varType) -> $varType + { + <$varType>::powf(self, n) + } + + fn sin_cos(self) -> ($varType, $varType) + { + <$varType>::sin_cos(self) + } + + define_self_bool_func!($varType, is_nan); + define_self_bool_func!($varType, is_infinite); + define_self_bool_func!($varType, is_finite); + define_self_bool_func!($varType, is_normal); + define_self_bool_func!($varType, is_sign_positive); + define_self_bool_func!($varType, is_sign_negative); + define_self_func!($varType, signum); + + define_self_func!($varType, floor); + define_self_func!($varType, ceil); + define_self_func!($varType, round); + define_self_func!($varType, trunc); + + define_self_func!($varType, fract); + define_self_func!($varType, abs); + define_self_other_func!($varType, abs_sub); + define_self_func!($varType, recip); + define_self_func!($varType, sqrt); + define_self_func!($varType, cbrt); + define_self_func!($varType, exp); + define_self_func!($varType, exp2); + define_self_func!($varType, exp_m1); + define_self_func!($varType, ln_1p); + + define_self_other_func!($varType, min); + define_self_other_func!($varType, max); + + define_self_func!($varType, ln); + define_self_other_func!($varType, log); + define_self_func!($varType, log2); + define_self_func!($varType, log10); + + define_self_func!($varType, cos); + define_self_func!($varType, sin); + define_self_func!($varType, tan); + define_self_func!($varType, acos); + define_self_func!($varType, asin); + define_self_func!($varType, atan); + define_self_func!($varType, cosh); + define_self_func!($varType, sinh); + define_self_func!($varType, tanh); + define_self_func!($varType, acosh); + define_self_func!($varType, asinh); + define_self_func!($varType, atanh); + define_self_other_func!($varType, atan2); } )*) } diff --git a/src/trig.rs b/src/trig.rs new file mode 100644 index 0000000..247d822 --- /dev/null +++ b/src/trig.rs @@ -0,0 +1,26 @@ +//use super::constants::Constants; +use super::real::Real; + + +/* +pub struct Radians where T: Real +{ + pub value: T +} + +pub struct Degrees where T: Real +{ + pub value: T +} +*/ + + +pub fn acos(x: T) -> T where T: Real +{ + x.acos() +} + +pub fn atan2(x: T, y: T) -> T where T: Real +{ + x.atan2(y) +} diff --git a/src/vector.rs b/src/vector.rs index b81c6a2..9bc24fd 100644 --- a/src/vector.rs +++ b/src/vector.rs @@ -1,11 +1,18 @@ +//! This module defines 2, 3, and 4 component [Vector][1] structures. +//! +//! [1]: https://en.wikipedia.org/wiki/Vector_(mathematics_and_physics) use std::num::{Zero, One}; -use std::ops::{Add, Sub, Mul, Div, Rem}; +use std::ops::{Add, Sub, Mul, Div, Rem, Neg}; use super::number::Number; +use super::real::Real; +use super::trig::{acos, atan2}; /// A trait that defines the minimum set of -/// functions a Vector must implement. +/// functions a [Vector][1] must implement. +/// +/// [1]: https://en.wikipedia.org/wiki/Vector_(mathematics_and_physics) pub trait Vector : Clone where T: Number { // Creation functions. @@ -23,26 +30,6 @@ pub trait Vector : Clone where T: Number ///``` fn from_value(val: T) -> Self; - /// Create a zero Vector. All components will be set to zero. - /// - /// ``` - /// // Create a new Vector4 where all - /// // the components are 0. - /// use sigils::vector::*; - /// - /// let vector = Vector4::::zero(); - /// # assert_eq!(vector.x, 0u8); - /// # assert_eq!(vector.y, 0u8); - /// # assert_eq!(vector.z, 0u8); - /// # assert_eq!(vector.w, 0u8); - /// ``` - // TODO: Should Vectors implement the Zero trait - // instead of defining a function for it? - fn zero() -> Self - { - Self::from_value(T::zero()) - } - /// Create an identity Vector. All components will be set to one. /// /// ``` @@ -54,78 +41,75 @@ pub trait Vector : Clone where T: Number /// # assert_eq!(vector.x, 1i32); /// # assert_eq!(vector.y, 1i32); /// ``` - // TODO: Should Vectors implement the One trait - // instead of defining an identity function? fn identity() -> Self { Self::from_value(T::one()) } - // Scalar operations that result in a new Vector. - /// Add a scalar value to this Vector and return a new Vector. + // Scalar operations that change this Vector. + /// Add a scalar value to this Vector. /// /// ``` /// // Create a new Vector2 where all /// // the components are 1. Then add 1 to it. /// use sigils::vector::*; /// - /// let vector = Vector2::::identity(); - /// let vector_two = vector.add_scalar(1i32); - /// # assert_eq!(vector_two.x, 2i32); - /// # assert_eq!(vector_two.y, 2i32); + /// let mut vector = Vector2::::identity(); + /// vector.add_scalar(1i32); + /// # assert_eq!(vector.x, 2i32); + /// # assert_eq!(vector.y, 2i32); /// ``` - fn add_scalar(&self, scalar: T) -> Self; + fn add_scalar(&mut self, scalar: T); - /// Subtract a scalar value from this Vector and return a new Vector. + /// Subtract a scalar value from this Vector. /// /// ``` /// // Create a new Vector4 where all /// // the components are 1. Then subtract 1 from it. /// use sigils::vector::*; /// - /// let vector = Vector4::::identity(); - /// let vector_two = vector.sub_scalar(1.0f64); - /// # assert_eq!(vector_two.x, 0f64); - /// # assert_eq!(vector_two.y, 0f64); - /// # assert_eq!(vector_two.z, 0f64); - /// # assert_eq!(vector_two.w, 0f64); + /// let mut vector = Vector4::::identity(); + /// vector.sub_scalar(1.0f64); + /// # assert_eq!(vector.x, 0f64); + /// # assert_eq!(vector.y, 0f64); + /// # assert_eq!(vector.z, 0f64); + /// # assert_eq!(vector.w, 0f64); /// ``` - fn sub_scalar(&self, scalar: T) -> Self; + fn sub_scalar(&mut self, scalar: T); - /// Multiply this Vector by a scalar value and return a new Vector. + /// Multiply this Vector by a scalar value. /// /// ``` /// // Create a new Vector4 where all /// // the components are 5. Then multiply it by 5. /// use sigils::vector::*; /// - /// let vector = Vector4::::from_value(5f32); - /// let vector_two = vector.mul_scalar(5f32); - /// # assert_eq!(vector_two.x, 25f32); - /// # assert_eq!(vector_two.y, 25f32); - /// # assert_eq!(vector_two.z, 25f32); - /// # assert_eq!(vector_two.w, 25f32); + /// let mut vector = Vector4::::from_value(5f32); + /// vector.mul_scalar(5f32); + /// # assert_eq!(vector.x, 25f32); + /// # assert_eq!(vector.y, 25f32); + /// # assert_eq!(vector.z, 25f32); + /// # assert_eq!(vector.w, 25f32); /// ``` - fn mul_scalar(&self, scalar: T) -> Self; + fn mul_scalar(&mut self, scalar: T); - /// Divide this Vector by a scalar value and return a new Vector. + /// Divide this Vector by a scalar value. /// /// ``` /// // Create a new Vector3 where all /// // the components are 25. Then divide it by 5. /// use sigils::vector::*; /// - /// let vector = Vector3::::from_value(25u8); - /// let vector_two = vector.div_scalar(5u8); - /// # assert_eq!(vector_two.x, 5u8); - /// # assert_eq!(vector_two.y, 5u8); - /// # assert_eq!(vector_two.z, 5u8); + /// let mut vector = Vector3::::from_value(25u8); + /// vector.div_scalar(5u8); + /// # assert_eq!(vector.x, 5u8); + /// # assert_eq!(vector.y, 5u8); + /// # assert_eq!(vector.z, 5u8); /// ``` - fn div_scalar(&self, scalar: T) -> Self; + fn div_scalar(&mut self, scalar: T); - /// Divide this Vector by a scalar value, take the remainder, - /// and return a new Vector. + /// Divide this Vector by a scalar value and store the remainder. /// /// ``` /// // Create a new Vector3 where all @@ -133,79 +117,226 @@ pub trait Vector : Clone where T: Number /// // and take the remainder. /// use sigils::vector::*; /// - /// let vector = Vector3::::from_value(25isize); - /// let vector_two = vector.rem_scalar(7isize); - /// # assert_eq!(vector_two.x, 4isize); - /// # assert_eq!(vector_two.y, 4isize); - /// # assert_eq!(vector_two.z, 4isize); + /// let mut vector = Vector3::::from_value(25isize); + /// vector.rem_scalar(7isize); + /// # assert_eq!(vector.x, 4isize); + /// # assert_eq!(vector.y, 4isize); + /// # assert_eq!(vector.z, 4isize); /// ``` - fn rem_scalar(&self, scalar: T) -> Self; - - - // Vector operations that result in a new Vector. - /// Add a Vector to this Vector and return a new Vector. - fn add_vector(&self, vector: &Self) -> Self; - - /// Subtract a Vector from this Vector and return a new Vector. - fn sub_vector(&self, vector: &Self) -> Self; - - /// Multiply this Vector by a Vector and return a new Vector. - fn mul_vector(&self, vector: &Self) -> Self; - - /// Divide this Vector by a Vector and return a new Vector. - fn div_vector(&self, vector: &Self) -> Self; - - /// Divide this Vector by a Vector, take the remainder, - /// and return a new Vector. - fn rem_vector(&self, vector: &Self) -> Self; - - - // Scalar operations that change this Vector. - /// Add a scalar value to this Vector. - fn add_scalar_self(&mut self, scalar: T); - - /// Subtract a scalar value from this Vector. - fn sub_scalar_self(&mut self, scalar: T); - - /// Multiply this Vector by a scalar value. - fn mul_scalar_self(&mut self, scalar: T); - - /// Divide this Vector by a scalar value. - fn div_scalar_self(&mut self, scalar: T); - - /// Divide this Vector by a scalar value and take the remainder. - fn rem_scalar_self(&mut self, scalar: T); + fn rem_scalar(&mut self, scalar: T); // Vector operations that change this Vector. /// Add a Vector to this Vector. - fn add_vector_self(&mut self, vector: &Self); + /// + /// ``` + /// // Create a new Vector2 where all + /// // the components are 1. Then add + /// // another Vector2, where all the + /// // components are 1, to it. + /// use sigils::vector::*; + /// + /// let mut vector = Vector2::::identity(); + /// let vector_two = Vector2::::identity(); + /// vector.add_vector(&vector_two); + /// # assert_eq!(vector.x, 2i32); + /// # assert_eq!(vector.y, 2i32); + /// ``` + fn add_vector(&mut self, vector: &Self); /// Subtract a Vector from this Vector. - fn sub_vector_self(&mut self, vector: &Self); + /// + /// ``` + /// // Create a new Vector3 where all + /// // the components are 5. Then subtract + /// // a Vector3, where all the + /// // components are 2, from it. + /// use sigils::vector::*; + /// + /// let mut vector = Vector3::::from_value(5i64); + /// let vector_two = Vector3::::from_value(2i64); + /// vector.sub_vector(&vector_two); + /// # assert_eq!(vector.x, 3i64); + /// # assert_eq!(vector.y, 3i64); + /// # assert_eq!(vector.z, 3i64); + /// ``` + fn sub_vector(&mut self, vector: &Self); /// Multiply this Vector by a Vector. - fn mul_vector_self(&mut self, vector: &Self); + /// + /// ``` + /// // Create a new Vector4 where all + /// // the components are 6.5. Then multiply + /// // it by another Vector4, where all the + /// // components are 4.0. + /// use sigils::vector::*; + /// + /// let mut vector = Vector4::::from_value(6.5f32); + /// let vector_two = Vector4::::from_value(4.0f32); + /// vector.mul_vector(&vector_two); + /// # assert_eq!(vector.x, 26.0f32); + /// # assert_eq!(vector.y, 26.0f32); + /// # assert_eq!(vector.z, 26.0f32); + /// # assert_eq!(vector.w, 26.0f32); + /// ``` + fn mul_vector(&mut self, vector: &Self); /// Divide this Vector by a Vector. - fn div_vector_self(&mut self, vector: &Self); + /// + /// ``` + /// // Create a new Vector2 where all + /// // the components are 19. Then + /// // divide it by another Vector2, + /// // where all the components are 2.0. + /// use sigils::vector::*; + /// + /// let mut vector = Vector2::::from_value(19.0f64); + /// let vector_two = Vector2::::from_value(2.0f64); + /// vector.div_vector(&vector_two); + /// # assert_eq!(vector.x, 9.5f64); + /// # assert_eq!(vector.y, 9.5f64); + /// ``` + fn div_vector(&mut self, vector: &Self); - /// Divide this Vector by a Vector and take the remainder. - fn rem_vector_self(&mut self, vector: &Self); + /// Divide this Vector by a Vector and store the remainder. + /// + /// ``` + /// // Create a new Vector3 where all + /// // the components are 22. Then + /// // divide it by another Vector3, + /// // where all the components are 6. + /// use sigils::vector::*; + /// + /// let mut vector = Vector3::::from_value(22usize); + /// let vector_two = Vector3::::from_value(6usize); + /// vector.rem_vector(&vector_two); + /// # assert_eq!(vector.x, 4usize); + /// # assert_eq!(vector.y, 4usize); + /// # assert_eq!(vector.z, 4usize); + /// ``` + fn rem_vector(&mut self, vector: &Self); - // TODO: Look at defining negation // Basic Vector functions. /// Get the sum of all the components of the Vector. + /// + ///``` + /// // Create a new Vector4 where all + /// // the components are 5.125. Then get + /// // the sum of the Vector's components. + /// use sigils::vector::*; + /// + /// let vector: Vector4 = Vector4::::from_value(5.125f32); + /// let sum: f32 = vector.get_sum(); + /// # assert_eq!(sum, 20.5f32); + ///``` fn get_sum(&self) -> T; /// Get the product of all the components of the Vector. + /// + ///``` + /// // Create a new Vector3 where all + /// // the components are 3. Then get + /// // the product of the Vector's components. + /// use sigils::vector::*; + /// + /// let vector: Vector3 = Vector3::::from_value(3isize); + /// let sum: isize = vector.get_product(); + /// # assert_eq!(sum, 27isize); + ///``` fn get_product(&self) -> T; /// Get the dot product between this and another Vector. - fn dot(&self, vector: &Self) -> T + /// + ///``` + /// // Create a two new Vector3 where all + /// // the components are 3. Then get the + /// // dot product of the two Vectors. + /// use sigils::vector::*; + /// + /// let vector: Vector3 = Vector3::::from_value(3i64); + /// let vector_two: Vector3 = Vector3::::from_value(3i64); + /// let dotProduct: i64 = vector.dot(&vector_two); + /// # assert_eq!(dotProduct, 27i64); + ///``` + fn dot(&self, vector: &Self) -> T; +} + +/// Defines the [EuclideanVector][1] trait. +/// +/// [1]: https://en.wikipedia.org/wiki/Euclidean_vector +pub trait EuclideanVector : Vector where T: Real +{ + /// Get the length of the Vector. + fn get_length(&self) -> T { - self.mul_vector(vector).get_sum() + self.dot(self).sqrt() + } + + /// Get the squared length of the Vector. + fn get_length_squared(&self) -> T + { + self.dot(self) + } + + /// Normalizes the Vector by multplying all the + /// components by 1/|V|. + fn normalize(&self) -> Self + { + let mut new_vector: Self; + + new_vector = self.clone(); + new_vector.mul_scalar(self.get_length().recip()); + new_vector + } + + /// Normalizes the Vector by multplying all the + /// components by 1/|V|. + fn normalize_self(&mut self) + { + let length: T; + + length = self.get_length().recip(); + self.mul_scalar(length) + } + + /// Determines if this Vector is perpendicular to another Vector. + fn is_perpendicular_to(&self, vector: &Self) -> bool + { + // TODO: Make this work with a fudge factor since floats + // are tricky. + self.dot(vector) == T::zero() + } + + /// Calculates the angle between this vector and + /// another Vector, in radians. + fn angle(&self, vector: &Self) -> T; + + /// Linearly interpolate the length of this Vector + /// towards the length of another Vector by a given amount. + fn lerp(&self, vector: &Self, amount: T) -> Self + { + let mut temp: Self; + let mut new_vector: Self; + + temp = vector.clone(); + temp.sub_vector(&self); + temp.mul_scalar(amount); + + new_vector = self.clone(); + new_vector.add_vector(&temp); + new_vector + } + + /// Linearly interpolate the length of this Vector + /// towards the length of another Vector by a given amount. + fn lerp_self(&mut self, vector: &Self, amount: T) + { + let mut temp: Self; + + temp = vector.clone(); + temp.mul_scalar(amount); + self.add_vector(&temp); } } @@ -239,6 +370,16 @@ macro_rules! binary_operator_impl ($traitName: ident :: $funcName: ident, $structName: ident {$($field: ident),+}) => { + impl $traitName for $structName where T: Number + { + type Output = $structName; + + fn $funcName(self, scalar: T) -> $structName + { + $structName::new($(self.$field.$funcName(scalar)),+) + } + } + impl<'a, T> $traitName for &'a $structName where T: Number { type Output = $structName; @@ -249,6 +390,59 @@ macro_rules! binary_operator_impl } } + impl<'a, T> $traitName<&'a T> for $structName where T: Number + { + type Output = $structName; + + fn $funcName(self, scalar: &'a T) -> $structName + { + $structName::new($(self.$field.$funcName(*scalar)),+) + } + } + + impl<'a, 'b, T> $traitName<&'b T> for &'a $structName where T: Number + { + type Output = $structName; + + fn $funcName(self, scalar: &'b T) -> $structName + { + $structName::new($(self.$field.$funcName(*scalar)),+) + } + } + + impl<'a, T> $traitName<$structName> for $structName + where T: Number + { + type Output = $structName; + + fn $funcName(self, vector: $structName) -> $structName + { + $structName::new($(self.$field.$funcName(vector.$field)),+) + } + } + + impl<'a, T> $traitName<$structName> for &'a $structName + where T: Number + { + type Output = $structName; + + fn $funcName(self, vector: $structName) -> $structName + { + $structName::new($(self.$field.$funcName(vector.$field)),+) + } + } + + impl<'a, 'b, T> $traitName<&'a $structName> for $structName + where T: Number + { + type Output = $structName; + + fn $funcName(self, vector: &'a $structName) -> $structName + { + $structName::new($(self.$field.$funcName(vector.$field)),+) + } + } + impl<'a, 'b, T> $traitName<&'a $structName> for &'b $structName where T: Number { @@ -268,12 +462,17 @@ macro_rules! define_vector { ($structName: ident <$T: ident> {$($field: ident),+}) => { + // Do not add a where clause here or implementing + // generic traits were the generic is different + // will not work properly. /// This structure was defined with the macro /// define_vector. /// - /// Please excuse the lack of comments. + /// Please excuse the lack of comments and refer + /// to the trait definitions for comments about + /// the implementation. #[derive(PartialEq, Eq, Copy, Clone, Hash)] - pub struct $structName where T: Number + pub struct $structName { $(pub $field: T),+ } @@ -286,6 +485,21 @@ macro_rules! define_vector } } + // Give this vector a negation function when the + // type stored in it is negatable. + impl<$T> $structName<$T> where T: Copy + Neg + { + /// Negate this vector in-place (multiply by -1). + /// + ///``` + /// + ///``` + pub fn negate(&mut self) + { + $(self.$field = -self.$field);+ + } + } + impl Vector for $structName where T: Number { fn from_value(val: T) -> $structName @@ -293,105 +507,53 @@ macro_rules! define_vector $structName {$($field: val),+} } - fn add_scalar(&self, scalar: T) -> $structName - { - self + scalar - } - - fn sub_scalar(&self, scalar: T) -> $structName - { - self - scalar - } - - fn mul_scalar(&self, scalar: T) -> $structName - { - self * scalar - } - - fn div_scalar(&self, scalar: T) -> $structName - { - self / scalar - } - - fn rem_scalar(&self, scalar: T) -> $structName - { - self % scalar - } - - - fn add_vector(&self, vector: &$structName) -> $structName - { - self + vector - } - - fn sub_vector(&self, vector: &$structName) -> $structName - { - self - vector - } - - fn mul_vector(&self, vector: &$structName) -> $structName - { - self * vector - } - - fn div_vector(&self, vector: &$structName) -> $structName - { - self / vector - } - - fn rem_vector(&self, vector: &$structName) -> $structName - { - self % vector - } - - - fn add_scalar_self(&mut self, scalar: T) + fn add_scalar(&mut self, scalar: T) { *self = &*self + scalar; } - fn sub_scalar_self(&mut self, scalar: T) + fn sub_scalar(&mut self, scalar: T) { *self = &*self - scalar; } - fn mul_scalar_self(&mut self, scalar: T) + fn mul_scalar(&mut self, scalar: T) { *self = &*self * scalar; } - fn div_scalar_self(&mut self, scalar: T) + fn div_scalar(&mut self, scalar: T) { *self = &*self / scalar; } - fn rem_scalar_self(&mut self, scalar: T) + fn rem_scalar(&mut self, scalar: T) { *self = &*self % scalar; } - fn add_vector_self(&mut self, vector: &$structName) + fn add_vector(&mut self, vector: &$structName) { *self = &*self + vector; } - fn sub_vector_self(&mut self, vector: &$structName) + fn sub_vector(&mut self, vector: &$structName) { *self = &*self - vector; } - fn mul_vector_self(&mut self, vector: &$structName) + fn mul_vector(&mut self, vector: &$structName) { *self = &*self * vector; } - fn div_vector_self(&mut self, vector: &$structName) + fn div_vector(&mut self, vector: &$structName) { *self = &*self / vector; } - fn rem_vector_self(&mut self, vector: &$structName) + fn rem_vector(&mut self, vector: &$structName) { *self = &*self % vector; } @@ -406,8 +568,42 @@ macro_rules! define_vector { perform_method_on_components!(mul, {$(self.$field),+}) } + + fn dot(&self, vector: &$structName) -> T + { + self.mul(vector).get_sum() + } } + // Implement the Zero and One traits for the Vector. + impl Zero for $structName where T: Number + { + fn zero() -> $structName + { + $structName::from_value(T::zero()) + } + } + + impl One for $structName where T: Number + { + fn one() -> $structName + { + $structName::identity() + } + } + + // Implement the negation operator for the Vector structure. + impl Neg for $structName where T: Neg + { + type Output = $structName; + + fn neg(self) -> $structName + { + $structName:: {$($field: -self.$field),+} + } + } + + // Implement the binary operations for this Vector structure. binary_operator_impl!(Add::add, $structName {$($field),+}); binary_operator_impl!(Sub::sub, $structName {$($field),+}); binary_operator_impl!(Mul::mul, $structName {$($field),+}); @@ -439,10 +635,17 @@ impl Vector2 where T: Number Vector2::new(T::zero(), T::one()) } + /// Calculate the perpendicular dot product. pub fn perpendicular_dot(&self, vector: &Vector2) -> T { (self.x * vector.y) - (self.y * vector.x) } + + /// Adds a z component with the given value to the Vector. + pub fn extend(&self, val: T) -> Vector3 + { + Vector3::new(self.x, self.y, val) + } } impl Vector3 where T: Number @@ -473,6 +676,39 @@ impl Vector3 where T: Number (self.z * vector.x) - (self.x * vector.z), (self.x * vector.y) - (self.y * vector.x)) } + + /// Calculate the cross product between this and another Vector + /// and store it in this Vector. + /// The final result will be a Vector perpendicular to both + /// of the input Vectors. + pub fn cross_self(&mut self, vector: &Vector3) + { + *self = self.cross(&vector); + } + + /// Adds a w component with the given value to the Vector. + pub fn extend(&self, val: T) -> Vector4 + { + Vector4::new(self.x, self.y, self.z, val) + } + + /// Discards the z component of the Vector. + pub fn truncate(&self) -> Vector2 + { + self.truncate_component(2) + } + + /// Discards the component at the given index from the Vector. + pub fn truncate_component(&self, index: isize) -> Vector2 + { + match index + { + 0 => Vector2::new(self.y, self.z), + 1 => Vector2::new(self.x, self.z), + 2 => Vector2::new(self.x, self.y), + _ => panic!("Component index {:?} is out of range.", index) + } + } } impl Vector4 where T: Number @@ -500,4 +736,51 @@ impl Vector4 where T: Number { Vector4::new(T::zero(), T::zero(), T::zero(), T::one()) } + + /// Discards the w component of the Vector. + pub fn truncate(&self) -> Vector3 + { + self.truncate_component(3) + } + + /// Discards the component at the given index from the Vector. + pub fn truncate_component(&self, index: isize) -> Vector3 + { + match index + { + 0 => Vector3::new(self.y, self.z, self.w), + 1 => Vector3::new(self.x, self.z, self.w), + 2 => Vector3::new(self.x, self.y, self.w), + 3 => Vector3::new(self.x, self.y, self.z), + _ => panic!("Component index {:?} is out of range.", index) + } + } +} + +// Implement the angle specific portion of the EuclideanVector. +impl EuclideanVector for Vector2 where T: Real +{ + fn angle(&self, vector: &Vector2) -> T + { + //unimplemented!(); + atan2(self.perpendicular_dot(vector), self.dot(vector)) + } +} + +impl EuclideanVector for Vector3 where T: Real +{ + fn angle(&self, vector: &Vector3) -> T + { + //unimplemented!(); + atan2(self.cross(vector).get_length(), self.dot(vector)) + } +} + +impl EuclideanVector for Vector4 where T: Real +{ + fn angle(&self, vector: &Vector4) -> T + { + //unimplemented!(); + acos(self.dot(vector) / (self.get_length() * vector.get_length())) + } } diff --git a/tests/constants.rs b/tests/constants.rs new file mode 100644 index 0000000..374e351 --- /dev/null +++ b/tests/constants.rs @@ -0,0 +1,97 @@ +extern crate sigils; + +use std::{f32, f64}; +use sigils::Constants; + + +#[test] +fn constant_check_f32() +{ + let val: f32 = Constants::SQRT_2; + assert_eq!(val, f32::consts::SQRT_2); + let val: f32 = Constants::SQRT_3; + assert_eq!(val, 1.73205080756887729352f32); + let val: f32 = Constants::INVERSE_SQRT_2; + assert_eq!(val, 1.0f32 / f32::consts::SQRT_2); + let val: f32 = Constants::INVERSE_SQRT_3; + assert_eq!(val, 1.0f32 / 1.73205080756887729352f32); + + let val: f32 = Constants::E; + assert_eq!(val, f32::consts::E); + + let val: f32 = Constants::LOG2_E; + assert_eq!(val, f32::consts::LOG2_E); + let val: f32 = Constants::LOG10_E; + assert_eq!(val, f32::consts::LOG10_E); + let val: f32 = Constants::LOGE_2; + assert_eq!(val, 2f32.ln()); + let val: f32 = Constants::LOGE_10; + assert_eq!(val, 10f32.ln()); + + let val: f32 = Constants::TWO_PI; + assert_eq!(val, 2f32 * f32::consts::PI); + let val: f32 = Constants::PI; + assert_eq!(val, f32::consts::PI); + let val: f32 = Constants::HALF_PI; + assert_eq!(val, f32::consts::PI / 2f32); + let val: f32 = Constants::THIRD_PI; + assert_eq!(val, f32::consts::PI / 3f32); + let val: f32 = Constants::QUARTER_PI; + assert_eq!(val, f32::consts::PI / 4f32); + let val: f32 = Constants::SIXTH_PI; + assert_eq!(val, f32::consts::PI / 6f32); + let val: f32 = Constants::EIGHTH_PI; + assert_eq!(val, f32::consts::PI / 8f32); + let val: f32 = Constants::INVERSE_PI; + assert_eq!(val, 1.0f32 / f32::consts::PI); + let val: f32 = Constants::TWO_INVERSE_PI; + assert_eq!(val, 2.0f32 / f32::consts::PI); + let val: f32 = Constants::TWO_INVERSE_SQRT_PI; + assert_eq!(val, 2.0f32 / (f32::consts::PI).sqrt()); +} + +#[test] +fn constant_check_f64() +{ + let val: f64 = Constants::SQRT_2; + assert_eq!(val, f64::consts::SQRT_2); + let val: f64 = Constants::SQRT_3; + assert_eq!(val, 1.73205080756887729352f64); + let val: f64 = Constants::INVERSE_SQRT_2; + assert_eq!(val, 1.0f64 / f64::consts::SQRT_2); + let val: f64 = Constants::INVERSE_SQRT_3; + assert_eq!(val, 1.0f64 / 1.73205080756887729352f64); + + let val: f64 = Constants::E; + assert_eq!(val, f64::consts::E); + + let val: f64 = Constants::LOG2_E; + assert_eq!(val, f64::consts::LOG2_E); + let val: f64 = Constants::LOG10_E; + assert_eq!(val, f64::consts::LOG10_E); + let val: f64 = Constants::LOGE_2; + assert_eq!(val, 2f64.ln()); + let val: f64 = Constants::LOGE_10; + assert_eq!(val, 10f64.ln()); + + let val: f64 = Constants::TWO_PI; + assert_eq!(val, 2f64 * f64::consts::PI); + let val: f64 = Constants::PI; + assert_eq!(val, f64::consts::PI); + let val: f64 = Constants::HALF_PI; + assert_eq!(val, f64::consts::PI / 2f64); + let val: f64 = Constants::THIRD_PI; + assert_eq!(val, f64::consts::PI / 3f64); + let val: f64 = Constants::QUARTER_PI; + assert_eq!(val, f64::consts::PI / 4f64); + let val: f64 = Constants::SIXTH_PI; + assert_eq!(val, f64::consts::PI / 6f64); + let val: f64 = Constants::EIGHTH_PI; + assert_eq!(val, f64::consts::PI / 8f64); + let val: f64 = Constants::INVERSE_PI; + assert_eq!(val, 1.0f64 / f64::consts::PI); + let val: f64 = Constants::TWO_INVERSE_PI; + assert_eq!(val, 2.0f64 / f64::consts::PI); + let val: f64 = Constants::TWO_INVERSE_SQRT_PI; + assert_eq!(val, 2.0f64 / (f64::consts::PI).sqrt()); +} diff --git a/tests/lib.rs b/tests/lib.rs index 253aac6..36b1ab2 100644 --- a/tests/lib.rs +++ b/tests/lib.rs @@ -1,3 +1,5 @@ extern crate sigils; + +mod constants; mod vector; diff --git a/tests/vector.rs b/tests/vector.rs index 9ef7487..5ff6375 100644 --- a/tests/vector.rs +++ b/tests/vector.rs @@ -1,5 +1,6 @@ extern crate sigils; +use std::ops::{Add, Sub, Mul, Div, Rem}; use sigils::vector::*; @@ -10,3 +11,348 @@ fn vector_creation() assert_eq!(v.x, 1.0f32); } + +#[test] +fn vector_add() +{ + let v: Vector3 = Vector3::::from_value(1.0f32); + + let v_two: Vector3 = Vector3::::from_value(4.0f32); + let scalar: f32 = 4.0f32; + + let v_three = v.add(&v_two); + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v.add(v_two); + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v + &v_two; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v + v_two; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = &v + &v_two; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = &v + v_two; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = &v + 4.0f32; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v + 4.0f32; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = &v + scalar; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v + scalar; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = &v + &scalar; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v + &scalar; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); +} + +#[test] +fn vector_sub() +{ + let v: Vector3 = Vector3::::from_value(9.0f32); + + let v_two: Vector3 = Vector3::::from_value(4.0f32); + let scalar: f32 = 4.0f32; + + let v_three = v.sub(&v_two); + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v.sub(v_two); + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v - &v_two; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v - v_two; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = &v - &v_two; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = &v - v_two; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = &v - 4.0f32; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v - 4.0f32; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = &v - scalar; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v - scalar; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = &v - &scalar; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); + + let v_three = v - &scalar; + assert_eq!(v_three.x, 5.0f32); + assert_eq!(v_three.y, 5.0f32); + assert_eq!(v_three.z, 5.0f32); +} + +#[test] +fn vector_mul() +{ + let v: Vector3 = Vector3::::from_value(3.0f32); + + let v_two: Vector3 = Vector3::::from_value(5.0f32); + let scalar: f32 = 5.0f32; + + let v_three = v.mul(&v_two); + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = v.mul(v_two); + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = v * &v_two; + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = v * v_two; + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = &v * &v_two; + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = &v * v_two; + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = &v * 5.0f32; + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = v * 5.0f32; + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = &v * scalar; + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = v * scalar; + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = &v * &scalar; + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); + + let v_three = v * &scalar; + assert_eq!(v_three.x, 15.0f32); + assert_eq!(v_three.y, 15.0f32); + assert_eq!(v_three.z, 15.0f32); +} + +#[test] +fn vector_div() +{ + let v: Vector3 = Vector3::::from_value(15.0f32); + + let v_two: Vector3 = Vector3::::from_value(5.0f32); + let scalar: f32 = 5.0f32; + + let v_three = v.div(&v_two); + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v.div(v_two); + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v / &v_two; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v / v_two; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = &v / &v_two; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = &v / v_two; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = &v / 5.0f32; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v / 5.0f32; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = &v / scalar; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v / scalar; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = &v / &scalar; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v / &scalar; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); +} + +#[test] +fn vector_rem() +{ + let v: Vector3 = Vector3::::from_value(15.0f32); + + let v_two: Vector3 = Vector3::::from_value(6.0f32); + let scalar: f32 = 6.0f32; + + let v_three = v.rem(&v_two); + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v.rem(v_two); + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v % &v_two; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v % v_two; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = &v % &v_two; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = &v % v_two; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = &v % 6.0f32; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v % 6.0f32; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = &v % scalar; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v % scalar; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = &v % &scalar; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); + + let v_three = v % &scalar; + assert_eq!(v_three.x, 3.0f32); + assert_eq!(v_three.y, 3.0f32); + assert_eq!(v_three.z, 3.0f32); +}