From 46f1bcafca62a721a950715ed9fed9a9381e41bf Mon Sep 17 00:00:00 2001
From: Jason Travis Smith <Myrddin@CyberMagesLLC.com>
Date: Sun, 29 Apr 2018 03:55:53 -0400
Subject: [PATCH] Fixed some function names.

---
 src/real.rs | 39 ++++++++++++++++++++++++---------------
 1 file changed, 24 insertions(+), 15 deletions(-)

diff --git a/src/real.rs b/src/real.rs
index 14dd279..aef5dc3 100644
--- a/src/real.rs
+++ b/src/real.rs
@@ -226,8 +226,10 @@ pub trait Real : Number + Constants + Neg<Output=Self>
    /// assert_eq!(f64::NEG_INFINITY.signum(), -1.0f64);
    /// assert!(f64::NAN.signum().is_nan());
    /// ```
-   fn signum(self) -> Self;
+   fn get_signum(self) -> Self;
 
+   /* TODO: Reimplement this when the error for 'use core::num::Float;'
+            goes away.
    /// 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.
@@ -243,13 +245,14 @@ pub trait Real : Number + Constants + Neg<Output=Self>
    /// let num64 = 12.4f64;
    /// let inf64 = f64::INFINITY;
    ///
-   /// assert_eq!(num32.classify(), FpCategory::Normal);
-   /// assert_eq!(inf32.classify(), FpCategory::Infinite);
+   /// assert_eq!(num32.get_category(), FpCategory::Normal);
+   /// assert_eq!(inf32.get_category(), FpCategory::Infinite);
    ///
-   /// assert_eq!(num64.classify(), FpCategory::Normal);
-   /// assert_eq!(inf64.classify(), FpCategory::Infinite);
+   /// assert_eq!(num64.get_category(), FpCategory::Normal);
+   /// assert_eq!(inf64.get_category(), FpCategory::Infinite);
    /// ```
-   fn classify(self) -> FpCategory;
+   fn get_category(self) -> FpCategory;
+   */
 
    // TODO: Fix/check this example.
    /// Returns the mantissa, base 2 exponent, and sign as
@@ -273,7 +276,7 @@ pub trait Real : Number + Constants + Neg<Output=Self>
    ///
    /// assert!(abs_difference < Real::EPSILON);
    /// ```
-   fn integer_decode(self) -> (u64, i16, i8);
+   fn get_integer_decode(self) -> (u64, i16, i8);
 
    /// Fused multiply-add. Computes `(self * a) + b` with
    /// only one rounding error. This produces a more accurate
@@ -678,7 +681,7 @@ impl Real for f32
       self.is_finite() && self > Self::zero()
    }
 
-   fn signum(self) -> Self
+   fn get_signum(self) -> Self
    {
       if self.is_nan() == true
       {
@@ -698,12 +701,15 @@ impl Real for f32
       }
    }
 
-   fn classify(self) -> FpCategory
+   /* TODO: Reimplement this when the error for 'use core::num::Float;'
+            goes away.
+   fn get_category(self) -> FpCategory
    {
-      <Self>::classify(self)
+      self.classify()
    }
+   */
 
-   fn integer_decode(self) -> (u64, i16, i8)
+   fn get_integer_decode(self) -> (u64, i16, i8)
    {
       let bits: u32;
       let sign: i8;
@@ -937,7 +943,7 @@ impl Real for f64
       self.is_finite() && self > Self::zero()
    }
 
-   fn signum(self) -> Self
+   fn get_signum(self) -> Self
    {
       if self.is_nan() == true
       {
@@ -957,12 +963,15 @@ impl Real for f64
       }
    }
 
-   fn classify(self) -> FpCategory
+   /* TODO: Reimplement this when the error for 'use core::num::Float;'
+            goes away.
+   fn get_category(self) -> FpCategory
    {
-      <Self>::classify(self)
+      self.classify()
    }
+   */
 
-   fn integer_decode(self) -> (u64, i16, i8)
+   fn get_integer_decode(self) -> (u64, i16, i8)
    {
       let bits: u64;
       let sign: i8;