Make Fraction IEquatable, update overrides and ops

napen123 · napen123 · commit 51a34eb043e4 · 2016-07-13T18:13:24.000-06:00
diff --git a/Mathos/Arithmetic/Fraction.cs b/Mathos/Arithmetic/Fraction.cs
@@ -17,7 +17,7 @@ namespace Fractions
         /// The the numerator and denominator are both Int64 (long).
         /// </remarks>
         [Serializable]
-        public class Fraction : IRational
+        public class Fraction : IRational, IEquatable<Fraction>
         {
             /// <summary>
             /// Gets or sets the numerator.
@@ -146,22 +146,44 @@ public override string ToString()
             }
 
             /// <summary>
-            /// Indicates whether this instance and a specified object are equal.
+            /// Gets the hashcode of this instance.
             /// </summary>
-            /// <returns>Whether <paramref name="obj"/> is equal to the fraction.</returns>
-            /// <param name="obj">Another object to compare to. </param><filterpriority>2</filterpriority>
+            /// <returns></returns>
+            public override int GetHashCode()
+            {
+                unchecked
+                {
+                    return (_denominator.GetHashCode() * 397) ^ Numerator.GetHashCode();
+                }
+            }
+
+            /// <summary>
+            /// Indicates whether this instance and a given object are equal.
+            /// </summary>
+            /// <returns>Whether <paramref name="obj"/> is equal to the current fraction.</returns>
+            /// <param name="obj">Another object to compare to. </param>
             public override bool Equals(object obj)
             {
                 return obj != null && obj.GetType() == GetType() && this == (Fraction) obj;
             }
 
+            /// <summary>
+            /// Indicates whether this instance and a given fraction are equal.
+            /// </summary>
+            /// <returns>Whether <paramref name="other"/> is equal to the current fraction.</returns>
+            /// <param name="other">Another object to compare to. </param>
+            public bool Equals(Fraction other)
+            {
+                return other != null && (Numerator == other.Numerator) && (Denominator == other.Denominator);
+            }
+
             /// <summary>
             /// Convert the fraction into a decimal.
             /// </summary>
             /// <returns>The fraction converted into a decimal.</returns>
             public decimal ToDecimal()
             {
-                return (decimal)Numerator / _denominator;
+                return (decimal) Numerator/_denominator;
             }
 
             /// <summary>
@@ -170,7 +192,7 @@ public decimal ToDecimal()
             /// <returns>The fraction converted into a long.</returns>
             public long ToLong()
             {
-                return Numerator / _denominator;
+                return Numerator/_denominator;
             }
 
             /// <summary>
@@ -182,6 +204,15 @@ public double ToDouble()
                 return (double) Numerator/_denominator;
             }
 
+            /// <summary>
+            /// Convert the fraction into a float.
+            /// </summary>
+            /// <returns>The fraction converted into a float.</returns>
+            public float ToFloat()
+            {
+                return (float) Numerator/_denominator;
+            }
+
             /// <summary>
             /// Convert the fraction into a Stern-Brocot system
             /// </summary>
