Fractions

using System;


namespace FractionExample
{
    class Fraction //Создаем класс дроби
    {
        //public int numerator { get; set; }
        //public int denominator { get; set; }

        public int numerator, denominator; //объявляем целочисленные переменные - числитель и знаменатель

        public Fraction(int x, int y) //Конструктор - присваиваем значения числителю и знаменателю
        {
            numerator = x;
            denominator = y;
        }
        public Fraction() //Еще один конструктор - без входных аргументов, присваиваем значение 0 чисоителю и знаменателю
        {
            numerator = 0;
            denominator = 0;
        }
        private static Fraction Reverse(Fraction a) //Функция переворота дроби (используется позже)
        {
            return new Fraction(a.denominator, a.numerator);
        }

        private static int LCM(int a, int b) //Функция нахождения наименьшего общего кратного (используется позже)
        {
            int lcm = 1;
            int max = (a > b) ? a : b;
            for (int i = max; ; i += max)
            {
                if (i % a == 0 && i % b == 0)
                {
                    lcm = i;
                    break;
                }
            }
            return lcm;
        }

        private static int GCD(int a, int b) //Функция нахождения наибольшего общего делителя (используется позже)
        {
            a = Math.Abs(a);
            b = Math.Abs(b);
            while (a != 0 && b != 0)
            {
                if (a > b)
                    a %= b;
                else
                    b %= a;
            }
            return a == 0 ? b : a;
        }

        private static Fraction Check(Fraction a) //Функция проверки дроби (используется позже)
        {
            if (a.numerator < 0 & a.denominator < 0) //Если и числ. и знам. меньше 0, то делаем их положительными
            {
                a.numerator = Math.Abs(a.numerator);
                a.denominator = Math.Abs(a.denominator);
            }
            if (a.denominator < 0) //Если знам. меньше 0, то делаем его положительным, а числ. отрицательным (будем считать, что дробь отрицательная, если отрицателен числитель)
            {
                a.denominator = -a.denominator;
                a.numerator = -a.numerator;
            }
            if (a.denominator == 0) //Если знаменатель равен 0, то создаем исключение
                throw new Exception("Нельзя делить на 0");
            int gcd = GCD(a.numerator, a.denominator); //находим наибольший общий делитель у числ. и знам, и если он не 1 - делим на него
            if (gcd != 1)
            {
                a.numerator /= gcd;
                a.denominator /= gcd;
            }
            return a;
        }

        public Fraction FractionAssign() //Функция присваивания значения дроби (ввести можно либо просто число - тогда оно станет числителем, а знаменатель станет равен 1, либо можно ввести конструкцию, например, 22/7 - тут все очевидно)
        {
            string a = Console.ReadLine(); //считываем строку
            if (!a.Contains("/")) //Если в ней нет знака '/'
            {
                while(true) //Бесконечный цикл с попыткой преобразовать введенное в число и присвоить его числителю
                {
                    try
                    {
                        numerator = Convert.ToInt32(a);
                        break;
                    }
                    catch (FormatException)
                    {
                        Console.WriteLine("Что-то пошло не так, попробуйте ввести еще раз");
                        a = Console.ReadLine();
                    }
                }
                denominator = 1; //Делаем знаменатель равным 1
            }
            else //Иначе
            {
                string[] numden = a.Split(new char[] { '/' }); //Создаем массив строк (то, что идет до знака '/', и после)
                while(true) //Бесконечный цикл с попыткой перевода полученных строк в числитель и знаменатель
                {
                    try
                    {
                        numerator = Convert.ToInt32(numden[0]);
                        denominator = Convert.ToInt32(numden[1]);
                        break;
                    }
                    catch (FormatException)
                    {
                        Console.WriteLine("Что-то пошло не так, попробуйте ввести еще раз");
                        a = Console.ReadLine();
                        numden = a.Split(new char[] { '/' });
                    }
                }

            }
            return Check(new Fraction(numerator, denominator)); //После всего этого возвращаем объект Fraction, прошедший через функцию Check()

        }

