// plus any other methods you deem necessary to meet the specification
// this method refactors two rational numbers so that they share the same denominators for future calculations and returns an array of two rational numbers sharing the same denominator
private IRationalNumber[] refactoredRationalNumbers(IRationalNumber number1, IRationalNumber number2)
{
IRationalNumber r1 = number1;
IRationalNumber r2 = number2;
//checking to see if they allready share the same denominator or not
if (r1.Denominator == r2.Denominator)
{
//returning rational numbers as is when they share the same denominator
IRationalNumber[] rationalNumbers = { r1, r2 };
return(rationalNumbers);
}
else
{
// converting rational number one to have the same denominator as rational number two
int numerator1 = r1.Numerator * r2.Denominator;
int demoniator1 = r1.Denominator * r2.Denominator;
// convertin rational number two to have the same denominator as rational number 1
int numerator2 = r2.Numerator * r1.Denominator;
int denominator2 = r2.Denominator * r1.Denominator;
IRationalNumber[] rationalNumbers = { new RationalNumber(numerator1, demoniator1), new RationalNumber(numerator2, denominator2) };
return(rationalNumbers);
}
}
/// <summary>
/// Returns a new rational number representing the subtraction of two rational numbers
/// objA - ObjB = ObjC
/// </summary>
/// <param name="number">IRationalNumber</param>
/// <returnsIRationalNumber></returns>
public IRationalNumber Subtract(IRationalNumber number)
{
var fraction = ToRational(number);
var numerator = (Numerator * fraction.GetDenominator()) - (fraction.GetNumerator() * Denominator);
var denominator = (Denominator * fraction.GetDenominator());
return(new RationalNumber(numerator, denominator));
}
/// <summary>
/// Returns a new rational number representing the division of two rational numbers
/// objA / ObjB = ObjC
/// </summary>
/// <param name="number">IRationalNumber</param>
/// <returns>IRationalNumber</returns>
public IRationalNumber Divide(IRationalNumber number)
{
var fraction = ToRational(number);
var numerator = Numerator * fraction.GetDenominator();
var denominator = Denominator * fraction.GetNumerator();
return(new RationalNumber(numerator, denominator));
}
// Divides 2 rational numbers and returns new number reduced to lowest terms
public IRationalNumber Divide(IRationalNumber number)
{
var rationalNumber = (RationalNumber)number;
var(newNumerator, newDenominator) = (Numerator * rationalNumber.Denominator, Denominator *rationalNumber.Numerator);
return(new RationalNumber(newNumerator, newDenominator).Reduce());
}
public IRationalNumber Multiply(IRationalNumber number)
{
IRationalNumber r1 = new RationalNumber(this.Numerator, this.Denominator);
IRationalNumber r2 = number;
// returning the result of simply multiplying both numerators and denominators of the rational numbers
return(new RationalNumber(r1.Numerator * r2.Numerator, r1.Denominator * r2.Denominator).Reduce());
//throw new NotImplementedException();
}
public IRationalNumber Divide(IRationalNumber number)
{
IRationalNumber r1 = new RationalNumber(this.Numerator, this.Denominator);
IRationalNumber r2 = number;
// returning the result of multiplying the first rational number and the inverse of the second rational number
return(new RationalNumber(r1.Numerator * r2.Denominator, r1.Denominator * r2.Numerator).Reduce());
//throw new NotImplementedException();
}
/// <summary>
/// Shows the operands and the logic of subtracting two fractions.
/// </summary>
/// <param name="a">IrationalNumber</param>
/// <param name="b">IrationalNumber</param>
/// <returns>Void</returns>
public static string ShowSubtraction(this IRationalNumber a, IRationalNumber b)
{
var first = (RationalNumber)a;
var second = (RationalNumber)b;
var numerator = $"{first.Numerator} * {second.Denominator} - {second.Numerator} * {first.Denominator}";
var denominator = $"{first.Denominator} * {second.Denominator}";
var result = new RationalNumber((first.Numerator * second.Denominator - second.Numerator * first.Denominator), (first.Denominator * second.Denominator));
return($"Subtraction: The numerator is equal to {numerator} and the denominator is equal to {denominator}, result is {result}");
}
public IRationalNumber Subtract(IRationalNumber number)
{
IRationalNumber r1 = new RationalNumber(this.Numerator, this.Denominator);
IRationalNumber r2 = number;
// calling the method refactoredNumbers to ensure both numbers share the same denominator
IRationalNumber[] NumbersToSubtract = refactoredRationalNumbers(r1, r2);
r1 = NumbersToSubtract[0];
r2 = NumbersToSubtract[1];
//returning the result of the
return(new RationalNumber(r1.Numerator - r2.Numerator, r1.Denominator).Reduce());
}
public IRationalNumber Add(IRationalNumber number)
{
IRationalNumber r1 = new RationalNumber(this.Numerator, this.Denominator);
IRationalNumber r2 = number;
// calling the method refactoredNumbers to ensure both numbers share the same denominator
IRationalNumber[] NumbersToAdd = refactoredRationalNumbers(r1, r2);
r1 = NumbersToAdd[0];
r2 = NumbersToAdd[1];
return(new RationalNumber((r1.Numerator + r2.Numerator), r1.Denominator).Reduce());
//throw new NotImplementedException();
}
/// <summary>
/// Multiplies this rational number with <paramref name="number"/>.
/// This method does not modify existing rational numbers.
/// </summary>
/// <param name="number">A rational number.</param>
/// <returns>The product of this rational number and <paramref name="number"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="number"/> is null.</exception>
public IRationalNumber Multiply(IRationalNumber number)
{
if (number == null)
{
throw new ArgumentNullException("Number cannot be null.");
}
int newNumerator = Numerator * number.Numerator;
int newDenominator = Denominator * number.Denominator;
return(new RationalNumber(newNumerator, newDenominator));
}
public IRationalNumber Divide(IRationalNumber number)
{
RationalNumber r2 = (RationalNumber)number;
try {
return(new RationalNumber((this.Numerator * r2.Denominator), (this.Denominator * r2.Numerator)).Reduce()); //https://www.helpwithfractions.com/dividing-fractions
}
catch (DivideByZeroException ex)
{
throw new DivideByZeroException("Error trying to multiply two fractions: {0}", ex);
}
}
// Subtracts one rational number
public IRationalNumber Subtract(IRationalNumber number)
{
var rationalNumber = (RationalNumber)number;
var(numerator2, denominator2) = (rationalNumber.Numerator, rationalNumber.Denominator);
int newNumerator = (Numerator * denominator2 - numerator2 * Denominator);
int newDenominator = (Denominator * denominator2);
if (newNumerator == 0)
{
return(new RationalNumber(0, 1));
}
return(new RationalNumber(newNumerator, newDenominator).Reduce());
}
public IRationalNumber Add(IRationalNumber number)
{
var rationalNumber = (RationalNumber)number;
var(numerator2, denominator2) = (rationalNumber.Numerator, rationalNumber.Denominator);
int newNumerator = Numerator * denominator2 + numerator2 * Denominator;
int newDenominator = Denominator * denominator2;
if (newNumerator == 0)
{
return(new RationalNumber(0, 1));
}
return(new RationalNumber(newNumerator, newDenominator).Reduce());
}
/// <summary>
/// Compares this rational number with another object.
/// </summary>
/// <param name="obj"></param>
/// <returns>True if this rational number is equal to <paramref name="obj"/>.</returns>
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (!(obj is RationalNumber))
{
return(false);
}
IRationalNumber other = (RationalNumber)obj;
return(Numerator == other.Numerator && Denominator == other.Denominator);
}
/// <summary>
/// Divides this rational number by <paramref name="number"/>.
/// This method does not modify existing rational numbers.
/// </summary>
/// <param name="number">A rational number.</param>
/// <returns>A new rational number that is the quotient of this and <paramref name="number"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="number"/>is null.</exception>
/// <exception cref="DivideByZeroException">Thrown if <paramref name="number"/>is zero.</exception>
public IRationalNumber Divide(IRationalNumber number)
{
if (number == null)
{
throw new ArgumentNullException("Number cannot be null.");
}
if (number.Numerator == 0)
{
throw new DivideByZeroException("Number cannot be zero.");
}
int newNumerator = Numerator * number.Denominator;
int newDenominator = Denominator * number.Numerator;
return(new RationalNumber(newNumerator, newDenominator));
}
static void Main()
{
Console.WriteLine("Welcome to the fraction calculator!.\n");
Console.WriteLine("To create a new Rational Number do as follows => IrationalNumber fraction = new RationalNumber(a , b ).\n");
Console.WriteLine("Where a is any positive or negative integer and b != 0.\n");
Console.WriteLine("Parameters can be: - A single integer to express rational numbers in the form a/1\n");
Console.WriteLine("Parameters can be: - Two integers to express rational numbers in the form a/b\n");
Console.WriteLine("Parameters can be: - Strings in the form \"a\" \"a\\b\" or \"a b\" \n");
Console.WriteLine("You can perform arithmetic operations on IrationalNumber objects using the inline operators + - * /\n");
Console.WriteLine("For example:\n");
Console.WriteLine("IrationalNumber fractionA = new RationalNumber(a1 , b1 ).\n");
Console.WriteLine("IrationalNumber fractionB = new RationalNumber(a2 , b2 ).\n");
Console.WriteLine("IrationalNumber fractionC = fractionA + fractionB\n");
Console.WriteLine("Alternatively you can do obj1.Add(obj2), obj1.Subtract(obj2), obj1.Multiply(obj2), obj1.Divide(obj2)\n");
Console.WriteLine("You can also do exponentiation of a real number in two ways, 1) integer.ExpReal(obj1) or 2) ExpReal(this int intNumber, RationalNumber r).\n");
Console.WriteLine("You can also exponentiate a rational number obj1.ExpRational(integer)\n");
IRationalNumber fractionA = new RationalNumber(1, 2);
IRationalNumber fractionB = new RationalNumber("2");
IRationalNumber fractionC = new RationalNumber("2/5");
IRationalNumber fractionD = new RationalNumber("2 6");
IRationalNumber fractionF = fractionA + fractionB;
Console.WriteLine("*************");
Console.WriteLine(IntNumberExtension.ShowMultiplication(fractionA, fractionB));
Console.WriteLine("*************");
Console.WriteLine(IntNumberExtension.ShowMultiplication(fractionA, fractionB));
Console.WriteLine("*************");
Console.WriteLine(IntNumberExtension.ShowDivision(fractionA, fractionB));
Console.WriteLine("*************");
Console.WriteLine(IntNumberExtension.ShowAddition(fractionA, fractionB));
Console.WriteLine("*************");
Console.WriteLine(IntNumberExtension.ShowSubtraction(fractionA, fractionB));
Console.WriteLine("*************");
Console.WriteLine($"Thanks to the operator overload we can also do this {fractionA} + {fractionB} = {fractionF}");
Console.WriteLine("*************");
}
/// <summary>
/// Cast an IRationalNumber into a RationalNumber.
/// We thought it looks neater although the effect is the same as casting the object directly.
/// </summary>
/// <param name="f">IRationalNumber</param>
/// <returns>RationalNumber</returns>
private RationalNumber ToRational(IRationalNumber f)
{
return((RationalNumber)f);
}
/// <summary>
/// Overload method of Divide(), this one allows the use of the inline operator "/"
/// </summary>
/// <param name="r1">IRationalNumber</param>
/// <param name="r2">IRationalNumber</param>
/// <returns>IRationalNumber</returns>
static IRationalNumber Divide(IRationalNumber r1, IRationalNumber r2)
{
return(r1.Divide(r2));
}
public IRationalNumber Subtract(IRationalNumber number)
{
RationalNumber r2 = (RationalNumber)number;
return(new RationalNumber((this.Numerator * r2.Denominator - r2.Numerator * this.Denominator), (this.Denominator * r2.Denominator)).Reduce());
}
/// <summary>
/// Overload method of Multiply(), this one allows the use of the inline operator "*"
/// </summary>
/// <param name="r1"></param>
/// <param name="r2"></param>
/// <returns></returns>
static IRationalNumber Multiply(IRationalNumber r1, IRationalNumber r2)
{
return(r1.Multiply(r2));
}
/// <summary>
/// Overload method of Substract(), this one allows the use of the inline operator "-"
/// </summary>
/// <param name="r1">IRationalNumber</param>
/// <param name="r2">IRationalNumber</param>
/// <returns>IRationalNumber</returns>
static IRationalNumber Subtract(IRationalNumber r1, IRationalNumber r2)
{
return(r1.Subtract(r2));
}
/// <summary>
/// Overload method of Add(), this one allows the use of the inline operator "+"
/// </summary>
/// <param name="r1">IRationalNumber</param>
/// <param name="r2">IRationalNumber</param>
/// <returns>IRationalNumber</returns>
static IRationalNumber Add(IRationalNumber r1, IRationalNumber r2)
{
return(r1.Add(r2));
}
public IRationalNumber Multiply(IRationalNumber number)
{
RationalNumber r2 = (RationalNumber)number;
return(new RationalNumber((this.Numerator * r2.Numerator), (this.Denominator * r2.Denominator)).Reduce());
}