@@ -350,22 +381,31 @@ public static string ToCondensedSternBrocotSystem(string sternBrocotRepresentati
             /// <returns>The simplified form of the fraction.</returns>
             public Fraction Simplify()
             {
-                var gdc = Numbers.Get.Gdc(Numbers.Convert.ToPositive(Numerator),
-                    Numbers.Convert.ToPositive(_denominator));
+                var gdc = Get.Gdc(Numbers.Convert.ToPositive(Numerator), Numbers.Convert.ToPositive(_denominator));
 
                 return new Fraction(Numerator/gdc, _denominator/gdc);
             }
 
             /// <summary>
-            /// Find the inverse
+            /// Gets the inverse of this instance.
             /// </summary>
             /// <example>2/3 -> 3/2</example>
-            /// <returns>The inverse of the fraction.</returns>
+            /// <returns>The inverse of this fraction.</returns>
             public Fraction Inverse()
             {
                 return new Fraction(Denominator, Numerator);
             }
 
+            /// <summary>
+            /// Gets the reciprocal of this instance.
+            /// </summary>
+            /// <example>2/3 -> 3/2</example>
+            /// <returns>The reciprocal of this fraction.</returns>
+            public Fraction Reciprocal()
+            {
+                return new Fraction(Denominator, Numerator);
+            }
+
             /// <summary>
             /// Avoid fractions like 2/-3 (better: -2/3),
             /// and -2/-3 (better: 2/3).
@@ -387,7 +427,10 @@ private void FractionChecker()
             /// <returns>Whether <paramref name="fractA"/> is equal to <paramref name="fractB"/>.</returns>
             public static bool operator ==(Fraction fractA, Fraction fractB)
             {
-                fractA = fractA.Simplify(); // simplifying, e.g. if a is 4/2, and b 2/1, return true
+                if (fractA == null || fractB == null)
+                    return fractA == null && fractB == null;
+
+                fractA = fractA.Simplify();
                 fractB = fractB.Simplify();
 
                 return (fractA.Numerator == fractB.Numerator) && (fractA.Denominator == fractB.Denominator);
@@ -467,35 +510,34 @@ private void FractionChecker()
             /// <returns><paramref name="fractA"/> added to <paramref name="fractB"/>.</returns>
             public static Fraction operator +(Fraction fractA, Fraction fractB)
             {
-                fractA = fractA.Simplify(); // simplifying
+                fractA = fractA.Simplify();
                 fractB = fractB.Simplify();
 
                 if (fractA.Denominator == fractB.Denominator)
                 {
-                    var fraction = new Fraction //creating a new fraction
+                    var fraction = new Fraction
                     {
-                        Numerator = fractA.Numerator + fractB.Numerator, // adding the nominators
-                        Denominator = fractA.Denominator // assigning the denominator
+                        Numerator = fractA.Numerator + fractB.Numerator,
+                        Denominator = fractA.Denominator
                     };
 
-                    return fraction.Simplify(); // a simplified version of the fraction
+                    return fraction.Simplify();
                 }
 
-                var gdc = Numbers.Get.Gdc(fractA.Denominator, fractB.Denominator);
+                var gdc = Get.Gdc(fractA.Denominator, fractB.Denominator);
                 
                 if (gdc == 1)
                 {
-                    // if the denominators are coprimes, i.e. no factors in common
                     var fraction = new Fraction
                     {
                         Numerator = fractA.Numerator * fractB.Denominator + fractB.Numerator * fractA.Denominator,
                         Denominator = fractA.Denominator * fractB.Denominator
                     };
 
-                    return fraction.Simplify(); // a simplified version of the fraction
+                    return fraction.Simplify();
                 }
 
-                if (fractA.Denominator > fractB.Denominator) //fractA.Denominator will be the new denominator
+                if (fractA.Denominator > fractB.Denominator)
                 {
                     var fraction = new Fraction
                     {
@@ -505,7 +547,7 @@ private void FractionChecker()
 
                     return fraction.Simplify();
                 }
-                else //fractB.Denominator will be the new denominator
+                else
                 {
                     var fraction = new Fraction
                     {
@@ -525,34 +567,33 @@ private void FractionChecker()
             /// <returns><paramref name="fractB"/> substracted from <paramref name="fractA"/>.</returns>
             public static Fraction operator -(Fraction fractA, Fraction fractB)
             {
-                //addition
-                fractA = fractA.Simplify(); // simplifying
+                fractA = fractA.Simplify();
                 fractB = fractB.Simplify();
                 
                 if (fractA.Denominator == fractB.Denominator)
                 {
-                    var fraction = new Fraction  //creating a new fraction
+                    var fraction = new Fraction
                     {
-                        Numerator = fractA.Numerator - fractB.Numerator, // subtracting the nominators
-                        Denominator = fractA.Denominator // assigning the denominator
+                        Numerator = fractA.Numerator - fractB.Numerator,
+                        Denominator = fractA.Denominator
                     };
-                    return fraction.Simplify(); // a simplified version of the fraction
+                    return fraction.Simplify();
                 }
 
-                var gdc = Numbers.Get.Gdc(fractA.Denominator, fractB.Denominator);
+                var gdc = Get.Gdc(fractA.Denominator, fractB.Denominator);
+
                 if (gdc == 1)
                 {
-                    // if the denominators are coprimes, i.e. no factors in common
                     var fraction = new Fraction
                     {
                         Numerator = fractA.Numerator * fractB.Denominator - fractB.Numerator * fractA.Denominator,
                         Denominator = fractA.Denominator * fractB.Denominator
                     };
 
-                    return fraction.Simplify(); // a simplified version of the fraction
+                    return fraction.Simplify();
                 }
                 
-                if (fractA.Denominator > fractB.Denominator) //fractA.Denominator will be the new denominator
+                if (fractA.Denominator > fractB.Denominator)
                 {
                     var fraction = new Fraction
                     {
@@ -562,7 +603,7 @@ private void FractionChecker()
 
                     return fraction.Simplify();
                 }
-                else //fractB.Denominator will be the new denominator
+                else
                 {
                     var fraction = new Fraction
                     {
@@ -582,7 +623,7 @@ private void FractionChecker()
             /// <returns><paramref name="fractA"/> multiplied by <paramref name="fractB"/>.</returns>
             public static Fraction operator *(Fraction fractA, Fraction fractB)
             {
-                fractA = fractA.Simplify(); // simplifying
+                fractA = fractA.Simplify();
                 fractB = fractB.Simplify();
 
                 return new Fraction(fractA.Numerator * fractB.Numerator,
@@ -597,7 +638,7 @@ private void FractionChecker()
             /// <returns><paramref name="fractA"/> divided by <paramref name="fractB"/>.</returns>
             public static Fraction operator /(Fraction fractA, Fraction fractB)
             {
-                fractA = fractA.Simplify(); // simplifying
+                fractA = fractA.Simplify();
                 fractB = fractB.Simplify();
 
                 return new Fraction(fractA.Numerator * fractB.Denominator,
@@ -613,12 +654,11 @@ public static implicit operator Fraction(string value)
             {
                 Fraction fraction;
 
-                if (value.Contains("/")) //checking if the separator exists
+                if (value.Contains("/"))
                 {
-                    // if it is a string input
                     try
                     {
-                        value = value.Trim(' '); // trim away unnessesary stuff
+                        value = value.Trim(' ');
                         
                         fraction = new Fraction
                         {
@@ -634,7 +674,7 @@ public static implicit operator Fraction(string value)
                     }
                 }
                 
-                value = value.Trim(' '); // trim away unnessesary stuff
+                value = value.Trim(' ');
 
                 fraction = new Fraction
                 {
@@ -660,7 +700,7 @@ public static implicit operator Fraction(long num)
             /// </summary>
             /// <param name="fraction">The fraction to convert into a double.</param>
             /// <returns>Returns <paramref name="fraction"/> converted into a double.</returns>
-            public static implicit operator decimal(Fraction fraction)
+            public static explicit operator decimal(Fraction fraction)
             {
                 return (decimal)fraction.Numerator / fraction.Denominator;
             }

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ namespace Fractions`
`17`	`17`	`/// The the numerator and denominator are both Int64 (long).`
`18`	`18`	`/// </remarks>`
`19`	`19`	`[Serializable]`
`20`		`- public class Fraction : IRational`
	`20`	`+ public class Fraction : IRational, IEquatable<Fraction>`
`21`	`21`	`{`
`22`	`22`	`/// <summary>`
`23`	`23`	`/// Gets or sets the numerator.`
`@@ -146,22 +146,44 @@ public override string ToString()`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`/// <summary>`
`149`		`- /// Indicates whether this instance and a specified object are equal.`
	`149`	`+ /// Gets the hashcode of this instance.`
`150`	`150`	`/// </summary>`
`151`		`- /// <returns>Whether <paramref name="obj"/> is equal to the fraction.</returns>`
`152`		`- /// <param name="obj">Another object to compare to. </param><filterpriority>2</filterpriority>`
	`151`	`+ /// <returns></returns>`
	`152`	`+ public override int GetHashCode()`
	`153`	`+ {`
	`154`	`+ unchecked`
	`155`	`+ {`
	`156`	`+ return (_denominator.GetHashCode() * 397) ^ Numerator.GetHashCode();`
	`157`	`+ }`
	`158`	`+ }`
	`159`	`+`
	`160`	`+ /// <summary>`
	`161`	`+ /// Indicates whether this instance and a given object are equal.`
	`162`	`+ /// </summary>`
	`163`	`+ /// <returns>Whether <paramref name="obj"/> is equal to the current fraction.</returns>`
	`164`	`+ /// <param name="obj">Another object to compare to. </param>`
`153`	`165`	`public override bool Equals(object obj)`
`154`	`166`	`{`
`155`	`167`	`return obj != null && obj.GetType() == GetType() && this == (Fraction) obj;`
`156`	`168`	`}`
`157`	`169`
	`170`	`+ /// <summary>`
	`171`	`+ /// Indicates whether this instance and a given fraction are equal.`
	`172`	`+ /// </summary>`
	`173`	`+ /// <returns>Whether <paramref name="other"/> is equal to the current fraction.</returns>`
	`174`	`+ /// <param name="other">Another object to compare to. </param>`
	`175`	`+ public bool Equals(Fraction other)`
	`176`	`+ {`
	`177`	`+ return other != null && (Numerator == other.Numerator) && (Denominator == other.Denominator);`
	`178`	`+ }`
	`179`	`+`
`158`	`180`	`/// <summary>`
`159`	`181`	`/// Convert the fraction into a decimal.`
`160`	`182`	`/// </summary>`
`161`	`183`	`/// <returns>The fraction converted into a decimal.</returns>`
`162`	`184`	`public decimal ToDecimal()`
`163`	`185`	`{`
`164`		`- return (decimal)Numerator / _denominator;`
	`186`	`+ return (decimal) Numerator/_denominator;`
`165`	`187`	`}`
`166`	`188`
`167`	`189`	`/// <summary>`
`@@ -170,7 +192,7 @@ public decimal ToDecimal()`
`170`	`192`	`/// <returns>The fraction converted into a long.</returns>`
`171`	`193`	`public long ToLong()`
`172`	`194`	`{`
`173`		`- return Numerator / _denominator;`
	`195`	`+ return Numerator/_denominator;`
`174`	`196`	`}`
`175`	`197`
`176`	`198`	`/// <summary>`
`@@ -182,6 +204,15 @@ public double ToDouble()`
`182`	`204`	`return (double) Numerator/_denominator;`
`183`	`205`	`}`
`184`	`206`
	`207`	`+ /// <summary>`
	`208`	`+ /// Convert the fraction into a float.`
	`209`	`+ /// </summary>`
	`210`	`+ /// <returns>The fraction converted into a float.</returns>`
	`211`	`+ public float ToFloat()`
	`212`	`+ {`
	`213`	`+ return (float) Numerator/_denominator;`
	`214`	`+ }`
	`215`	`+`
`185`	`216`	`/// <summary>`
`186`	`217`	`/// Convert the fraction into a Stern-Brocot system`
`187`	`218`	`/// </summary>`
`@@ -350,22 +381,31 @@ public static string ToCondensedSternBrocotSystem(string sternBrocotRepresentati`
`350`	`381`	`/// <returns>The simplified form of the fraction.</returns>`
`351`	`382`	`public Fraction Simplify()`
`352`	`383`	`{`
`353`		`- var gdc = Numbers.Get.Gdc(Numbers.Convert.ToPositive(Numerator),`
`354`		`- Numbers.Convert.ToPositive(_denominator));`
	`384`	`+ var gdc = Get.Gdc(Numbers.Convert.ToPositive(Numerator), Numbers.Convert.ToPositive(_denominator));`
`355`	`385`
`356`	`386`	`return new Fraction(Numerator/gdc, _denominator/gdc);`
`357`	`387`	`}`
`358`	`388`
`359`	`389`	`/// <summary>`
`360`		`- /// Find the inverse`
	`390`	`+ /// Gets the inverse of this instance.`
`361`	`391`	`/// </summary>`
`362`	`392`	`/// <example>2/3 -> 3/2</example>`
`363`		`- /// <returns>The inverse of the fraction.</returns>`
	`393`	`+ /// <returns>The inverse of this fraction.</returns>`
`364`	`394`	`public Fraction Inverse()`
`365`	`395`	`{`
`366`	`396`	`return new Fraction(Denominator, Numerator);`
`367`	`397`	`}`
`368`	`398`
	`399`	`+ /// <summary>`
	`400`	`+ /// Gets the reciprocal of this instance.`
	`401`	`+ /// </summary>`
	`402`	`+ /// <example>2/3 -> 3/2</example>`
	`403`	`+ /// <returns>The reciprocal of this fraction.</returns>`
	`404`	`+ public Fraction Reciprocal()`
	`405`	`+ {`
	`406`	`+ return new Fraction(Denominator, Numerator);`
	`407`	`+ }`
	`408`	`+`
`369`	`409`	`/// <summary>`
`370`	`410`	`/// Avoid fractions like 2/-3 (better: -2/3),`
`371`	`411`	`/// and -2/-3 (better: 2/3).`
`@@ -387,7 +427,10 @@ private void FractionChecker()`
`387`	`427`	`/// <returns>Whether <paramref name="fractA"/> is equal to <paramref name="fractB"/>.</returns>`
`388`	`428`	`public static bool operator ==(Fraction fractA, Fraction fractB)`
`389`	`429`	`{`
`390`		`- fractA = fractA.Simplify(); // simplifying, e.g. if a is 4/2, and b 2/1, return true`
	`430`	`+ if (fractA == null \|\| fractB == null)`
	`431`	`+ return fractA == null && fractB == null;`
	`432`	`+`
	`433`	`+ fractA = fractA.Simplify();`
`391`	`434`	`fractB = fractB.Simplify();`
`392`	`435`
`393`	`436`	`return (fractA.Numerator == fractB.Numerator) && (fractA.Denominator == fractB.Denominator);`
`@@ -467,35 +510,34 @@ private void FractionChecker()`
`467`	`510`	`/// <returns><paramref name="fractA"/> added to <paramref name="fractB"/>.</returns>`
`468`	`511`	`public static Fraction operator +(Fraction fractA, Fraction fractB)`
`469`	`512`	`{`
`470`		`- fractA = fractA.Simplify(); // simplifying`
	`513`	`+ fractA = fractA.Simplify();`
`471`	`514`	`fractB = fractB.Simplify();`
`472`	`515`
`473`	`516`	`if (fractA.Denominator == fractB.Denominator)`
`474`	`517`	`{`
`475`		`- var fraction = new Fraction //creating a new fraction`
	`518`	`+ var fraction = new Fraction`
`476`	`519`	`{`
`477`		`- Numerator = fractA.Numerator + fractB.Numerator, // adding the nominators`
`478`		`- Denominator = fractA.Denominator // assigning the denominator`
	`520`	`+ Numerator = fractA.Numerator + fractB.Numerator,`
	`521`	`+ Denominator = fractA.Denominator`
`479`	`522`	`};`
`480`	`523`
`481`		`- return fraction.Simplify(); // a simplified version of the fraction`
	`524`	`+ return fraction.Simplify();`
`482`	`525`	`}`
`483`	`526`
`484`		`- var gdc = Numbers.Get.Gdc(fractA.Denominator, fractB.Denominator);`
	`527`	`+ var gdc = Get.Gdc(fractA.Denominator, fractB.Denominator);`
`485`	`528`
`486`	`529`	`if (gdc == 1)`
`487`	`530`	`{`
`488`		`- // if the denominators are coprimes, i.e. no factors in common`
`489`	`531`	`var fraction = new Fraction`
`490`	`532`	`{`
`491`	`533`	`Numerator = fractA.Numerator * fractB.Denominator + fractB.Numerator * fractA.Denominator,`
`492`	`534`	`Denominator = fractA.Denominator * fractB.Denominator`
`493`	`535`	`};`
`494`	`536`
`495`		`- return fraction.Simplify(); // a simplified version of the fraction`
	`537`	`+ return fraction.Simplify();`
`496`	`538`	`}`
`497`	`539`
`498`		`- if (fractA.Denominator > fractB.Denominator) //fractA.Denominator will be the new denominator`
	`540`	`+ if (fractA.Denominator > fractB.Denominator)`
`499`	`541`	`{`
`500`	`542`	`var fraction = new Fraction`
`501`	`543`	`{`
`@@ -505,7 +547,7 @@ private void FractionChecker()`
`505`	`547`
`506`	`548`	`return fraction.Simplify();`
`507`	`549`	`}`
`508`		`- else //fractB.Denominator will be the new denominator`
	`550`	`+ else`
`509`	`551`	`{`
`510`	`552`	`var fraction = new Fraction`
`511`	`553`	`{`
`@@ -525,34 +567,33 @@ private void FractionChecker()`
`525`	`567`	`/// <returns><paramref name="fractB"/> substracted from <paramref name="fractA"/>.</returns>`
`526`	`568`	`public static Fraction operator -(Fraction fractA, Fraction fractB)`
`527`	`569`	`{`
`528`		`- //addition`
`529`		`- fractA = fractA.Simplify(); // simplifying`
	`570`	`+ fractA = fractA.Simplify();`
`530`	`571`	`fractB = fractB.Simplify();`
`531`	`572`
`532`	`573`	`if (fractA.Denominator == fractB.Denominator)`
`533`	`574`	`{`
`534`		`- var fraction = new Fraction //creating a new fraction`
	`575`	`+ var fraction = new Fraction`
`535`	`576`	`{`
`536`		`- Numerator = fractA.Numerator - fractB.Numerator, // subtracting the nominators`
`537`		`- Denominator = fractA.Denominator // assigning the denominator`
	`577`	`+ Numerator = fractA.Numerator - fractB.Numerator,`
	`578`	`+ Denominator = fractA.Denominator`
`538`	`579`	`};`
`539`		`- return fraction.Simplify(); // a simplified version of the fraction`
	`580`	`+ return fraction.Simplify();`
`540`	`581`	`}`
`541`	`582`
`542`		`- var gdc = Numbers.Get.Gdc(fractA.Denominator, fractB.Denominator);`
	`583`	`+ var gdc = Get.Gdc(fractA.Denominator, fractB.Denominator);`
	`584`	`+`
`543`	`585`	`if (gdc == 1)`
`544`	`586`	`{`
`545`		`- // if the denominators are coprimes, i.e. no factors in common`
`546`	`587`	`var fraction = new Fraction`
`547`	`588`	`{`
`548`	`589`	`Numerator = fractA.Numerator * fractB.Denominator - fractB.Numerator * fractA.Denominator,`
`549`	`590`	`Denominator = fractA.Denominator * fractB.Denominator`
`550`	`591`	`};`
`551`	`592`
`552`		`- return fraction.Simplify(); // a simplified version of the fraction`
	`593`	`+ return fraction.Simplify();`
`553`	`594`	`}`
`554`	`595`
`555`		`- if (fractA.Denominator > fractB.Denominator) //fractA.Denominator will be the new denominator`
	`596`	`+ if (fractA.Denominator > fractB.Denominator)`
`556`	`597`	`{`
`557`	`598`	`var fraction = new Fraction`
`558`	`599`	`{`
`@@ -562,7 +603,7 @@ private void FractionChecker()`
`562`	`603`
`563`	`604`	`return fraction.Simplify();`
`564`	`605`	`}`
`565`		`- else //fractB.Denominator will be the new denominator`
	`606`	`+ else`
`566`	`607`	`{`
`567`	`608`	`var fraction = new Fraction`
`568`	`609`	`{`
`@@ -582,7 +623,7 @@ private void FractionChecker()`
`582`	`623`	`/// <returns><paramref name="fractA"/> multiplied by <paramref name="fractB"/>.</returns>`
`583`	`624`	`public static Fraction operator *(Fraction fractA, Fraction fractB)`
`584`	`625`	`{`
`585`		`- fractA = fractA.Simplify(); // simplifying`
	`626`	`+ fractA = fractA.Simplify();`
`586`	`627`	`fractB = fractB.Simplify();`
`587`	`628`
`588`	`629`	`return new Fraction(fractA.Numerator * fractB.Numerator,`
`@@ -597,7 +638,7 @@ private void FractionChecker()`
`597`	`638`	`/// <returns><paramref name="fractA"/> divided by <paramref name="fractB"/>.</returns>`
`598`	`639`	`public static Fraction operator /(Fraction fractA, Fraction fractB)`
`599`	`640`	`{`
`600`		`- fractA = fractA.Simplify(); // simplifying`
	`641`	`+ fractA = fractA.Simplify();`
`601`	`642`	`fractB = fractB.Simplify();`
`602`	`643`
`603`	`644`	`return new Fraction(fractA.Numerator * fractB.Denominator,`
`@@ -613,12 +654,11 @@ public static implicit operator Fraction(string value)`
`613`	`654`	`{`
`614`	`655`	`Fraction fraction;`
`615`	`656`
`616`		`- if (value.Contains("/")) //checking if the separator exists`
	`657`	`+ if (value.Contains("/"))`
`617`	`658`	`{`
`618`		`- // if it is a string input`
`619`	`659`	`try`
`620`	`660`	`{`
`621`		`- value = value.Trim(' '); // trim away unnessesary stuff`
	`661`	`+ value = value.Trim(' ');`
`622`	`662`
`623`	`663`	`fraction = new Fraction`
`624`	`664`	`{`
`@@ -634,7 +674,7 @@ public static implicit operator Fraction(string value)`
`634`	`674`	`}`
`635`	`675`	`}`
`636`	`676`
`637`		`- value = value.Trim(' '); // trim away unnessesary stuff`
	`677`	`+ value = value.Trim(' ');`
`638`	`678`
`639`	`679`	`fraction = new Fraction`
`640`	`680`	`{`
`@@ -660,7 +700,7 @@ public static implicit operator Fraction(long num)`
`660`	`700`	`/// </summary>`
`661`	`701`	`/// <param name="fraction">The fraction to convert into a double.</param>`
`662`	`702`	`/// <returns>Returns <paramref name="fraction"/> converted into a double.</returns>`
`663`		`- public static implicit operator decimal(Fraction fraction)`
	`703`	`+ public static explicit operator decimal(Fraction fraction)`
`664`	`704`	`{`
`665`	`705`	`return (decimal)fraction.Numerator / fraction.Denominator;`
`666`	`706`	`}`