static void Main()
{
Fraction f1 = new Fraction(3, 4);
Console.WriteLine("f1: {0}", f1.ToString());
Fraction f2 = new Fraction(2, 4);
Console.WriteLine("f2: {0}", f2.ToString());
Fraction f3 = f1 + f2;
Console.WriteLine("f1 + f2 = f3: {0}", f3.ToString());
Fraction f4 = f3 + 5;
Console.WriteLine("f3 + 5 = f4: {0}", f4.ToString());
Fraction f5 = new Fraction(2, 4);
if (f5 == f2)
{
Console.WriteLine("F5: {0} == F2: {1}",
f5.ToString(),
f2.ToString());
}
}
static void Main()
{
Fraction f1 = new Fraction(3, 4);
Console.WriteLine("f1: {0}", f1.ToString());
Fraction f2 = new Fraction(2, 4);
Console.WriteLine("f2: {0}", f2.ToString());
Fraction f3 = f1 + f2;
Console.WriteLine("f1+f2=f3: {0}", f3.ToString());
Fraction f4 = f3 + 5;
// se apeleaza conversia implicita de la int la Fraction
// apoi se foloseste supraincarcarea operatorului +
Console.WriteLine("f3 + 5 = f4: {0}", f4.ToString());
Fraction f5 = new Fraction(2, 4);
if (f5 == f2)
{
Console.WriteLine("f5: {0} = f2: {1}", f5.ToString(), f2.ToString());
}
Fraction f6 = (int)f5;
Console.WriteLine("f6: {0}", f6.ToString());
}
static void PerformAndPrintOperation(Fraction left, Fraction right, char operatorChar, Func <Fraction, Fraction, Fraction> action)
{
Console.WriteLine("Operation " + operatorChar + ": " +
String.Format("{0}{1} {2} {3}{4} = {5}",
left.IsNegative() ? "-" : "",
left.ToString(false),
operatorChar == '+' || operatorChar == '-' ? (right.IsNegative() && operatorChar == '-' ? '+' : '-') : operatorChar,
right.IsNegative() && operatorChar != '+' && operatorChar != '-' ? "-" : "",
right.ToString(false),
action(left, right).ToString()
));
}
static void Main(string[] args)
{
Console.WriteLine("Вас приветствует программа работы с дробями!");
Console.Write("Введите числитель первой дроби: ");
int n1 = GetInt();
Console.Write("Введите знаминатель первой дроби: ");
int d1 = GetInt();
Console.Write("Введите числитель второй дроби: ");
int n2 = GetInt();
Console.Write("Введите знаминатель второй дроби: ");
int d2 = GetInt();
Fraction fraction1 = Init(n1, d1);
Fraction fraction2 = Init(n2, d2);
Console.WriteLine();
Fraction result = fraction1.Plus(fraction2);
result.Simplification();
Console.WriteLine("Результом операции сложения чисел: " + fraction1.ToString() + " и " + fraction2.ToString() + " является "
+ result.ToString());
result = fraction1.Minus(fraction2);
result.Simplification();
Console.WriteLine("Результом операции вычитания чисел: " + fraction1.ToString() + " и " + fraction2.ToString() + " является "
+ result.ToString());
result = fraction1.Multi(fraction2);
result.Simplification();
Console.WriteLine("Результом операции умножения чисел: " + fraction1.ToString() + " и " + fraction2.ToString() + " является "
+ result.ToString());
result = fraction1.Division(fraction2);
result.Simplification();
Console.WriteLine("Результом операции деления чисел: " + fraction1.ToString() + " и " + fraction2.ToString() + " является "
+ result.ToString());
Console.ReadKey();
}
static void Main(string[] args)
{
//different constructors and string formats
List <Fraction> fractions = new List <Fraction>()
{
new Fraction(5),
new Fraction(2, 3),
new Fraction(1.45),
Fraction.GetFraction("5/3"),
Fraction.GetFraction("-3(1/2)"),
Fraction.GetFraction("15,69"),
Fraction.GetFraction("21")
};
Console.WriteLine("YES");
//overload operations
fractions.Add(fractions[0] + fractions[2]);
fractions.Add(fractions[3] - fractions[1]);
fractions.Add(fractions[6] * fractions[4]);
fractions.Add(fractions[5] / fractions[7]);
//use Clone
fractions.Add(fractions[3].Clone() as Fraction);
Fraction testFraction = new Fraction(-42, 13);
Console.WriteLine("Try to convert fraction to unsuported format: ");
try
{
testFraction.ToString("The string");
}
catch (FormatException ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("\nTry get fraction using unssuported format:");
try
{
fractions.Add(Fraction.GetFraction("The string"));
}
catch (FormatException ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("\nTry to add fraction with denominator = 0 :");
try
{
fractions.Add(new Fraction(12, 0));
}
catch (ArgumentException ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("\nTry to add fraction with denominator < 0 :");
try
{
fractions.Add(new Fraction(12, -3));
}
catch (ArgumentException ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("\nList of all fractions:");
fractions.ForEach(i => Console.WriteLine("{0:S}", i));
Console.WriteLine("\noutput fraction in different formats:");
Console.WriteLine("{0:S}", testFraction);
Console.WriteLine("{0:M}", testFraction);
Console.WriteLine("{0:D}", testFraction);
Console.WriteLine("{0:I}", testFraction);
Console.WriteLine("\nCoversion:");
Console.WriteLine((short)testFraction);
Console.WriteLine((int)testFraction);
Console.WriteLine((long)testFraction);
Console.WriteLine((float)testFraction);
Console.WriteLine((double)testFraction);
Console.WriteLine(Convert.ToBoolean(testFraction));
Console.WriteLine(Convert.ToString(testFraction));
Console.WriteLine("\nComparison:");
Console.WriteLine(fractions[0] == fractions[9]);
Console.WriteLine(fractions[3] != fractions[5]);
Console.WriteLine(fractions[6] < fractions[8]);
Console.WriteLine(fractions[1] >= fractions[7]);
}
static void Main(string[] args)
{
Console.OutputEncoding = Encoding.Unicode;
Console.InputEncoding = Encoding.Unicode;
int a, b, c, d;
Console.WriteLine("Enter a");
a = Int32.Parse(Console.ReadLine());
Console.WriteLine("Enter b");
b = Int32.Parse(Console.ReadLine());
Console.WriteLine("Enter c");
c = Int32.Parse(Console.ReadLine());
Console.WriteLine("Enter d");
d = Int32.Parse(Console.ReadLine());
Fraction f1 = new Fraction(a, b);
Fraction f2 = new Fraction(c, d);
if (b == 0 || d == 0)
{
throw new Exception("Знаменник не може бути рівним нулю!");
}
Console.WriteLine("Дроби,які ви ввели, мають наступний вигляд(у вигляді правильного дробу): ");
Console.WriteLine(f1.ToString() + " " + f2.ToString());
if (f1)
{
Console.WriteLine("Перший дріб правильний");
}
else
{
Console.WriteLine("Перший дріб неправильний ");
}
if (f2)
{
Console.WriteLine("Другий дріб правильний");
}
else
{
Console.WriteLine("Другий дріб неправильний ");
}
Console.WriteLine("Рівність між першим і другим дробом ");
Console.WriteLine("----------------------------------");
Console.WriteLine($"f1 < f2:{ f1 < f2}");
Console.WriteLine($"f1 > f2:{ f1 > f2}");
Console.WriteLine($"f1 == f2:{ f1 == f2}");
Console.WriteLine($"f1 != f2:{ f1 != f2}");
Console.WriteLine("Математичні дії: ");
Console.WriteLine("----------------------------------");
Console.WriteLine($"f1 + f2:{ f1 + f2}");
Console.WriteLine($"f1 - f2:{ f1 - f2}");
Console.WriteLine($"f1 * f2:{ f1 * f2}");
Console.WriteLine($"f1 / f2:{ f1 / f2}");
Console.WriteLine("---------------------------------");
int m = 10;
Console.WriteLine("f1+m = {0}", f1 + m);
Console.WriteLine("f1*m = {0}", f1 * m);
Console.WriteLine("m*f1 = {0}", m * f1);
Console.WriteLine("-----------------------------------");
Console.WriteLine("Введіть десятковий дріб(через крапку),який ви хочете додати до першого дробу: ");
string s = Console.ReadLine();
Fraction f3 = Fraction.Parse(s);
Console.WriteLine("Введений вами десятковий дріб має такий вигляд(у вигляды правильного дробу): ");
f3.Show();
Fraction f4 = f1 + f3;
Console.WriteLine("Ваш результат(у вигляді правильного дробу): ");
f4.Show();
}
static void Main(string[] args)
{
List <Fraction> fractions = new List <Fraction>()
{
new Fraction(0.25),
new Fraction(2),
new Fraction(2, 4)
//Creating fractions with different constructor types
};
fractions = fractions.Concat(new List <Fraction>()
{
Fraction.Parse("1/3"),
Fraction.Parse("3"),
Fraction.Parse("-2(1/4)"),
Fraction.Parse("-0.75")
//Parsing from different string formats
}).ToList();
Fraction testing;
Console.WriteLine(Fraction.TryParse("Not a fraction", out testing));
Console.WriteLine(Fraction.TryParse("27/54", out testing));
Console.WriteLine(testing);
//TryParse function
fractions = fractions.Concat(new List <Fraction>()
{
new Fraction(3, 4) + new Fraction(2, 3),
new Fraction(5, 6) - new Fraction(1, 6),
new Fraction(1, 9) * new Fraction(9, 4),
new Fraction(2, 3) / new Fraction(3, 2),
//Math operations
}).ToList();
fractions.Add(new Fraction(7, 8).Clone() as Fraction);
//Cloning fraction
Console.WriteLine("____________________");
Console.WriteLine(new Fraction(3, 4) > new Fraction(2, 3));
Console.WriteLine(new Fraction(5, 6) <= new Fraction(1, 6));
Console.WriteLine(new Fraction(1, 2) == new Fraction(2, 4));
Console.WriteLine(new Fraction(3, 4) != new Fraction(6, 8));
//Comparison operators
Console.WriteLine("____________________");
testing = new Fraction(-5, 2);
Console.WriteLine("{0:F}", testing);
Console.WriteLine("{0:IF}", testing);
Console.WriteLine("{0:I}", testing);
Console.WriteLine("{0:D}", testing);
Console.WriteLine("{0:D5}", testing);
//Converting to string in different formats and IFormattible implementation
Console.WriteLine("____________________");
Console.WriteLine((int)testing);
Console.WriteLine((double)testing);
Console.WriteLine(Convert.ToBoolean(testing));
Console.WriteLine(Convert.ToString(testing));
//Conversion operators and implementation of IConvertible
fractions.Sort();
fractions.Sort(new Fraction.DecreaseComparer());
fractions.Sort((x, y) => y.CompareTo(x));
//Sorting by using IComparable interface, default Decrease comparer and CompareTo
//function
Console.WriteLine("____________________");
fractions.ForEach(x => Console.WriteLine("{0:IF}", x));
Console.WriteLine("____________________");
try
{
new Fraction(2, 0);
//Division by zero exception
}
catch (ArgumentException ex)
{
Console.WriteLine(ex.Message);
}
try
{
Fraction.Parse("Not a fraction");
//Trying to parse incorrect string exception
}
catch (FormatException ex)
{
Console.WriteLine(ex.Message);
}
try
{
testing.ToString("Unsupported format");
//Unsupported ToString() format exception
}
catch (FormatException ex)
{
Console.WriteLine(ex.Message);
}
}
static void Main(string[] args)
{
// Constructor test
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("Creating Fractions from different constructors");
Console.ResetColor();
List <Fraction> fractionsList = new List <Fraction>()
{
new Fraction(),
new Fraction(24),
new Fraction(25, 4),
new Fraction(2.5),
new Fraction(100, 50, 1, 1, 1),
};
Console.Write("List: ");
foreach (var fractNumber in fractionsList)
{
Console.Write(fractNumber + ", ");
}
// Simplifying test
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("\n\nAll fraction automatically simplifying to shortest form(if it possible)\n");
Console.ResetColor();
Console.WriteLine("List: ");
List <Fraction> fractionsList2 = new List <Fraction>()
{
new Fraction(100, 2),
new Fraction(33, 3),
new Fraction(21, 9),
new Fraction(600, 21),
new Fraction(4.2)
};
foreach (var fractNumber in fractionsList2)
{
Console.Write(fractNumber + ", ");
}
// Random number to Fraction test
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write("\n\nDemonstrating with random numbers!");
Console.ResetColor();
Console.WriteLine("\nFractions added to Array:\n");
Random rand = new Random();
int size = 20;
Fraction[] fractArray = new Fraction[size];
int size1 = size - 5;
for (int i = 0; i < size1; i++)
{
long numerator = rand.Next(-1000, 1000);
long denumerator = rand.Next(-1000, 1000);
while (denumerator == 0)
{
denumerator = rand.Next(-1000, 1000);
}
fractArray[i] = new Fraction(numerator, denumerator);
Console.Write("{0, -21} | {1, -23} ===> {2, -10}\n",
$"Rand numerator: {numerator.ToString()}", $"Rand Denomerator: {denumerator}", $"{fractArray[i]}");
}
Console.WriteLine("\nAlso adding to array few integers which equal to random frations:");
int cnt = size1;
while (cnt < size)
{
long numerator = rand.Next(-1000, 1000);
long denumerator = rand.Next(-1000, 1000);
while (denumerator == 0)
{
denumerator = rand.Next(-1000, 1000);
}
Fraction fraction = new Fraction(numerator, denumerator);
if (fraction.Denominator == 1)
{
fractArray[cnt] = fraction;
cnt++;
Console.Write("{0, -21} | {1, -23} ===> {2, -10}\n",
$"Rand numerator: {numerator.ToString()}", $"Rand Denomerator: {denumerator}", $"{fraction}");
}
}
Console.WriteLine("\nPrinting all our Array:");
foreach (var fractNum in fractArray)
{
Console.Write($"{fractNum}, ");
}
// Sorting test
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("\n\nSorting our Array:");
Console.ResetColor();
Array.Sort(fractArray);
foreach (var fractNum in fractArray)
{
Console.Write($"{fractNum}, ");
}
// Testing Math operators
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("\n\nTesting Math operators:");
Console.ResetColor();
long numTest = 1;
long denumTest = 0;
long numTest2 = 1;
long denumTest2 = 0;
while (numTest == 1 || denumTest == 0 || numTest2 == 1 || denumTest2 == 0)
{
numTest = rand.Next(-20, 20);
denumTest = rand.Next(-20, 20);
numTest2 = rand.Next(-20, 20);
denumTest2 = rand.Next(-20, 20);
}
Fraction fractTest1 = new Fraction(numTest, denumTest);
Fraction fractTest2 = new Fraction(numTest2, denumTest2);
Console.WriteLine("Our random fractions: {0}, {1}", fractTest1, fractTest2);
Console.WriteLine($"{fractTest1} + {fractTest2} = {fractTest1+fractTest2}");
Console.WriteLine($"{fractTest1} - {fractTest2} = {fractTest1-fractTest2}");
Console.WriteLine($"{fractTest1} * {fractTest2} = {fractTest1*fractTest2}");
Console.WriteLine($"{fractTest1} / {fractTest2} = {fractTest1/fractTest2}");
Console.WriteLine($"{fractTest1} % {fractTest2} = {fractTest1%fractTest2}");
Console.WriteLine($"{fractTest1} > {fractTest2} = {(fractTest1>fractTest2).ToString()}");
Console.WriteLine($"{fractTest1} < {fractTest2} = {(fractTest1<fractTest2).ToString()}");
Console.WriteLine($"{fractTest1} >= {fractTest2} = {(fractTest1>=fractTest2).ToString()}");
Console.WriteLine($"{fractTest1} <= {fractTest2} = {(fractTest1<=fractTest2).ToString()}");
Console.WriteLine($"{fractTest1} == {fractTest2} = {(fractTest1==fractTest2).ToString()}");
Console.WriteLine($"++ {fractTest1} ==> {(++fractTest1).ToString()}");
Console.WriteLine($"-- {fractTest1} ==> {(--fractTest1).ToString()}");
// Testing Converting types from Fraction to simple C# types
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("\n\nTesting Converting types from Fraction to simple C# types:");
Console.ResetColor();
fractTest1 = new Fraction(-17, 13);
Console.WriteLine("Testing type converting with fraction: {0}", fractTest1);
Console.WriteLine("Fraction to sbyte: {0}", ((sbyte)fractTest1).ToString());
Console.WriteLine("Fraction to short: {0}", ((short)fractTest1).ToString());
Console.WriteLine("Fraction to int: {0}", ((int)fractTest1).ToString());
Console.WriteLine("Fraction to long: {0}", ((long)fractTest1).ToString());
Console.WriteLine("Fraction to float: {0}", ((float)fractTest1).ToString());
Console.WriteLine("Fraction to double: {0}", ((double)fractTest1).ToString());
Console.WriteLine("Fraction to decimal: {0}", ((decimal)fractTest1).ToString());
// Testing Converting float, double, decimal to Fraction type
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("\nTesting Converting float, double, decimal to Fraction type");
Console.ResetColor();
Fraction test = null;
double duble = 9024.24;
test = duble;
Console.WriteLine("Double to Fraction: {0} ==> {1}", duble.ToString(), test);
float floate = 9124.234f;
test = floate;
Console.WriteLine("Float to Fraction: {0} ==> {1}", floate.ToString(), test);
decimal decim = 23412.32414m;
test = decim;
Console.WriteLine("Decimal to Fraction: {0} ==> {1}", decim.ToString(), test);
// Demonstrating ToString Overloading
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("\nFraction ToString method:");
Console.ResetColor();
Fraction testString = new Fraction(12375, 5000);
Console.WriteLine("Fractional Number: " + testString.ToString());
Console.WriteLine("Enumerator: " + testString.ToString("NUM"));
Console.WriteLine("Denominator: " + testString.ToString("DENUM"));
Console.WriteLine("Format FLOAT: " + testString.ToString("FLOAT"));
Console.WriteLine("Format INT: " + testString.ToString("INT"));
Console.WriteLine("Format FULL: " + testString.ToString("FULL"));
// Getting Fraction from String
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("\nGetting Fraction from string:");
Console.ResetColor();
string tryString = "Not a Parsable Fraction";
string tryString1 = "5/3";
string tryString2 = " 5/3";
string tryString3 = " 5 /3";
string tryString4 = " 5 / 3 ";
string tryString5 = "234";
string tryString6 = " 234";
string tryString7 = " 234 ";
string tryString8 = "65.225";
string tryString9 = " 65.225";
string tryString10 = "2,25 ";
string tryString11 = " 2,25";
string tryString12 = " 2,25 ";
string tryString13 = "2.25";
string tryString14 = "Last string for parsing";
List <string> stringsForParse = new List <string>();
stringsForParse.Add(tryString);
stringsForParse.Add(tryString1);
stringsForParse.Add(tryString2);
stringsForParse.Add(tryString3);
stringsForParse.Add(tryString4);
stringsForParse.Add(tryString5);
stringsForParse.Add(tryString6);
stringsForParse.Add(tryString7);
stringsForParse.Add(tryString8);
stringsForParse.Add(tryString8);
stringsForParse.Add(tryString9);
stringsForParse.Add(tryString10);
stringsForParse.Add(tryString11);
stringsForParse.Add(tryString12);
stringsForParse.Add(tryString13);
stringsForParse.Add(tryString14);
foreach (var parsingStr in stringsForParse)
{
Console.WriteLine("Parsing string: {0}", parsingStr);
if (Fraction.TryParse(parsingStr, out Fraction fraction1))
{
Console.WriteLine("Result Parse: {0}\n", fraction1);
}
else
{
Console.WriteLine("Can't Parse from -- {0}\n", parsingStr);
}
}
}
public bool Equals(Fraction obj)
{
return(ToString() == obj.ToString());
}