Clean up rationals [skip ci]

Former-commit-id: ad694de554cb1cbec984f5af7abde6885649b2cc
Former-commit-id: 7d411118b462d6451d386c6915c6d31ddc7289c8
Former-commit-id: dd60d42bb56b148f630bd1ad3d7af8e5e9bb5764

src/ImageProcessorCore/Numerics/BigRational.cs

@@ -1,219 +0,0 @@
-// <copyright file="Rational.cs" company="James Jackson-South">
-// Copyright (c) James Jackson-South and contributors.
-// Licensed under the Apache License, Version 2.0.
-// </copyright>
-
-namespace ImageProcessorCore
-{
-    using System;
-    using System.Text;
-
-    internal struct BigRational : IEquatable<BigRational>
-    {
-        private bool IsIndeterminate
-        {
-            get
-            {
-                if (Denominator != 0)
-                    return false;
-
-                return Numerator == 0;
-            }
-        }
-
-        private bool IsInteger => Denominator == 1;
-
-        private bool IsNegativeInfinity
-        {
-            get
-            {
-                if (Denominator != 0)
-                    return false;
-
-                return Numerator == -1;
-            }
-        }
-
-        private bool IsPositiveInfinity
-        {
-            get
-            {
-                if (Denominator != 0)
-                    return false;
-
-                return Numerator == 1;
-            }
-        }
-
-        private bool IsZero
-        {
-            get
-            {
-                if (Denominator != 1)
-                    return false;
-
-                return Numerator == 0;
-            }
-        }
-
-        private static long GreatestCommonDivisor(long a, long b)
-        {
-            return b == 0 ? a : GreatestCommonDivisor(b, a % b);
-        }
-
-        private void Simplify()
-        {
-            if (IsIndeterminate)
-                return;
-
-            if (IsNegativeInfinity)
-                return;
-
-            if (IsPositiveInfinity)
-                return;
-
-            if (IsInteger)
-                return;
-
-            if (IsZero)
-                return;
-
-            if (Numerator == 0)
-            {
-                Denominator = 0;
-                return;
-            }
-
-            if (Numerator == Denominator)
-            {
-                Numerator = 1;
-                Denominator = 1;
-            }
-
-            long gcd = GreatestCommonDivisor(Math.Abs(Numerator), Math.Abs(Denominator));
-            if (gcd > 1)
-            {
-                Numerator = Numerator / gcd;
-                Denominator = Denominator / gcd;
-            }
-        }
-
-        public BigRational(long numerator, long denominator)
-          : this(numerator, denominator, false)
-        {
-        }
-
-        public BigRational(long numerator, long denominator, bool simplify)
-        {
-            Numerator = numerator;
-            Denominator = denominator;
-
-            if (simplify)
-                Simplify();
-        }
-
-        public BigRational(double value, bool bestPrecision)
-        {
-            if (double.IsNaN(value))
-            {
-                Numerator = Denominator = 0;
-                return;
-            }
-
-            if (double.IsPositiveInfinity(value))
-            {
-                Numerator = 1;
-                Denominator = 0;
-                return;
-            }
-
-            if (double.IsNegativeInfinity(value))
-            {
-                Numerator = -1;
-                Denominator = 0;
-                return;
-            }
-
-            Numerator = 1;
-            Denominator = 1;
-
-            double val = Math.Abs(value);
-            double df = Numerator / (double)Denominator;
-            double epsilon = bestPrecision ? double.Epsilon : .000001;
-
-            while (Math.Abs(df - val) > epsilon)
-            {
-                if (df < val)
-                    Numerator++;
-                else
-                {
-                    Denominator++;
-                    Numerator = (int)(val * Denominator);
-                }
-
-                df = Numerator / (double)Denominator;
-            }
-
-            if (value < 0.0)
-                Numerator *= -1;
-
-            Simplify();
-        }
-
-        public long Denominator
-        {
-            get;
-            private set;
-        }
-
-        public long Numerator
-        {
-            get;
-            private set;
-        }
-
-        public bool Equals(BigRational other)
-        {
-            if (Denominator == other.Denominator)
-                return Numerator == other.Numerator;
-
-            if (Numerator == 0 && Denominator == 0)
-                return other.Numerator == 0 && other.Denominator == 0;
-
-            if (other.Numerator == 0 && other.Denominator == 0)
-                return Numerator == 0 && Denominator == 0;
-
-            return (Numerator * other.Denominator) == (Denominator * other.Numerator);
-        }
-
-        public override int GetHashCode()
-        {
-            return ((Numerator * 397) ^ Denominator).GetHashCode();
-        }
-
-        public string ToString(IFormatProvider provider)
-        {
-            if (IsIndeterminate)
-                return "[ Indeterminate ]";
-
-            if (IsPositiveInfinity)
-                return "[ PositiveInfinity ]";
-
-            if (IsNegativeInfinity)
-                return "[ NegativeInfinity ]";
-
-            if (IsZero)
-                return "0";
-
-            if (IsInteger)
-                return Numerator.ToString(provider);
-
-            StringBuilder sb = new StringBuilder();
-            sb.Append(Numerator.ToString(provider));
-            sb.Append("/");
-            sb.Append(Denominator.ToString(provider));
-
-            return sb.ToString();
-        }
-    }
-}