        public static string Output(Fraction a) //Красивый вывод дроби
        {
            if (a.numerator == 0)
                return "0";
            if (a.denominator == 1)
                return a.numerator.ToString();
            else
                return a.numerator + "/" + a.denominator;
        }

        //Дальше идут перегруженные операторы. Грубо говоря, это когда есть например объекты fraction1 и fraction2,
        //и можно просто написать fraction1 + fraction2 и получить новую дробь, в которой будет результат сложения.
        //В функции Main есть пара примеров
        //Не буду объяснять работу всех перегруженных операторов, покажу только пример работы оперетора + , который складывает дробь и число (идет вторым сверху)

        public static Fraction operator +(Fraction a, Fraction b) //Перегруженный оператор +, который складывает дробь и дробь
        {
            Fraction Res = new Fraction();
            int m = LCM(a.denominator, b.denominator);
            Res.numerator = a.numerator * (m / a.denominator) + b.numerator * (m / b.denominator);
            Res.denominator = m;
            return Check(Res);
        }
        public static Fraction operator +(Fraction a, int b) //Перегруженный оператор +, который складывает дробь и число
        {
            Fraction Res = new Fraction();  //Создаем новую дробь, в которой будет результат
            Res.numerator = a.numerator + a.denominator * b;  //В ее числитель записываем сумму числителя дроби и произведения числа и знаменателя дроби
            Res.denominator = a.denominator; //Знаменатель дроби-результата равен знаменателю исходной дроби
            return Check(Res); //Возвращаем дробь-результат, пропущенную через функцию Check();
        }
        public static Fraction operator -(Fraction a, Fraction b) //Перегруженный оператор -, который вычитает из дроби дробь
        {
            Fraction Res = new Fraction();
            int m = LCM(a.denominator, b.denominator);
            Res.numerator = a.numerator * (m / a.denominator) - b.numerator * (m / b.denominator);
            Res.denominator = m;
            return Check(Res);
        }
        public static Fraction operator -(Fraction a, int b) //Перегруженный оператор -, который вычитает из дроби число
        {
            Fraction Res = new Fraction();
            Res.numerator = a.numerator - a.denominator * b;
            Res.denominator = a.denominator;
            return Check(Res);
        }
        public static Fraction operator *(Fraction a, Fraction b) //Перегруженный оператор *, который умножает дробь на дробь
        {
            Fraction Res = new Fraction();
            Res.numerator = a.numerator * b.numerator;
            Res.denominator = a.denominator * b.denominator;
            return Check(Res);
        }
        public static Fraction operator *(Fraction a, int b) //Перегруженный оператор *, который умножает дробь на число
        {
            Fraction Res = new Fraction();
            Res.numerator = a.numerator * b;
            Res.denominator = a.denominator;
            return Check(Res);
        }
        public static Fraction operator /(Fraction a, int b) //Перегруженный оператор /, который делит дробь на число
        {
            Fraction Res = new Fraction();
            Res.denominator = a.denominator * b;
            Res.numerator = a.numerator;
            return Check(Res);
        }
        public static Fraction operator /(int a, Fraction b) //Перегруженный оператор /, который делит число на дробь
        {
            return Check(Reverse(b) * a);
        }
        public static Fraction operator /(Fraction a, Fraction b) //Перегруженный оператор /, который делит дробь на дробь
        {
            return Check(a * Reverse(b));
        }

    }
    class Program
    {
        static void Main()
        {
            Fraction fraction = new Fraction(2, 5); //Создаем дробь fraction = 2/5
            Fraction fraction1 = new Fraction(1, 6); //Создаем дробь fraction1 = 1/6
            int a = 5;

            Console.WriteLine("Результат деления 1/6 на 2/5 = " + Fraction.Output(fraction1/ fraction));
            Console.WriteLine("Результат умножения 2/5 на 5 = " + Fraction.Output(fraction * a));
            Console.WriteLine("Результат сложения 2/5 и 1/6 = " + Fraction.Output(fraction + fraction1));
            Console.ReadKey();
        }
    }
}