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<Output=Self> + Sub<Output=Self> +
    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<Self, Self::StrRadixError>;
 }
 
-
-// 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<u8>
+   {
+      let option: Option<u64>;
 
-            fn from_str_radix(src: &str, radix: u32) ->
-               Result<Self, ::std::num::ParseIntError>
-            {
-               <$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<u16>
+   {
+      let option: Option<u64>;
+
+      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<u32>
+   {
+      let option: Option<u64>;
+
+      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<u64>;
+
+   /// Convert this to an usize.
+   /// None is returned if the conversion is not possible.
+   fn to_usize(&self) -> Option<usize>
+   {
+      let option: Option<u64>;
+
+      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<i8>
+   {
+      let option: Option<i64>;
+
+      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<i16>
+   {
+      let option: Option<i64>;
+
+      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<i32>
+   {
+      let option: Option<i64>;
+
+      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<i64>;
+
+   /// Convert this to an isize.
+   /// None is returned if the conversion is not possible.
+   fn to_isize(&self) -> Option<isize>
+   {
+      let option: Option<i64>;
+
+      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<f32>
+   {
+      let option: Option<f64>;
+
+      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<f64>
+   {
+      let option: Option<i64>;
+
+      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<Self>
+   {
+      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<Self>
+   {
+      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<Self>
+   {
+      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<Self>;
+
+   /// 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<Self>
+   {
+      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<Self>
+   {
+      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<Self>
+   {
+      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<Self>
+   {
+      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<Self>;
+
+   /// 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<Self>
+   {
+      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<Self>
+   {
+      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<Self>
+   {
+      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<u8>
+         {
+            convert_int_to_uint!($varType, u8, *self)
+         }
+
+         fn to_u16(&self) -> Option<u16>
+         {
+            convert_int_to_uint!($varType, u16, *self)
+         }
+
+         fn to_u32(&self) -> Option<u32>
+         {
+            convert_int_to_uint!($varType, u32, *self)
+         }
+
+         fn to_u64(&self) -> Option<u64>
+         {
+            convert_int_to_uint!($varType, u64, *self)
+         }
+
+         fn to_usize(&self) -> Option<usize>
+         {
+            convert_int_to_uint!($varType, usize, *self)
+         }
+
+
+         fn to_i8(&self) -> Option<i8>
+         {
+            convert_int_to_int!($varType, i8, *self)
+         }
+
+         fn to_i16(&self) -> Option<i16>
+         {
+            convert_int_to_int!($varType, i16, *self)
+         }
+
+         fn to_i32(&self) -> Option<i32>
+         {
+            convert_int_to_int!($varType, i32, *self)
+         }
+
+         fn to_i64(&self) -> Option<i64>
+         {
+            convert_int_to_int!($varType, i64, *self)
+         }
+
+         fn to_isize(&self) -> Option<isize>
+         {
+            convert_int_to_int!($varType, isize, *self)
+         }
+
+
+         fn to_f32(&self) -> Option<f32>
+         {
+            Some(*self as f32)
+         }
+
+         fn to_f64(&self) -> Option<f64>
+         {
+            Some(*self as f64)
+         }
+      }
+   )*)
+}
+
+macro_rules! uint_to_number_impl
+{
+   ($traitName: ident for $($varType: ty)*) =>
+   ($(
+      impl $traitName for $varType
+      {
+         fn to_u8(&self) -> Option<u8>
+         {
+            convert_uint_to_uint!($varType, u8, *self)
+         }
+
+         fn to_u16(&self) -> Option<u16>
+         {
+            convert_uint_to_uint!($varType, u16, *self)
+         }
+
+         fn to_u32(&self) -> Option<u32>
+         {
+            convert_uint_to_uint!($varType, u32, *self)
+         }
+
+         fn to_u64(&self) -> Option<u64>
+         {
+            convert_uint_to_uint!($varType, u64, *self)
+         }
+
+         fn to_usize(&self) -> Option<usize>
+         {
+            convert_uint_to_uint!($varType, usize, *self)
+         }
+
+
+         fn to_i8(&self) -> Option<i8>
+         {
+            convert_uint_to_int!(i8, *self)
+         }
+
+         fn to_i16(&self) -> Option<i16>
+         {
+            convert_uint_to_int!(i16, *self)
+         }
+
+         fn to_i32(&self) -> Option<i32>
+         {
+            convert_uint_to_int!(i32, *self)
+         }
+
+         fn to_i64(&self) -> Option<i64>
+         {
+            convert_uint_to_int!(i64, *self)
+         }
+
+         fn to_isize(&self) -> Option<isize>
+         {
+            convert_uint_to_int!(isize, *self)
+         }
+
+
+         fn to_f32(&self) -> Option<f32>
+         {
+            Some(*self as f32)
+         }
+
+         fn to_f64(&self) -> Option<f64>
+         {
+            Some(*self as f64)
+         }
+      }
+   )*)
+}
+
+macro_rules! float_to_number_impl
+{
+   ($traitName: ident for $($varType: ty)*) =>
+   ($(
+      impl $traitName for $varType
+      {
+         fn to_u8(&self) -> Option<u8>
+         {
+            Some(*self as u8)
+         }
+
+         fn to_u16(&self) -> Option<u16>
+         {
+            Some(*self as u16)
+         }
+
+         fn to_u32(&self) -> Option<u32>
+         {
+            Some(*self as u32)
+         }
+
+         fn to_u64(&self) -> Option<u64>
+         {
+            Some(*self as u64)
+         }
+
+         fn to_usize(&self) -> Option<usize>
+         {
+            Some(*self as usize)
+         }
+
+
+         fn to_i8(&self) -> Option<i8>
+         {
+            Some(*self as i8)
+         }
+
+         fn to_i16(&self) -> Option<i16>
+         {
+            Some(*self as i16)
+         }
+
+         fn to_i32(&self) -> Option<i32>
+         {
+            Some(*self as i32)
+         }
+
+         fn to_i64(&self) -> Option<i64>
+         {
+            Some(*self as i64)
+         }
+
+         fn to_isize(&self) -> Option<isize>
+         {
+            Some(*self as isize)
+         }
+
+
+         fn to_f32(&self) -> Option<f32>
+         {
+            convert_float_to_float!($varType, f32, *self)
+         }
+
+         fn to_f64(&self) -> Option<f64>
+         {
+            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<Self, ::std::num::ParseIntError>
+         {
+            <$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<T> where T: Real
+{
+   pub value: T
+}
+
+pub struct Degrees<T> where T: Real
+{
+   pub value: T
+}
+*/
+
+
+pub fn acos<T>(x: T) -> T where T: Real
+{
+   x.acos()
+}
+
+pub fn atan2<T>(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<T> : Clone where T: Number
 {
    // Creation functions.
@@ -23,26 +30,6 @@ pub trait Vector<T> : 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<u8> where all
-   /// // the components are 0.
-   /// use sigils::vector::*;
-   ///
-   /// let vector = Vector4::<u8>::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<T> : 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<i32> where all
    /// // the components are 1. Then add 1 to it.
    /// use sigils::vector::*;
    ///
-   /// let vector = Vector2::<i32>::identity();
-   /// let vector_two = vector.add_scalar(1i32);
-   /// # assert_eq!(vector_two.x, 2i32);
-   /// # assert_eq!(vector_two.y, 2i32);
+   /// let mut vector = Vector2::<i32>::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<f64> where all
    /// // the components are 1. Then subtract 1 from it.
    /// use sigils::vector::*;
    ///
-   /// let vector = Vector4::<f64>::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::<f64>::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<f64> where all
    /// // the components are 5. Then multiply it by 5.
    /// use sigils::vector::*;
    ///
-   /// let vector = Vector4::<f32>::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::<f32>::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<u8> where all
    /// // the components are 25. Then divide it by 5.
    /// use sigils::vector::*;
    ///
-   /// let vector = Vector3::<u8>::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::<u8>::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<isize> where all
@@ -133,79 +117,226 @@ pub trait Vector<T> : Clone where T: Number
    /// // and take the remainder.
    /// use sigils::vector::*;
    ///
-   /// let vector = Vector3::<isize>::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::<isize>::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<i32> where all
+   /// // the components are 1. Then add
+   /// // another Vector2<i32>, where all the
+   /// // components are 1, to it.
+   /// use sigils::vector::*;
+   ///
+   /// let mut vector = Vector2::<i32>::identity();
+   /// let vector_two = Vector2::<i32>::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<i64> where all
+   /// // the components are 5. Then subtract
+   /// // a Vector3<i64>, where all the
+   /// // components are 2, from it.
+   /// use sigils::vector::*;
+   ///
+   /// let mut vector = Vector3::<i64>::from_value(5i64);
+   /// let vector_two = Vector3::<i64>::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<f32> where all
+   /// // the components are 6.5. Then multiply
+   /// // it by another Vector4<f32>, where all the
+   /// // components are 4.0.
+   /// use sigils::vector::*;
+   ///
+   /// let mut vector = Vector4::<f32>::from_value(6.5f32);
+   /// let vector_two = Vector4::<f32>::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<f64> where all
+   /// // the components are 19. Then
+   /// // divide it by another Vector2<f64>,
+   /// // where all the components are 2.0.
+   /// use sigils::vector::*;
+   ///
+   /// let mut vector = Vector2::<f64>::from_value(19.0f64);
+   /// let vector_two = Vector2::<f64>::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<usize> where all
+   /// // the components are 22. Then
+   /// // divide it by another Vector3<usize>,
+   /// // where all the components are 6.
+   /// use sigils::vector::*;
+   ///
+   /// let mut vector = Vector3::<usize>::from_value(22usize);
+   /// let vector_two = Vector3::<usize>::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<f32> where all
+   /// // the components are 5.125. Then get
+   /// // the sum of the Vector's components.
+   /// use sigils::vector::*;
+   ///
+   /// let vector: Vector4<f32> = Vector4::<f32>::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<isize> where all
+   /// // the components are 3. Then get
+   /// // the product of the Vector's components.
+   /// use sigils::vector::*;
+   ///
+   /// let vector: Vector3<isize> = Vector3::<isize>::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<i64> where all
+   /// // the components are 3. Then get the
+   /// // dot product of the two Vectors.
+   /// use sigils::vector::*;
+   ///
+   /// let vector: Vector3<i64> = Vector3::<i64>::from_value(3i64);
+   /// let vector_two: Vector3<i64> = Vector3::<i64>::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<T> : Vector<T> 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<T> $traitName<T> for $structName<T> where T: Number
+      {
+         type Output = $structName<T>;
+
+         fn $funcName(self, scalar: T) -> $structName<T>
+         {
+            $structName::new($(self.$field.$funcName(scalar)),+)
+         }
+      }
+
       impl<'a, T> $traitName<T> for &'a $structName<T> where T: Number
       {
          type Output = $structName<T>;
@@ -249,6 +390,59 @@ macro_rules! binary_operator_impl
          }
       }
 
+      impl<'a, T> $traitName<&'a T> for $structName<T> where T: Number
+      {
+         type Output = $structName<T>;
+
+         fn $funcName(self, scalar: &'a T) -> $structName<T>
+         {
+            $structName::new($(self.$field.$funcName(*scalar)),+)
+         }
+      }
+
+      impl<'a, 'b, T> $traitName<&'b T> for &'a $structName<T> where T: Number
+      {
+         type Output = $structName<T>;
+
+         fn $funcName(self, scalar: &'b T) -> $structName<T>
+         {
+            $structName::new($(self.$field.$funcName(*scalar)),+)
+         }
+      }
+
+      impl<'a, T> $traitName<$structName<T>> for $structName<T>
+         where T: Number
+      {
+         type Output = $structName<T>;
+
+         fn $funcName(self, vector: $structName<T>) -> $structName<T>
+         {
+            $structName::new($(self.$field.$funcName(vector.$field)),+)
+         }
+      }
+
+      impl<'a, T> $traitName<$structName<T>> for &'a $structName<T>
+         where T: Number
+      {
+         type Output = $structName<T>;
+
+         fn $funcName(self, vector: $structName<T>) -> $structName<T>
+         {
+            $structName::new($(self.$field.$funcName(vector.$field)),+)
+         }
+      }
+
+      impl<'a, 'b, T> $traitName<&'a $structName<T>> for $structName<T>
+         where T: Number
+      {
+         type Output = $structName<T>;
+
+         fn $funcName(self, vector: &'a $structName<T>) -> $structName<T>
+         {
+            $structName::new($(self.$field.$funcName(vector.$field)),+)
+         }
+      }
+
       impl<'a, 'b, T> $traitName<&'a $structName<T>> for &'b $structName<T>
          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<T> where T: Number
+      pub struct $structName<T>
       {
          $(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<Output = $T>
+      {
+         /// Negate this vector in-place (multiply by -1).
+         ///
+         ///```
+         ///
+         ///```
+         pub fn negate(&mut self)
+         {
+            $(self.$field = -self.$field);+
+         }
+      }
+
       impl<T> Vector<T> for $structName<T> where T: Number
       {
          fn from_value(val: T) -> $structName<T>
@@ -293,105 +507,53 @@ macro_rules! define_vector
             $structName {$($field: val),+}
          }
 
-         fn add_scalar(&self, scalar: T) -> $structName<T>
-         {
-            self + scalar
-         }
-
-         fn sub_scalar(&self, scalar: T) -> $structName<T>
-         {
-            self - scalar
-         }
-
-         fn mul_scalar(&self, scalar: T) -> $structName<T>
-         {
-            self * scalar
-         }
-
-         fn div_scalar(&self, scalar: T) -> $structName<T>
-         {
-            self / scalar
-         }
-
-         fn rem_scalar(&self, scalar: T) -> $structName<T>
-         {
-            self % scalar
-         }
-
-
-         fn add_vector(&self, vector: &$structName<T>) -> $structName<T>
-         {
-            self + vector
-         }
-
-         fn sub_vector(&self, vector: &$structName<T>) -> $structName<T>
-         {
-            self - vector
-         }
-
-         fn mul_vector(&self, vector: &$structName<T>) -> $structName<T>
-         {
-            self * vector
-         }
-
-         fn div_vector(&self, vector: &$structName<T>) -> $structName<T>
-         {
-            self / vector
-         }
-
-         fn rem_vector(&self, vector: &$structName<T>) -> $structName<T>
-         {
-            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<T>)
+         fn add_vector(&mut self, vector: &$structName<T>)
          {
             *self = &*self + vector;
          }
 
-         fn sub_vector_self(&mut self, vector: &$structName<T>)
+         fn sub_vector(&mut self, vector: &$structName<T>)
          {
             *self = &*self - vector;
          }
 
-         fn mul_vector_self(&mut self, vector: &$structName<T>)
+         fn mul_vector(&mut self, vector: &$structName<T>)
          {
             *self = &*self * vector;
          }
 
-         fn div_vector_self(&mut self, vector: &$structName<T>)
+         fn div_vector(&mut self, vector: &$structName<T>)
          {
             *self = &*self / vector;
          }
 
-         fn rem_vector_self(&mut self, vector: &$structName<T>)
+         fn rem_vector(&mut self, vector: &$structName<T>)
          {
             *self = &*self % vector;
          }
@@ -406,8 +568,42 @@ macro_rules! define_vector
          {
             perform_method_on_components!(mul, {$(self.$field),+})
          }
+
+         fn dot(&self, vector: &$structName<T>) -> T
+         {
+            self.mul(vector).get_sum()
+         }
       }
 
+      // Implement the Zero and One traits for the Vector.
+      impl<T> Zero for $structName<T> where T: Number
+      {
+         fn zero() -> $structName<T>
+         {
+            $structName::from_value(T::zero())
+         }
+      }
+
+      impl<T> One for $structName<T> where T: Number
+      {
+         fn one() -> $structName<T>
+         {
+            $structName::identity()
+         }
+      }
+
+      // Implement the negation operator for the Vector structure.
+      impl<T> Neg for $structName<T> where T: Neg<Output = T>
+      {
+         type Output = $structName<T>;
+
+         fn neg(self) -> $structName<T>
+         {
+            $structName::<T> {$($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<T> Vector2<T> where T: Number
       Vector2::new(T::zero(), T::one())
    }
 
+   /// Calculate the perpendicular dot product.
    pub fn perpendicular_dot(&self, vector: &Vector2<T>) -> 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<T>
+   {
+      Vector3::new(self.x, self.y, val)
+   }
 }
 
 impl<T> Vector3<T> where T: Number
@@ -473,6 +676,39 @@ impl<T> Vector3<T> 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<T>)
+   {
+      *self = self.cross(&vector);
+   }
+
+   /// Adds a w component with the given value to the Vector.
+   pub fn extend(&self, val: T) -> Vector4<T>
+   {
+      Vector4::new(self.x, self.y, self.z, val)
+   }
+
+   /// Discards the z component of the Vector.
+   pub fn truncate(&self) -> Vector2<T>
+   {
+      self.truncate_component(2)
+   }
+
+   /// Discards the component at the given index from the Vector.
+   pub fn truncate_component(&self, index: isize) -> Vector2<T>
+   {
+      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<T> Vector4<T> where T: Number
@@ -500,4 +736,51 @@ impl<T> Vector4<T> 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<T>
+   {
+      self.truncate_component(3)
+   }
+
+   /// Discards the component at the given index from the Vector.
+   pub fn truncate_component(&self, index: isize) -> Vector3<T>
+   {
+      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<T> EuclideanVector<T> for Vector2<T> where T: Real
+{
+   fn angle(&self, vector: &Vector2<T>) -> T
+   {
+      //unimplemented!();
+      atan2(self.perpendicular_dot(vector), self.dot(vector))
+   }
+}
+
+impl<T> EuclideanVector<T> for Vector3<T> where T: Real
+{
+   fn angle(&self, vector: &Vector3<T>) -> T
+   {
+      //unimplemented!();
+      atan2(self.cross(vector).get_length(), self.dot(vector))
+   }
+}
+
+impl<T> EuclideanVector<T> for Vector4<T> where T: Real
+{
+   fn angle(&self, vector: &Vector4<T>) -> 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<f32> = Vector3::<f32>::from_value(1.0f32);
+
+   let v_two: Vector3<f32> = Vector3::<f32>::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<f32> = Vector3::<f32>::from_value(9.0f32);
+
+   let v_two: Vector3<f32> = Vector3::<f32>::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<f32> = Vector3::<f32>::from_value(3.0f32);
+
+   let v_two: Vector3<f32> = Vector3::<f32>::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<f32> = Vector3::<f32>::from_value(15.0f32);
+
+   let v_two: Vector3<f32> = Vector3::<f32>::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<f32> = Vector3::<f32>::from_value(15.0f32);
+
+   let v_two: Vector3<f32> = Vector3::<f32>::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);
+}