src/ImageProcessorCore/Numerics/LongRational.cs

@@ -0,0 +1,355 @@
+// <copyright file="LongRational.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageProcessorCore
+{
+    using System;
+    using System.Globalization;
+    using System.Text;
+
+    /// <summary>
+    /// Represents a number that can be expressed as a fraction
+    /// </summary>
+    /// <remarks>
+    /// This is a very simplified implementation of a rational number designed for use with metadata only.
+    /// </remarks>
+    internal struct LongRational : IEquatable<LongRational>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LongRational"/> struct. 
+        /// </summary>
+        /// <param name="numerator">
+        /// The number above the line in a vulgar fraction showing how many of the parts 
+        /// indicated by the denominator are taken.
+        /// </param>
+        /// <param name="denominator">
+        /// The number below the line in a vulgar fraction; a divisor.
+        /// </param>
+        public LongRational(long numerator, long denominator)
+          : this(numerator, denominator, false)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LongRational"/> struct. 
+        /// </summary>
+        /// <param name="numerator">
+        /// The number above the line in a vulgar fraction showing how many of the parts 
+        /// indicated by the denominator are taken.
+        /// </param>
+        /// <param name="denominator">
+        /// The number below the line in a vulgar fraction; a divisor.
+        /// </param>
+        /// <param name="simplify">
+        /// Whether to attempt to simplify the fractional parts.
+        /// </param>
+        public LongRational(long numerator, long denominator, bool simplify)
+            : this()
+        {
+            this.Numerator = numerator;
+            this.Denominator = denominator;
+
+            if (simplify)
+            {
+                this.Simplify();
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LongRational"/> struct. 
+        /// </summary>
+        /// <param name="value">The <see cref="double"/> to create the instance from.</param>
+        /// <param name="bestPrecision">Whether to use the best possible precision when parsing the value.</param>
+        public LongRational(double value, bool bestPrecision)
+            : this()
+        {
+            if (double.IsNaN(value))
+            {
+                this.Numerator = this.Denominator = 0;
+                return;
+            }
+
+            if (double.IsPositiveInfinity(value))
+            {
+                this.Numerator = 1;
+                this.Denominator = 0;
+                return;
+            }
+
+            if (double.IsNegativeInfinity(value))
+            {
+                this.Numerator = -1;
+                this.Denominator = 0;
+                return;
+            }
+
+            this.Numerator = 1;
+            this.Denominator = 1;
+
+            double val = Math.Abs(value);
+            double df = this.Numerator / (double)this.Denominator;
+            double epsilon = bestPrecision ? double.Epsilon : .000001;
+
+            while (Math.Abs(df - val) > epsilon)
+            {
+                if (df < val)
+                {
+                    this.Numerator++;
+                }
+                else
+                {
+                    this.Denominator++;
+                    this.Numerator = (int)(val * this.Denominator);
+                }
+
+                df = this.Numerator / (double)this.Denominator;
+            }
+
+            if (value < 0.0)
+            {
+                this.Numerator *= -1;
+            }
+
+            this.Simplify();
+        }
+
+        /// <summary>
+        /// Gets the numerator of a number.
+        /// </summary>
+        public long Numerator
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Gets the denominator of a number.
+        /// </summary>
+        public long Denominator
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this instance is indeterminate. 
+        /// </summary>
+        public bool IsIndeterminate
+        {
+            get
+            {
+                if (this.Denominator != 0)
+                {
+                    return false;
+                }
+
+                return this.Numerator == 0;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this instance is an integer (n, 1)
+        /// </summary>
+        public bool IsInteger => this.Denominator == 1;
+
+        /// <summary>
+        /// Gets a value indicating whether this instance is equal to negative infinity (-1, 0) 
+        /// </summary>
+        public bool IsNegativeInfinity
+        {
+            get
+            {
+                if (this.Denominator != 0)
+                {
+                    return false;
+                }
+
+                return this.Numerator == -1;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this instance is equal to positive infinity (1, 0) 
+        /// </summary>
+        public bool IsPositiveInfinity
+        {
+            get
+            {
+                if (this.Denominator != 0)
+                {
+                    return false;
+                }
+
+                return this.Numerator == 1;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this instance is equal to 0 (0, 1)
+        /// </summary>
+        public bool IsZero
+        {
+            get
+            {
+                if (this.Denominator != 1)
+                {
+                    return false;
+                }
+
+                return this.Numerator == 0;
+            }
+        }
+
+        /// <inheritdoc/>
+        public bool Equals(LongRational other)
+        {
+            if (this.Denominator == other.Denominator)
+            {
+                return this.Numerator == other.Numerator;
+            }
+
+            if (this.Numerator == 0 && this.Denominator == 0)
+            {
+                return other.Numerator == 0 && other.Denominator == 0;
+            }
+
+            if (other.Numerator == 0 && other.Denominator == 0)
+            {
+                return this.Numerator == 0 && this.Denominator == 0;
+            }
+
+            return (this.Numerator * other.Denominator) == (this.Denominator * other.Numerator);
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            return this.GetHashCode(this);
+        }
+
+        /// <inheritdoc/>
+        public override string ToString()
+        {
+            return this.ToString(CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Converts the numeric value of this instance to its equivalent string representation using 
+        /// the specified culture-specific format information.
+        /// </summary>
+        /// <param name="provider">
+        /// An object that supplies culture-specific formatting information. 
+        /// </param>
+        /// <returns>The <see cref="string"/></returns>
+        public string ToString(IFormatProvider provider)
+        {
+            if (this.IsIndeterminate)
+            {
+                return "[ Indeterminate ]";
+            }
+
+            if (this.IsPositiveInfinity)
+            {
+                return "[ PositiveInfinity ]";
+            }
+
+            if (this.IsNegativeInfinity)
+            {
+                return "[ NegativeInfinity ]";
+            }
+
+            if (this.IsZero)
+            {
+                return "0";
+            }
+
+            if (this.IsInteger)
+            {
+                return this.Numerator.ToString(provider);
+            }
+
+            StringBuilder sb = new StringBuilder();
+            sb.Append(this.Numerator.ToString("R", provider));
+            sb.Append("/");
+            sb.Append(this.Denominator.ToString("R", provider));
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Finds the greatest common divisor of two <see cref="long"/> values.
+        /// </summary>
+        /// <param name="left">The first value</param>
+        /// <param name="right">The second value</param>
+        /// <returns>The <see cref="long"/></returns>
+        private static long GreatestCommonDivisor(long left, long right)
+        {
+            return right == 0 ? left : GreatestCommonDivisor(right, left % right);
+        }
+
+        /// <summary>
+        /// Simplifies the <see cref="LongRational"/>
+        /// </summary>
+        private void Simplify()
+        {
+            if (this.IsIndeterminate)
+            {
+                return;
+            }
+
+            if (this.IsNegativeInfinity)
+            {
+                return;
+            }
+
+            if (this.IsPositiveInfinity)
+            {
+                return;
+            }
+
+            if (this.IsInteger)
+            {
+                return;
+            }
+
+            if (this.IsZero)
+            {
+                return;
+            }
+
+            if (this.Numerator == 0)
+            {
+                this.Denominator = 0;
+                return;
+            }
+
+            if (this.Numerator == this.Denominator)
+            {
+                this.Numerator = 1;
+                this.Denominator = 1;
+            }
+
+            long gcd = GreatestCommonDivisor(Math.Abs(this.Numerator), Math.Abs(this.Denominator));
+            if (gcd > 1)
+            {
+                this.Numerator = this.Numerator / gcd;
+                this.Denominator = this.Denominator / gcd;
+            }
+        }
+
+        /// <summary>
+        /// Returns the hash code for this instance.
+        /// </summary>
+        /// <param name="rational">
+        /// The instance of <see cref="LongRational"/> to return the hash code for.
+        /// </param>
+        /// <returns>
+        /// A 32-bit signed integer that is the hash code for this instance.
+        /// </returns>
+        private int GetHashCode(LongRational rational)
+        {
+            return ((rational.Numerator * 397) ^ rational.Denominator).GetHashCode();
+        }
+    }
+}

src/ImageProcessorCore/Numerics/Rational.cs

@@ -12,74 +12,84 @@ namespace ImageProcessorCore
     /// Represents a number that can be expressed as a fraction.
     /// </summary>
     /// <remarks>
-    /// This is a very simplified implimentation of a rational number designed for use with metadata only.
+    /// This is a very simplified implementation of a rational number designed for use with metadata only.
     /// </remarks>
     public struct Rational : IEquatable<Rational>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="Rational"/> struct.
         /// </summary>
-        ///<param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
+        /// <param name="value">The <see cref="uint"/> to create the rational from.</param>
-        public Rational(double value)
+        public Rational(uint value)
-          : this(value, false)
+          : this(value, 1)
         {
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Rational"/> struct.
         /// </summary>
-        ///<param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
+        /// <param name="numerator">The number above the line in a vulgar fraction showing how many of the parts indicated by the denominator are taken.</param>
-        ///<param name="bestPrecision">Specifies if the instance should be created with the best precision possible.</param>
+        /// <param name="denominator">The number below the line in a vulgar fraction; a divisor.</param>
-        public Rational(double value, bool bestPrecision)
+        public Rational(uint numerator, uint denominator)
+          : this(numerator, denominator, true)
         {
-            BigRational rational = new BigRational(Math.Abs(value), bestPrecision);
-
-            Numerator = (uint)rational.Numerator;
-            Denominator = (uint)rational.Denominator;
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Rational"/> struct.
         /// </summary>
-        /// <param name="value">The integer to create the rational from.</param>
+        /// <param name="numerator">The number above the line in a vulgar fraction showing how many of the parts indicated by the denominator are taken.</param>
-        public Rational(uint value)
+        /// <param name="denominator">The number below the line in a vulgar fraction; a divisor.</param>
-          : this(value, 1)
+        /// <param name="simplify">Specified if the rational should be simplified.</param>
+        public Rational(uint numerator, uint denominator, bool simplify)
         {
+            LongRational rational = new LongRational(numerator, denominator, simplify);
+
+            this.Numerator = (uint)rational.Numerator;
+            this.Denominator = (uint)rational.Denominator;
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Rational"/> struct.
         /// </summary>
-        /// <param name="numerator">The number above the line in a vulgar fraction showing how many of the parts indicated by the denominator are taken.</param>
+        /// <param name="value">The <see cref="double"/> to create the instance from.</param>
-        /// <param name="denominator">The number below the line in a vulgar fraction; a divisor.</param>
+        public Rational(double value)
-        public Rational(uint numerator, uint denominator)
+          : this(value, false)
-          : this(numerator, denominator, true)
         {
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Rational"/> struct.
         /// </summary>
-        /// <param name="numerator">The number above the line in a vulgar fraction showing how many of the parts indicated by the denominator are taken.</param>
+        /// <param name="value">The <see cref="double"/> to create the instance from.</param>
-        /// <param name="denominator">The number below the line in a vulgar fraction; a divisor.</param>
+        /// <param name="bestPrecision">Whether to use the best possible precision when parsing the value.</param>
-        /// <param name="simplify">Specified if the rational should be simplified.</param>
+        public Rational(double value, bool bestPrecision)
-        public Rational(uint numerator, uint denominator, bool simplify)
         {
-            BigRational rational = new BigRational(numerator, denominator, simplify);
+            LongRational rational = new LongRational(Math.Abs(value), bestPrecision);
 
-            Numerator = (uint)rational.Numerator;
+            this.Numerator = (uint)rational.Numerator;
-            Denominator = (uint)rational.Denominator;
+            this.Denominator = (uint)rational.Denominator;
         }
 
+        /// <summary>
+        /// Gets the numerator of a number.
+        /// </summary>
+        public uint Numerator { get; }
+
+        /// <summary>
+        /// Gets the denominator of a number.
+        /// </summary>
+        public uint Denominator { get; }
+
         /// <summary>
         /// Determines whether the specified <see cref="Rational"/> instances are considered equal.
         /// </summary>
         /// <param name="left">The first <see cref="Rational"/>  to compare.</param>
         /// <param name="right"> The second <see cref="Rational"/>  to compare.</param>
-        /// <returns></returns>
+        /// <returns>The <see cref="bool"/></returns>
         public static bool operator ==(Rational left, Rational right)
         {
-            return Equals(left, right);
+            return Rational.Equals(left, right);
         }
 
         /// <summary>
@@ -87,79 +97,61 @@ namespace ImageProcessorCore
         /// </summary>
         /// <param name="left">The first <see cref="Rational"/> to compare.</param>
         /// <param name="right"> The second <see cref="Rational"/> to compare.</param>
-        /// <returns></returns>
+        /// <returns>The <see cref="bool"/></returns>
         public static bool operator !=(Rational left, Rational right)
         {
-            return !Equals(left, right);
+            return !Rational.Equals(left, right);
         }
 
         /// <summary>
-        /// Gets the numerator of a number.
+        /// Converts the specified <see cref="double"/> to an instance of this type.
         /// </summary>
-        public uint Numerator
+        /// <param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
+        /// <returns>
+        /// The <see cref="Rational"/>.
+        /// </returns>
+        public static Rational FromDouble(double value)
         {
-            get;
+            return new Rational(value, false);
-            private set;
         }
 
         /// <summary>
-        /// Gets the denominator of a number.
+        /// Converts the specified <see cref="double"/> to an instance of this type.
         /// </summary>
-        public uint Denominator
+        /// <param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
+        /// <param name="bestPrecision">Whether to use the best possible precision when parsing the value.</param>
+        /// <returns>
+        /// The <see cref="Rational"/>.
+        /// </returns>
+        public static Rational FromDouble(double value, bool bestPrecision)
         {
-            get;
+            return new Rational(value, bestPrecision);
-            private set;
         }
 
-        ///<summary>
+        /// <inheritdoc/>
-        /// Determines whether the specified <see cref="object"/> is equal to this <see cref="Rational"/>.
-        ///</summary>
-        ///<param name="obj">The <see cref="object"/> to compare this <see cref="Rational"/> with.</param>
         public override bool Equals(object obj)
         {
             if (obj is Rational)
-                return Equals((Rational)obj);
+            {
+                return this.Equals((Rational)obj);
+            }
 
             return false;
         }
 
-        ///<summary>
+        /// <inheritdoc/>
-        /// Determines whether the specified <see cref="Rational"/> is equal to this <see cref="Rational"/>.
-        ///</summary>
-        ///<param name="other">The <see cref="Rational"/> to compare this <see cref="Rational"/> with.</param>
         public bool Equals(Rational other)
         {
-            BigRational left = new BigRational(Numerator, Denominator);
+            LongRational left = new LongRational(this.Numerator, this.Denominator);
-            BigRational right = new BigRational(other.Numerator, other.Denominator);
+            LongRational right = new LongRational(other.Numerator, other.Denominator);
 
             return left.Equals(right);
         }
 
-        ///<summary>
+        /// <inheritdoc/>
-        /// Converts the specified <see cref="double"/> to an instance of this type.
-        ///</summary>
-        ///<param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
-        public static Rational FromDouble(double value)
-        {
-            return new Rational(value, false);
-        }
-
-        ///<summary>
-        /// Converts the specified <see cref="double"/> to an instance of this type.
-        ///</summary>
-        ///<param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
-        ///<param name="bestPrecision">Specifies if the instance should be created with the best precision possible.</param>
-        public static Rational FromDouble(double value, bool bestPrecision)
-        {
-            return new Rational(value, bestPrecision);
-        }
-
-        ///<summary>
-        /// Serves as a hash of this type.
-        ///</summary>
         public override int GetHashCode()
         {
-            BigRational self = new BigRational(Numerator, Denominator);
+            LongRational self = new LongRational(this.Numerator, this.Denominator);
             return self.GetHashCode();
         }
 
@@ -171,28 +163,26 @@ namespace ImageProcessorCore
         /// </returns>
         public double ToDouble()
         {
-            return Numerator / (double)Denominator;
+            return this.Numerator / (double)this.Denominator;
         }
 
-        /// <summary>
+        /// <inheritdoc/>
-        /// Converts the numeric value of this instance to its equivalent string representation.
-        /// </summary>
         public override string ToString()
         {
-            return ToString(CultureInfo.InvariantCulture);
+            return this.ToString(CultureInfo.InvariantCulture);
         }
 
         /// <summary>
-        /// Converts the numeric value of this instance to its equivalent string representation using
+        /// Converts the numeric value of this instance to its equivalent string representation using 
         /// the specified culture-specific format information.
         /// </summary>
         /// <param name="provider">
         /// An object that supplies culture-specific formatting information. 
         /// </param>
-        /// <returns></returns>
+        /// <returns>The <see cref="string"/></returns>
         public string ToString(IFormatProvider provider)
         {
-            BigRational rational = new BigRational(Numerator, Denominator);
+            LongRational rational = new LongRational(this.Numerator, this.Denominator);
             return rational.ToString(provider);
         }
     }

src/ImageProcessorCore/Numerics/SignedRational.cs

@@ -1,4 +1,4 @@
-// <copyright file="Rational.cs" company="James Jackson-South">
+// <copyright file="SignedRational.cs" company="James Jackson-South">
 // Copyright (c) James Jackson-South and contributors.
 // Licensed under the Apache License, Version 2.0.
 // </copyright>
@@ -12,74 +12,84 @@ namespace ImageProcessorCore
     /// Represents a number that can be expressed as a fraction.
     /// </summary>
     /// <remarks>
-    /// This is a very simplified implimentation of a rational number designed for use with metadata only.
+    /// This is a very simplified implementation of a rational number designed for use with metadata only.
     /// </remarks>
     public struct SignedRational : IEquatable<SignedRational>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="SignedRational"/> struct.
         /// </summary>
-        ///<param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
+        /// <param name="value">The <see cref="int"/> to create the rational from.</param>
-        public SignedRational(double value)
+        public SignedRational(int value)
-          : this(value, false)
+          : this(value, 1)
         {
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SignedRational"/> struct.
         /// </summary>
-        ///<param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
+        /// <param name="numerator">The number above the line in a vulgar fraction showing how many of the parts indicated by the denominator are taken.</param>
-        ///<param name="bestPrecision">Specifies if the instance should be created with the best precision possible.</param>
+        /// <param name="denominator">The number below the line in a vulgar fraction; a divisor.</param>
-        public SignedRational(double value, bool bestPrecision)
+        public SignedRational(int numerator, int denominator)
+          : this(numerator, denominator, true)
         {
-            BigRational rational = new BigRational(value, bestPrecision);
-
-            Numerator = (int)rational.Numerator;
-            Denominator = (int)rational.Denominator;
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SignedRational"/> struct.
         /// </summary>
-        /// <param name="value">The integer to create the rational from.</param>
+        /// <param name="numerator">The number above the line in a vulgar fraction showing how many of the parts indicated by the denominator are taken.</param>
-        public SignedRational(int value)
+        /// <param name="denominator">The number below the line in a vulgar fraction; a divisor.</param>
-          : this(value, 1)
+        /// <param name="simplify">Specified if the rational should be simplified.</param>
+        public SignedRational(int numerator, int denominator, bool simplify)
         {
+            LongRational rational = new LongRational(numerator, denominator, simplify);
+
+            this.Numerator = (int)rational.Numerator;
+            this.Denominator = (int)rational.Denominator;
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SignedRational"/> struct.
         /// </summary>
-        /// <param name="numerator">The number above the line in a vulgar fraction showing how many of the parts indicated by the denominator are taken.</param>
+        /// <param name="value">The <see cref="double"/> to create the instance from.</param>
-        /// <param name="denominator">The number below the line in a vulgar fraction; a divisor.</param>
+        public SignedRational(double value)
-        public SignedRational(int numerator, int denominator)
+          : this(value, false)
-          : this(numerator, denominator, true)
         {
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SignedRational"/> struct.
         /// </summary>
-        /// <param name="numerator">The number above the line in a vulgar fraction showing how many of the parts indicated by the denominator are taken.</param>
+        /// <param name="value">The <see cref="double"/> to create the instance from.</param>
-        /// <param name="denominator">The number below the line in a vulgar fraction; a divisor.</param>
+        /// <param name="bestPrecision">Whether to use the best possible precision when parsing the value.</param>
-        /// <param name="simplify">Specified if the rational should be simplified.</param>
+        public SignedRational(double value, bool bestPrecision)
-        public SignedRational(int numerator, int denominator, bool simplify)
         {
-            BigRational rational = new BigRational(numerator, denominator, simplify);
+            LongRational rational = new LongRational(value, bestPrecision);
 
-            Numerator = (int)rational.Numerator;
+            this.Numerator = (int)rational.Numerator;
-            Denominator = (int)rational.Denominator;
+            this.Denominator = (int)rational.Denominator;
         }
 
+        /// <summary>
+        /// Gets the numerator of a number.
+        /// </summary>
+        public int Numerator { get; }
+
+        /// <summary>
+        /// Gets the denominator of a number.
+        /// </summary>
+        public int Denominator { get; }
+
         /// <summary>
         /// Determines whether the specified <see cref="SignedRational"/> instances are considered equal.
         /// </summary>
         /// <param name="left">The first <see cref="SignedRational"/>  to compare.</param>
         /// <param name="right"> The second <see cref="SignedRational"/>  to compare.</param>
-        /// <returns></returns>
+        /// <returns>The <see cref="bool"/></returns>
         public static bool operator ==(SignedRational left, SignedRational right)
         {
-            return Equals(left, right);
+            return SignedRational.Equals(left, right);
         }
 
         /// <summary>
@@ -87,79 +97,61 @@ namespace ImageProcessorCore
         /// </summary>
         /// <param name="left">The first <see cref="SignedRational"/> to compare.</param>
         /// <param name="right"> The second <see cref="SignedRational"/> to compare.</param>
-        /// <returns></returns>
+        /// <returns>The <see cref="bool"/></returns>
         public static bool operator !=(SignedRational left, SignedRational right)
         {
-            return !Equals(left, right);
+            return !SignedRational.Equals(left, right);
         }
 
         /// <summary>
-        /// Gets the numerator of a number.
+        /// Converts the specified <see cref="double"/> to an instance of this type.
         /// </summary>
-        public int Numerator
+        /// <param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
+        /// <returns>
+        /// The <see cref="SignedRational"/>.
+        /// </returns>
+        public static SignedRational FromDouble(double value)
         {
-            get;
+            return new SignedRational(value, false);
-            private set;
         }
 
         /// <summary>
-        /// Gets the denominator of a number.
+        /// Converts the specified <see cref="double"/> to an instance of this type.
         /// </summary>
-        public int Denominator
+        /// <param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
+        /// <param name="bestPrecision">Whether to use the best possible precision when parsing the value.</param>
+        /// <returns>
+        /// The <see cref="SignedRational"/>.
+        /// </returns>
+        public static SignedRational FromDouble(double value, bool bestPrecision)
         {
-            get;
+            return new SignedRational(value, bestPrecision);
-            private set;
         }
 
-        ///<summary>
+        /// <inheritdoc/>
-        /// Determines whether the specified <see cref="object"/> is equal to this <see cref="SignedRational"/>.
-        ///</summary>
-        ///<param name="obj">The <see cref="object"/> to compare this <see cref="SignedRational"/> with.</param>
         public override bool Equals(object obj)
         {
             if (obj is SignedRational)
-                return Equals((SignedRational)obj);
+            {
+                return this.Equals((SignedRational)obj);
+            }
 
             return false;
         }
 
-        ///<summary>
+        /// <inheritdoc/>
-        /// Determines whether the specified <see cref="SignedRational"/> is equal to this <see cref="SignedRational"/>.
-        ///</summary>
-        ///<param name="other">The <see cref="SignedRational"/> to compare this <see cref="SignedRational"/> with.</param>
         public bool Equals(SignedRational other)
         {
-            BigRational left = new BigRational(Numerator, Denominator);
+            LongRational left = new LongRational(this.Numerator, this.Denominator);
-            BigRational right = new BigRational(other.Numerator, other.Denominator);
+            LongRational right = new LongRational(other.Numerator, other.Denominator);
 
             return left.Equals(right);
         }
 
-        ///<summary>
+        /// <inheritdoc/>
-        /// Converts the specified <see cref="double"/> to an instance of this type.
-        ///</summary>
-        ///<param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
-        public static SignedRational FromDouble(double value)
-        {
-            return new SignedRational(value, false);
-        }
-
-        ///<summary>
-        /// Converts the specified <see cref="double"/> to an instance of this type.
-        ///</summary>
-        ///<param name="value">The <see cref="double"/> to convert to an instance of this type.</param>
-        ///<param name="bestPrecision">Specifies if the instance should be created with the best precision possible.</param>
-        public static SignedRational FromDouble(double value, bool bestPrecision)
-        {
-            return new SignedRational(value, bestPrecision);
-        }
-
-        ///<summary>
-        /// Serves as a hash of this type.
-        ///</summary>
         public override int GetHashCode()
         {
-            BigRational self = new BigRational(Numerator, Denominator);
+            LongRational self = new LongRational(this.Numerator, this.Denominator);
             return self.GetHashCode();
         }
 
@@ -171,28 +163,26 @@ namespace ImageProcessorCore
         /// </returns>
         public double ToDouble()
         {
-            return Numerator / (double)Denominator;
+            return this.Numerator / (double)this.Denominator;
         }
 
-        /// <summary>
+        /// <inheritdoc/>
-        /// Converts the numeric value of this instance to its equivalent string representation.
-        /// </summary>
         public override string ToString()
         {
-            return ToString(CultureInfo.InvariantCulture);
+            return this.ToString(CultureInfo.InvariantCulture);
         }
 
         /// <summary>
-        /// Converts the numeric value of this instance to its equivalent string representation using
+        /// Converts the numeric value of this instance to its equivalent string representation using 
         /// the specified culture-specific format information.
         /// </summary>
         /// <param name="provider">
         /// An object that supplies culture-specific formatting information. 
         /// </param>
-        /// <returns></returns>
+        /// <returns>The <see cref="string"/></returns>
         public string ToString(IFormatProvider provider)
         {
-            BigRational rational = new BigRational(Numerator, Denominator);
+            LongRational rational = new LongRational(this.Numerator, this.Denominator);
             return rational.ToString(provider);
         }
     }