tsai
/
ImageSharp
mirror of https://github.com/SixLabors/ImageSharp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Clean up rationals [skip ci] 

Former-commit-id: ad694de554cb1cbec984f5af7abde6885649b2cc
Former-commit-id: 7d411118b462d6451d386c6915c6d31ddc7289c8
Former-commit-id: dd60d42bb56b148f630bd1ad3d7af8e5e9bb5764
pull/1/head
James Jackson-South 10 years ago
parent
cf112f604d
commit
ea6ac37273
4 changed files with 494 additions and 378 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 219
      src/ImageProcessorCore/Numerics/BigRational.cs
  2. 355
      src/ImageProcessorCore/Numerics/LongRational.cs
  3. 148
      src/ImageProcessorCore/Numerics/Rational.cs
  4. 150
      src/ImageProcessorCore/Numerics/SignedRational.cs

219
src/ImageProcessorCore/Numerics/BigRational.cs
View File

@ -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();
}
}
}

355
src/ImageProcessorCore/Numerics/LongRational.cs
View File

@ -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();
}
}
}

148
src/ImageProcessorCore/Numerics/Rational.cs
View File

@ -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>
public Rational(double value)
: this(value, false)
/// <param name="value">The <see cref="uint"/> to create the rational from.</param>
public Rational(uint value)
: 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="bestPrecision">Specifies if the instance should be created with the best precision possible.</param>
public Rational(double value, bool bestPrecision)
/// <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 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>
public Rational(uint value)
: this(value, 1)
/// <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">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="denominator">The number below the line in a vulgar fraction; a divisor.</param>
public Rational(uint numerator, uint denominator)
: this(numerator, denominator, true)
/// <param name="value">The <see cref="double"/> to create the instance from.</param>
public Rational(double value)
: this(value, false)
{
}
/// <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="denominator">The number below the line in a vulgar fraction; a divisor.</param>
/// <param name="simplify">Specified if the rational should be simplified.</param>
public Rational(uint numerator, uint denominator, bool simplify)
/// <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 Rational(double value, bool bestPrecision)
{
BigRational rational = new BigRational(numerator, denominator, simplify);
LongRational rational = new LongRational(Math.Abs(value), bestPrecision);
Numerator = (uint)rational.Numerator;
Denominator = (uint)rational.Denominator;
this.Numerator = (uint)rational.Numerator;
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;
private set;
return new Rational(value, false);
}
/// <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;
private set;
return new Rational(value, bestPrecision);
}
///<summary>
/// 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>
/// <inheritdoc/>
public override bool Equals(object obj)
{
if (obj is Rational)
return Equals((Rational)obj);
{
return this.Equals((Rational)obj);
}
return false;
}
///<summary>
/// 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>
/// <inheritdoc/>
public bool Equals(Rational other)
{
BigRational left = new BigRational(Numerator, Denominator);
BigRational right = new BigRational(other.Numerator, other.Denominator);
LongRational left = new LongRational(this.Numerator, this.Denominator);
LongRational right = new LongRational(other.Numerator, other.Denominator);
return left.Equals(right);
}
///<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>
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>
/// <inheritdoc/>
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>
/// Converts the numeric value of this instance to its equivalent string representation.
/// </summary>
/// <inheritdoc/>
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);
}
}

150
src/ImageProcessorCore/Numerics/SignedRational.cs
View File

@ -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>
public SignedRational(double value)
: this(value, false)
/// <param name="value">The <see cref="int"/> to create the rational from.</param>
public SignedRational(int value)
: 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="bestPrecision">Specifies if the instance should be created with the best precision possible.</param>
public SignedRational(double value, bool bestPrecision)
/// <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 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>
public SignedRational(int value)
: this(value, 1)
/// <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">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="denominator">The number below the line in a vulgar fraction; a divisor.</param>
public SignedRational(int numerator, int denominator)
: this(numerator, denominator, true)
/// <param name="value">The <see cref="double"/> to create the instance from.</param>
public SignedRational(double value)
: this(value, false)
{
}
/// <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="denominator">The number below the line in a vulgar fraction; a divisor.</param>
/// <param name="simplify">Specified if the rational should be simplified.</param>
public SignedRational(int numerator, int denominator, bool simplify)
/// <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 SignedRational(double value, bool bestPrecision)
{
BigRational rational = new BigRational(numerator, denominator, simplify);
LongRational rational = new LongRational(value, bestPrecision);
Numerator = (int)rational.Numerator;
Denominator = (int)rational.Denominator;
this.Numerator = (int)rational.Numerator;
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;
private set;
return new SignedRational(value, false);
}
/// <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;
private set;
return new SignedRational(value, bestPrecision);
}
///<summary>
/// 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>
/// <inheritdoc/>
public override bool Equals(object obj)
{
if (obj is SignedRational)
return Equals((SignedRational)obj);
{
return this.Equals((SignedRational)obj);
}
return false;
}
///<summary>
/// 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>
/// <inheritdoc/>
public bool Equals(SignedRational other)
{
BigRational left = new BigRational(Numerator, Denominator);
BigRational right = new BigRational(other.Numerator, other.Denominator);
LongRational left = new LongRational(this.Numerator, this.Denominator);
LongRational right = new LongRational(other.Numerator, other.Denominator);
return left.Equals(right);
}
///<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>
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>
/// <inheritdoc/>
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>
/// Converts the numeric value of this instance to its equivalent string representation.
/// </summary>
/// <inheritdoc/>
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);
}
}

Write Preview
Loading…
Cancel
Save