public void Divide_AnyThing()
{
// arrange
Fraction expected1 = new Fraction(10, 1);
Fraction expected2 = new Fraction(4, 3);
Fraction expected3 = new Fraction(6, 5);
Fraction expected4 = new Fraction(4, 15);
Fraction expected5 = new Fraction(6, 15);
Fraction expected6 = new Fraction(9, 8);
// action
Fraction actual1 = FractionOperations.Divide(new Fraction(2), new Fraction(1, 5));
Fraction actual2 = FractionOperations.Divide(new Fraction(2), new Fraction(3, 2));
Fraction actual3 = FractionOperations.Divide(new Fraction(2), new Fraction(1, 2, 3));
Fraction actual4 = FractionOperations.Divide(new Fraction(2, 3), new Fraction(5, 2));
Fraction actual5 = FractionOperations.Divide(new Fraction(2, 3), new Fraction(1, 2, 3));
Fraction actual6 = FractionOperations.Divide(new Fraction(3, 2), new Fraction(1, 1, 3));
// assert
Assert.AreEqual(expected1, actual1, "Dividing whole number with proper fraction yielded an invalid result");
Assert.AreEqual(expected2, actual2, "Dividing whole number with improper fraction yielded an invalid result");
Assert.AreEqual(expected3, actual3, "Dividing whole number with mixed number fraction fractions yielded an invalid result");
Assert.AreEqual(expected4, actual4, "Dividing proper with improper fractions yielded an invalid result");
Assert.AreEqual(expected3, actual3, "Dividing proper with mixed number fractions yielded an invalid result");
Assert.AreEqual(expected4, actual4, "Dividing improper with mixed number fractions yielded an invalid result");
}
public void Multiply_Negatives()
{
// arrange
Fraction fraction1a = new Fraction(2);
Fraction fraction1b = new Fraction(-3);
Fraction fraction2a = new Fraction(3, 4);
Fraction fraction2b = new Fraction(-2, 5);
Fraction fraction3a = new Fraction(1, 1, 2);
Fraction fraction3b = new Fraction(-1, 2, 3);
Fraction expected1 = new Fraction(-6, 1);
Fraction expected2 = new Fraction(-6, 20);
Fraction expected3 = new Fraction(-15, 6);
Fraction expected4 = new Fraction(4, 25);
// action
Fraction actual1 = FractionOperations.Multiply(fraction1a, fraction1b);
Fraction actual2 = FractionOperations.Multiply(fraction2a, fraction2b);
Fraction actual3 = FractionOperations.Multiply(fraction3a, fraction3b);
Fraction actual4 = FractionOperations.Multiply(fraction2b, fraction2b);
// assert
Assert.AreEqual(expected1.WholePart, actual1.WholePart, "Invalid result when multiplying positive whole with negative whole.");
Assert.AreEqual(expected2, actual2, "Invalid result when multiplying positive proper with negative proper.");
Assert.AreEqual(expected3, actual3, "Invalid result when multiplying positive mixed number with negative mixed number");
Assert.AreEqual(expected4, actual4, "Invalid result when multiplying two negative proper fractions.");
}
public void IsEquivalent_IsValidTrue()
{
// arrange
Fraction fraction1a = new Fraction(3);
Fraction fraction1b = new Fraction(6, 2);
Fraction fraction2a = new Fraction(1, 4);
Fraction fraction2b = new Fraction(3, 12);
Fraction fraction3a = new Fraction(3, 2);
Fraction fraction3b = new Fraction(6, 4);
Fraction fraction4a = new Fraction(1, 1, 2);
Fraction fraction4b = new Fraction(1, 3, 6);
//Boolean expected = true;
// action
Boolean actual1 = FractionOperations.IsEquivalent(fraction1a, fraction1b);
Boolean actual2 = FractionOperations.IsEquivalent(fraction2a, fraction2b);
Boolean actual3 = FractionOperations.IsEquivalent(fraction3a, fraction3b);
Boolean actual4 = FractionOperations.IsEquivalent(fraction4a, fraction4b);
// assert
Assert.IsTrue(actual1, "Result not equivalent for whole number and improper fraction.");
Assert.IsTrue(actual2, "Result not equivalent for proper fractions.");
Assert.IsTrue(actual3, "Result not equivalent for improper fractions.");
Assert.IsTrue(actual4, "Result not equivalent for mixed number fractions.");
}
public static void Main()
{
var fraction1 = new Fraction(22, 7);
var fraction2 = new Fraction(40, 4);
Console.WriteLine("Fraction 1: {0}/{1} \r\nFraction 2: {2}/{3}\r\n--------------------\r\n",
fraction1.Numerator, fraction1.Denominator, fraction2.Numerator, fraction2.Denominator);
var oprations = new[] { "Add", "Subtract", "Multiply", "Divide", "Power" };
int index = 0;
var fractionOperations = new List<Fraction>
{
fraction1 + fraction2,
fraction1 - fraction2,
fraction1 * fraction2,
fraction1 / fraction2,
fraction1 ^ 2
};
foreach (var opetarion in fractionOperations)
{
Console.WriteLine("{0}\r\nFraction: {1} \r\nResult: {2}",
oprations[index++], opetarion, (double)opetarion + Environment.NewLine);
}
try
{
new Fraction(22, 0);
}
catch (ArithmeticException e)
{
Console.WriteLine(e.Message);
}
}
public void Subtract_MixedTypedPositives()
{
// arrange
Fraction fraction1 = new Fraction(1);
Fraction fraction2 = new Fraction(1, 2);
Fraction fraction3 = new Fraction(3, 2);
Fraction fraction4 = new Fraction(1, 2, 3);
Fraction expected1 = new Fraction(1, 2);
Fraction expected2 = new Fraction(1, 2);
Fraction expected3 = new Fraction(2, 3);
Fraction expected4 = new Fraction(2, 2);
Fraction expected5 = new Fraction(7, 6);
Fraction expected6 = new Fraction(1, 6);
// aciton
Fraction actual1 = FractionOperations.Subtract(fraction1, fraction2);
Fraction actual2 = FractionOperations.Subtract(fraction3, fraction1);
Fraction actual3 = FractionOperations.Subtract(fraction4, fraction1);
Fraction actual4 = FractionOperations.Subtract(fraction3, fraction2);
Fraction actual5 = FractionOperations.Subtract(fraction4, fraction2);
Fraction actual6 = FractionOperations.Subtract(fraction4, fraction3);
// assert
Assert.AreEqual(expected1, actual1, "Invalid difference of a whole number and a proper fraction.");
Assert.AreEqual(expected2, actual2, "Invalid difference of whole number and an improper fraction.");
Assert.AreEqual(expected3, actual3, "Invalid difference of whole number and an mixed number fraction.");
Assert.AreEqual(expected4, actual4, "Invalid difference of a proper fraction and an improper fraction.");
Assert.AreEqual(expected5, actual5, "Invalid difference of a proper fraction and a mixed number fraction.");
Assert.AreEqual(expected5, actual5, "Invalid difference of an improper fraction a mixed number fraction.");
}
public void MakeImproper_IsValidResult()
{
// arrange
Fraction fraction1 = new Fraction(2);
Fraction fraction2 = new Fraction(3, 5);
Fraction fraction3 = new Fraction(4, 3);
Fraction fraction4 = new Fraction(1, 1, 2);
Fraction expected1 = new Fraction(2, 1);
Fraction expected2 = new Fraction(3, 5);
Fraction expected3 = new Fraction(4, 3);
Fraction expected4 = new Fraction(3, 2);
// action
Fraction actual1 = FractionOperations.MakeImproper(fraction1);
Fraction actual2 = FractionOperations.MakeImproper(fraction2);
Fraction actual3 = FractionOperations.MakeImproper(fraction3);
Fraction actual4 = FractionOperations.MakeImproper(fraction4);
// assert
Assert.AreEqual(expected1, actual1, "Invalid Improper fraction result for whole number.");
Assert.AreEqual(expected2, actual2, "Invalid Improper fraction result for proper fraction.");
Assert.AreEqual(expected3, actual3, "Invalid Improper fraction result for improper fraction.");
Assert.AreEqual(expected4, actual4, "Invalid Improper fraction result for mixed number.");
}
public void FindReciprocal_IsValidResultNegative()
{
// arrange
Fraction fraction1 = new Fraction(-3);
Fraction fraction2 = new Fraction(-1, 6);
Fraction fraction3 = new Fraction(-4, 3);
Fraction fraction4 = new Fraction(-1, 2, 5);
Fraction expected1 = new Fraction(-1, 3);
Fraction expected2 = new Fraction(-6, 1);
Fraction expected3 = new Fraction(-3, 4);
Fraction expected4 = new Fraction(-5, 7);
// action
Fraction actual1 = FractionOperations.FindReciprocal(fraction1);
Fraction actual2 = FractionOperations.FindReciprocal(fraction2);
Fraction actual3 = FractionOperations.FindReciprocal(fraction3);
Fraction actual4 = FractionOperations.FindReciprocal(fraction4);
// assert
Assert.AreEqual(expected1, actual1, "Invalid reciprocal fraction for negative whole number.");
Assert.AreEqual(expected2, actual2, "Invalid reciprocal fraction for negative proper fraction.");
Assert.AreEqual(expected3, actual3, "Invalid reciprocal fraction for negative improper fraction.");
Assert.AreEqual(expected4, actual4, "Invalid reciprocal fraction for negative mixed number.");
}
public void MakeImproper_IsValidForNegatives()
{
// arrange
Fraction fraction1 = new Fraction(-2);
Fraction fraction2 = new Fraction(-3, 5);
Fraction fraction3 = new Fraction(-4, 3);
Fraction fraction4 = new Fraction(-1, 1, 2);
Fraction expected1 = new Fraction(-2, 1);
Fraction expected2 = new Fraction(-3, 5);
Fraction expected3 = new Fraction(-4, 3);
Fraction expected4 = new Fraction(-3, 2);
// action
Fraction actual1 = FractionOperations.MakeImproper(fraction1);
Fraction actual2 = FractionOperations.MakeImproper(fraction2);
Fraction actual3 = FractionOperations.MakeImproper(fraction3);
Fraction actual4 = FractionOperations.MakeImproper(fraction4);
// assert
Assert.AreEqual(expected1, actual1, "Invalid Improper fraction result for negative whole number.");
Assert.AreEqual(expected2, actual2, "Invalid Improper fraction result for negative proper fraction.");
Assert.AreEqual(expected3, actual3, "Invalid Improper fraction result for negative improper fraction.");
Assert.AreEqual(expected4, actual4, "Invalid Improper fraction result for negative mixed number.");
}
protected void Page_Load(object sender, EventArgs e)
{
try {
/*
int num1 = 4, num2 = 0;
strList = String.Format("Common Multiples of {0} and {1}: ", num1, num2);
IEnumerable<int> factorList = Factors.Factors.ListCommonMultiples(num1,num2);
foreach(int i in factorList){
strList += String.Format("{0} ", i);
}
*/
Fraction fraction1 = new Fraction(3, 2);
Fraction fraction2 = new Fraction(4, 2);
Fraction total = FractionOperations.Add(fraction1, fraction2);
lblResult.Text = String.Format("{0}/{1} ", fraction1.Numerator, fraction1.Denominator);
lblResult.Text += String.Format("+ {0}/{1} ", fraction2.Numerator, fraction2.Denominator);
lblResult.Text += String.Format("= {0}/{1} ", total.Numerator, total.Denominator);
lblResult.Text += "<br />" ;
IEnumerable someList = Factors.FindPrimeFactors(24);
foreach (DictionaryEntry item in someList){
lblResult.Text += item.Key +"^" + item.Value + " ";
}
//lblResult.Text = String.Format("{0}/{1} + {2}/{3} = {4}/{5}", fraction1.Numerator.ToString(), fraction1.Denominator.ToString(), fraction2.Numerator.ToString(), fraction2.Denominator.ToString());
} catch(ArgumentException ex) {
lblResult.Text = "Argument exception: " + ex.Message;
} catch(Exception ex) {
lblResult.Text = "General exception: " + ex.Message;
}
}
public void FindReduced_IsValidNegative()
{
// arrange
Fraction fraction1 = new Fraction(-3);
Fraction fraction2 = new Fraction(-3, 6);
Fraction fraction3 = new Fraction(-6, 3);
Fraction fraction4 = new Fraction(-1, 3, 6);
Fraction expected1 = new Fraction(-3, 1);
Fraction expected2 = new Fraction(-1, 2);
Fraction expected3 = new Fraction(-2, 1);
Fraction expected4 = new Fraction(-3, 2);
// action
Fraction actual1 = FractionOperations.FindReduced(fraction1);
Fraction actual2 = FractionOperations.FindReduced(fraction2);
Fraction actual3 = FractionOperations.FindReduced(fraction3);
Fraction actual4 = FractionOperations.FindReduced(fraction4);
// assert
Assert.AreEqual(expected1, actual1, "Invalid reduced fraction for negative whole number.");
Assert.AreEqual(expected2, actual2, "Invalid reduced fraction for negative proper fraction.");
Assert.AreEqual(expected3, actual3, "Invalid reduced fraction for negative improper fraction.");
Assert.AreEqual(expected4, actual4, "Invalid reduced fraction for negative mixed number.");
}
public void ToString_IsValid()
{
// arrange
Fraction fraction1 = new Fraction(2);
Fraction fraction2 = new Fraction(-4);
Fraction fraction3 = new Fraction(1, 2);
Fraction fraction4 = new Fraction(-3, 2);
Fraction fraction5= new Fraction(1, 2, 3);
Fraction fraction6 = new Fraction(-2, 4, 5);
string expected1 = "2";
string expected2 = "-4";
string expected3 = "1/2";
string expected4 = "-3/2";
string expected5 = "1 2/3";
string expected6 = "-2 4/5";
// action
string actual1 = fraction1.ToString();
string actual2 = fraction2.ToString();
string actual3 = fraction3.ToString();
string actual4 = fraction4.ToString();
string actual5 = fraction5.ToString();
string actual6 = fraction6.ToString();
// assert
Assert.AreEqual(expected1, actual1, "Invalid string for positive whole integer.");
Assert.AreEqual(expected2, actual2, "Invalid string for negative whole integer.");
Assert.AreEqual(expected3, actual3, "Invalid string for positive proper fraction.");
Assert.AreEqual(expected4, actual4, "Invalid string for negative improper fraction.");
Assert.AreEqual(expected5, actual5, "Invalid string for positive mixed number fraction.");
Assert.AreEqual(expected6, actual6, "Invalid string for negative mixed number fraction.");
}
public void Compare_IsValidGreaterThanWithDiffferentTypes()
{
// arrange
Fraction fraction1 = new Fraction(3);
Fraction fraction2 = new Fraction(1, 2);
Fraction fraction3 = new Fraction(5, 2);
Fraction fraction4 = new Fraction(2, 1, 4);
int expected = 1;
// action
int actual1 = FractionOperations.Compare(fraction1, fraction2);
int actual2 = FractionOperations.Compare(fraction1, fraction3);
int actual3 = FractionOperations.Compare(fraction1, fraction4);
int actual4 = FractionOperations.Compare(fraction3, fraction2);
int actual5 = FractionOperations.Compare(fraction4, fraction2);
int actual6 = FractionOperations.Compare(fraction3, fraction4);
// assert
Assert.AreEqual(expected, actual1, "Invalid greater than comparison result for whole number and improper fraction.");
Assert.AreEqual(expected, actual2, "Invalid greater than comparison result for whole number and proper fraction.");
Assert.AreEqual(expected, actual3, "Invalid greater than comparison result for whole number and improper fraction.");
Assert.AreEqual(expected, actual4, "Invalid greater than comparison result for proper and improper fractions.");
Assert.AreEqual(expected, actual5, "Invalid greater than comparison result for proper and mixed number fractions.");
Assert.AreEqual(expected, actual6, "Invalid greater than comparison result for improper and mixed number fractions.");
}
public static Fraction operator -(Fraction a, Fraction b)
{
Fraction x = new Fraction();
x.Numerator = a.Numerator * b.Denominator - b.Numerator * a.Denominator;
x.Denominator = a.Denominator * b.Denominator;
return x;
}
public void Fraction_NegativeArgument_3()
{
// arrange
Fraction fraction1 = new Fraction(1, -2, 5);
Fraction fraction2 = new Fraction(1, 2, -5);
Fraction fraction3 = new Fraction(1, -2, -5);
Fraction fraction4 = new Fraction(-1, -2, 5);
Fraction fraction5 = new Fraction(-1, 2, -5);
Fraction fraction6 = new Fraction(-1, -2, -5);
// assert
Assert.AreEqual(-1, fraction1.WholePart, "Invalid whole part for three parameters constructor with a positive whole part, negative numerator.");
Assert.AreEqual(2, fraction1.Numerator, "Invalid numerator for three parameters constructor with apositive whole part, negative numerator.");
Assert.AreEqual(5, fraction1.Denominator, "Invalid denominator for three parameters constructor with a positive whole part, negative numerator.");
Assert.AreEqual(-1, fraction2.WholePart, "Invalid whole part for three parameters constructor with a positive whole part, negative denominator.");
Assert.AreEqual(2, fraction2.Numerator, "Invalid numerator for three parameters constructor with a positive whole part, negative denominator.");
Assert.AreEqual(5, fraction2.Denominator, "Invalid denominator for three parameters constructor with a positive whole part, negative denominator.");
Assert.AreEqual(1, fraction3.WholePart, "Invalid whole part for three parameters constructor with a positive whole part, negative numerator and denominator.");
Assert.AreEqual(2, fraction3.Numerator, "Invalid numerator for three parameters constructor with a negative numerator and denominator.");
Assert.AreEqual(5, fraction3.Denominator, "Invalid denominator three two parameters constructor with a positive whole part, negative numerator and denominator.");
Assert.AreEqual(1, fraction4.WholePart, "Invalid whole part for three parameters constructor with a negative whole part, negative numerator.");
Assert.AreEqual(2, fraction4.Numerator, "Invalid numerator for three parameters constructor with a negative whole part, negative numerator.");
Assert.AreEqual(5, fraction4.Denominator, "Invalid denominator for three parameters constructor with a negative whole part, negative numerator.");
Assert.AreEqual(1, fraction5.WholePart, "Invalid whole part for three parameters constructor with a negative whole part, negative denominator.");
Assert.AreEqual(2, fraction5.Numerator, "Invalid numerator for three parameters constructor with a positive whole part, negative denominator.");
Assert.AreEqual(5, fraction5.Denominator, "Invalid denominator for three parameters constructor with a positive whole part, negative denominator.");
Assert.AreEqual(-1, fraction6.WholePart, "Invalid whole part for three parameters constructor with a negative whole part, negative numerator and denominator.");
Assert.AreEqual(2, fraction6.Numerator, "Invalid numerator for three parameters constructor with a negative numerator and denominator.");
Assert.AreEqual(5, fraction6.Denominator, "Invalid denominator three two parameters constructor with a positive whole part, negative numerator and denominator.");
}
public void Compare_IsValidEqualWithSameType()
{
// arrange
Fraction fraction1a = new Fraction(2);
Fraction fraction1b = new Fraction(2);
Fraction fraction2a = new Fraction(1, 2);
Fraction fraction2b = new Fraction(1, 2);
Fraction fraction3a = new Fraction(3, 2);
Fraction fraction3b = new Fraction(3, 2);
Fraction fraction4a = new Fraction(1, 1, 8);
Fraction fraction4b = new Fraction(1, 1, 8);
int expected = 0;
// action
int actual1 = FractionOperations.Compare(fraction1a, fraction1b);
int actual2 = FractionOperations.Compare(fraction2a, fraction2b);
int actual3 = FractionOperations.Compare(fraction3a, fraction3b);
int actual4 = FractionOperations.Compare(fraction4a, fraction4b);
// assert
Assert.AreEqual(expected, actual1, "Invalid equal comparison result for two whole numbers.");
Assert.AreEqual(expected, actual2, "Invalid equal comparison result for two proper fractions.");
Assert.AreEqual(expected, actual3, "Invalid equal comparison result for two improper fractions.");
Assert.AreEqual(expected, actual4, "Invalid equal comparison result for two mixed number fractions.");
}
public void IsUnit_IsValidResultNegative()
{
// arrange
Fraction fraction1 = new Fraction(-3);
Fraction fraction2 = new Fraction(-3, 4);
Fraction fraction3 = new Fraction(-3, 2, 5);
Fraction fraction4 = new Fraction(-1, 4);
Fraction fraction5 = new Fraction(-2, 1, 4);
Boolean expected1 = false;
Boolean expected2 = false;
Boolean expected3 = false;
Boolean expected4 = true;
Boolean expected5 = false;
// action
Boolean actual1 = fraction1.IsUnit();
Boolean actual2 = fraction2.IsUnit();
Boolean actual3 = fraction3.IsUnit();
Boolean actual4 = fraction4.IsUnit();
Boolean actual5 = fraction5.IsUnit();
// assert
Assert.IsNotNull(actual1, "Invalid result with one argument, result is null.");
Assert.AreEqual(expected1, actual1, "Invalid result with one argument, numerator is not one; negative whole number.");
Assert.AreEqual(expected2, actual2, "Invalid result with two argument, numerator is not one; negative proper fraction");
Assert.AreEqual(expected3, actual3, "Invalid result with three arguments, numerator is not one; negative mixed number.");
Assert.AreEqual(expected4, actual4, "Invalid result with two arguments, numerator is one; negative proper fraction.");
Assert.AreEqual(expected5, actual5, "Invalid result with three arguments, numerator is one; negative mixed number.");
}
public void Multiply_IsValidResultOfAnyType()
{
// arrange
Fraction expected1 = new Fraction(2, 5);
Fraction expected2 = new Fraction(6, 2);
Fraction expected3 = new Fraction(10, 3);
Fraction expected4 = new Fraction(10, 6);
Fraction expected5 = new Fraction(10, 9);
Fraction expected6 = new Fraction(12,6);
// action
Fraction actual1 = FractionOperations.Multiply(new Fraction(2), new Fraction(1, 5));
Fraction actual2 = FractionOperations.Multiply(new Fraction(2), new Fraction(3, 2));
Fraction actual3 = FractionOperations.Multiply(new Fraction(2), new Fraction(1, 2, 3));
Fraction actual4 = FractionOperations.Multiply(new Fraction(2, 3), new Fraction(5, 2));
Fraction actual5 = FractionOperations.Multiply(new Fraction(2, 3), new Fraction(1, 2, 3));
Fraction actual6 = FractionOperations.Multiply(new Fraction(3, 2), new Fraction(1, 1, 3));
// assert
Assert.AreEqual(expected1, actual1, "Multiplying whole number with proper fraction yielded an invalid result");
Assert.AreEqual(expected2, actual2, "Multiplying whole number with improper fraction yielded an invalid result");
Assert.AreEqual(expected3, actual3, "Multiplying whole number with mixed number fraction fractions yielded an invalid result");
Assert.AreEqual(expected4, actual4, "Multiplying proper with improper fractions yielded an invalid result");
Assert.AreEqual(expected3, actual3, "Multiplying proper with mixed number fractions yielded an invalid result");
Assert.AreEqual(expected4, actual4, "Multiplying improper with mixed number fractions yielded an invalid result");
}
public void MakeDecimal_IsValidResult()
{
// arrange
Fraction fraction1 = new Fraction(3);
Fraction fraction2 = new Fraction(1, 5);
Fraction fraction3 = new Fraction(3, 2);
Fraction fraction4 = new Fraction(1, 1, 2);
decimal expected1 = 3.00M;
decimal expected2 = 0.20M;
decimal expected3 = 1.5M;
decimal expected4 = 1.5M;
double delta = 0.1;
// action
decimal actual1 = FractionOperations.MakeDecimal(fraction1);
decimal actual2 = FractionOperations.MakeDecimal(fraction2);
decimal actual3 = FractionOperations.MakeDecimal(fraction3);
decimal actual4 = FractionOperations.MakeDecimal(fraction4);
// assert
Assert.AreEqual(Convert.ToDouble(expected1), Convert.ToDouble(actual1), delta, "Invalid whole to decimal conversion.");
Assert.AreEqual(Convert.ToDouble(expected2), Convert.ToDouble(actual2), delta, "Invalid proper fraction to decimal conversion.");
Assert.AreEqual(Convert.ToDouble(expected3), Convert.ToDouble(actual3), delta, "Invalid improper fraction to decimal conversion.");
Assert.AreEqual(Convert.ToDouble(expected4), Convert.ToDouble(actual4), delta, "Mixed number result is invalid");
}
public static void Main()
{
Fraction a = new Fraction(6, 18);
Fraction b = new Fraction(7, 8);
Console.WriteLine(a + b);
Console.WriteLine((a + b).Simplify);
}
public void Add_MixedTypedPositives()
{
// arrange
Fraction fraction1 = new Fraction(1);
Fraction fraction2 = new Fraction(1, 2);
Fraction fraction3 = new Fraction(3, 2);
Fraction fraction4 = new Fraction(1, 2, 3);
Fraction expected1 = new Fraction(3, 2);
Fraction expected2 = new Fraction(5, 2);
Fraction expected3 = new Fraction(8, 3);
Fraction expected4 = new Fraction(4, 2);
Fraction expected5 = new Fraction(13, 6);
Fraction expected6 = new Fraction(19, 6);
// aciton
Fraction actual1 = FractionOperations.Add(fraction1, fraction2);
Fraction actual2 = FractionOperations.Add(fraction1, fraction3);
Fraction actual3 = FractionOperations.Add(fraction1, fraction4);
Fraction actual4 = FractionOperations.Add(fraction2, fraction3);
Fraction actual5 = FractionOperations.Add(fraction2, fraction4);
Fraction actual6 = FractionOperations.Add(fraction3, fraction4);
// assert
Assert.AreEqual(expected1, actual1, "Invalid sum of a whole number and a proper fraction.");
Assert.AreEqual(expected2, actual2, "Invalid sum of whole number and an improper fraction.");
Assert.AreEqual(expected3, actual3, "Invalid sum of whole number and an mixed number fraction.");
Assert.AreEqual(expected4, actual4, "Invalid sum of a proper fraction and an improper fraction.");
Assert.AreEqual(expected5, actual5, "Invalid sum of a proper fraction and a mixed number fraction.");
Assert.AreEqual(expected5, actual5, "Invalid sum of an improper fraction a mixed number fraction.");
}
static void Main(string[] args)
{
Fraction fr1 = new Fraction(2 , 3);
Fraction fr2 = new Fraction(1, 3);
Fraction result = fr1 + fr2;
Console.WriteLine(result);
Console.WriteLine(fr2-fr1);
}
static void Main()
{
Fraction testOne = new Fraction(22, 7);
Fraction testTwo = new Fraction(40, 4);
Fraction testThr = testOne + testTwo;
Console.WriteLine(testThr);
}
public static Fraction operator -(Fraction a, Fraction b)
{
long numerator = a.Numerator * b.Denominator - b.Numerator * a.Denominator;
long denominator = a.Denominator * b.Denominator;
var result = new Fraction(numerator, denominator);
return result;
}
static void Main()
{
Fraction f1 = new Fraction(22, 7);
Fraction f2 = new Fraction(40, 4);
Fraction result = f1 + f2;
Console.WriteLine(result.Numerator);
Console.WriteLine(result.Denominator);
Console.WriteLine(result);
}
static void Main(string[] args)
{
Fraction fraction1 = new Fraction(22, 7);
Fraction fraction2 = new Fraction(40, 4);
Fraction result = fraction1 + fraction2;
Console.WriteLine(result.Numerator);
Console.WriteLine(result.Denominator);
Console.WriteLine(result);
}
public static Fraction operator +(Fraction one, Fraction two)
{
BigInteger CommonDenominator=one.denominator*two.denominator;
BigInteger devisorOne=CommonDenominator/one.denominator;
BigInteger devisorTwo=CommonDenominator/two.denominator;
BigInteger MainNumerator=(devisorOne*one.numerator)+(devisorTwo*two.numerator);
Fraction CalculatedFraction=new Fraction(MainNumerator,CommonDenominator);
return CalculatedFraction;
}
public void FindReciprocal_DivideByZero()
{
// assign
Fraction fraction = new Fraction(0);
// action
Fraction actual = FractionOperations.FindReciprocal(fraction);
Assert.IsNotNull(actual, "Actual fraction object was null.");
}
public void Divide_ByZero()
{
// assign
Fraction fraction = new Fraction(0);
// action
Fraction actual = FractionOperations.Divide(new Fraction(1,2), fraction);
Assert.IsNotNull(actual, "Actual fraction object was null.");
}
public Fraction(long num, long den)
: this()
{
CheckDenominatorZero(den);
CheckMinValue(num);
CheckMinValue(den);
var f = new Fraction((decimal)num, den);
this.Initialize(f.numerator, f.denominator);
}
public void Fraction_NegativeArguments_1()
{
int whole = -5;
// arrange
Fraction fraction = new Fraction(whole);
// assert
Assert.AreEqual(-5, fraction.WholePart, "Invalid whole part for single parameter constructor with a negative argument.");
Assert.AreEqual(0, fraction.Numerator, "Invalid numerator for single parameter constructor with a negative argument.");
Assert.AreEqual(0, fraction.Denominator, "Invalid denominator for single parameter constructor with a negative argument.");
}
