Untitled

using System;
using static System.Console;


////////////////////////////////////////////////////////////////////////////////////////////////////
// namespace: zad1
//
// summary: set of stuff that presents the basic functionalities of a fraction
////////////////////////////////////////////////////////////////////////////////////////////////////

namespace zad1
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   A fraction structure. </summary>
    ///
    /// <remarks>   Julita, 2017-11-24. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    struct Fraction
    {
        int licznik, mianownik;

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Implicit cast that converts the given int to a Fraction. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="x">    The x coordinate. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static implicit operator Fraction(int x) => new Fraction(x, 1);

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Explicit cast that converts the given Fraction to an int. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f">    A Fraction to process. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static explicit operator int(Fraction f) => f.licznik / f.mianownik;

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Constructor. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="licznik">      The licznik. </param>
        /// <param name="mianownik">    The mianownik. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public Fraction(int licznik, int mianownik)
        {
            this.licznik = licznik;
            this.mianownik = mianownik;
            repairFraction();
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Repair fraction. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void repairFraction()
        {
            if ((licznik < 0 && mianownik < 0) || (licznik > 0 && mianownik < 0))
            {
                licznik *= -1;
                mianownik *= -1;
            }
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Simplify fraction. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void simplifyFraction()
        {
            if (licznik > 0)
            {
                int l = licznik;
                int m = mianownik;
                int nwd = findNWD(l, m);
                if (l % nwd == 0)
                {
                    licznik = l / nwd;
                    mianownik = m / nwd;
                    repairFraction();
                }
            }
            else if (licznik < 0)
            {
                int l = Math.Abs(licznik);
                int m = mianownik;
                int nwd = findNWD(l, m);
                if (l % nwd == 0)
                {
                    licznik = (l / nwd) * -1;
                    mianownik = m / nwd;
                    repairFraction();
                }
            }
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Addition operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="f2">   The second Fraction. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator +(Fraction f1, Fraction f2)
        {
            int newLicznik = f1.licznik * f2.mianownik + f2.licznik * f1.mianownik;
            int newMianownik = f1.mianownik * f2.mianownik;
            f1.repairFraction();
            f2.repairFraction();
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Addition operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="n">    An int to process. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator +(Fraction f1, int n)
        {
            Fraction f = n;
            return f + f1;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Subtraction operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="f2">   The second Fraction. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator -(Fraction f1, Fraction f2)
        {
            int newLicznik = f1.licznik * f2.mianownik - f2.licznik * f1.mianownik;
            int newMianownik = f1.mianownik * f2.mianownik;
            f1.repairFraction();
            f2.repairFraction();
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Subtraction operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="n">    An int to process. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator -(Fraction f1, int n)
        {
            Fraction f = n;
            return f1 - f;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Multiplication operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="f2">   The second Fraction. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator *(Fraction f1, Fraction f2)
        {
            int newLicznik = f1.licznik * f2.licznik;
            int newMianownik = f1.mianownik * f2.mianownik;
            f1.repairFraction();
            f2.repairFraction();
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Multiplication operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="n">    An int to process. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator *(Fraction f1, int n)
        {
            int newLicznik = f1.licznik * n;
            int newMianownik = f1.mianownik;
            f1.repairFraction();
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Division operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="f2">   The second Fraction. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator /(Fraction f1, Fraction f2)
        {
            int newLicznik = f1.licznik * f2.mianownik;
            int newMianownik = f1.mianownik * f2.licznik;
            f1.repairFraction();
            f2.repairFraction();
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Division operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="n">    An int to process. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator /(Fraction f1, int n)
        {
            int newLicznik = f1.licznik;
            int newMianownik = f1.mianownik * n;
            f1.repairFraction();
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Bitwise 'exclusive or' operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f">    A Fraction to process. </param>
        /// <param name="pow">  The pow. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator ^(Fraction f, int pow)
        {
            if (pow > 0)
            {
                int l = f.licznik;
                int m = f.mianownik;
                f.licznik = (int)Math.Pow(l, pow);
                f.mianownik = (int)Math.Pow(m, pow);
            }
            else if (pow < 0)
            {
                pow *= -1;
                int l = f.licznik;
                int m = f.mianownik;
                f.licznik = (int)Math.Pow(m, pow);
                f.mianownik = (int)Math.Pow(l, pow);
            }
            else
            {
                f.licznik = 1;
                f.mianownik = 1;
            }
            f.repairFraction();
            return f;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Greater-than comparison operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="f2">   The second Fraction. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator >(Fraction f1, Fraction f2)
        {
            int licznik1 = f1.licznik * f2.mianownik;
            int licznik2 = f2.licznik * f1.mianownik;
            f1.repairFraction();
            f2.repairFraction();
            return licznik1 > licznik2;
        }


        /// <summary>   . </summary>
        public static bool operator <(Fraction f1, Fraction f2)
        {
            int licznik1 = f1.licznik * f2.mianownik;
            int licznik2 = f2.licznik * f1.mianownik;
            f1.repairFraction();
            f2.repairFraction();
            return licznik1 < licznik2;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Greater-than-or-equal comparison operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="f2">   The second Fraction. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator >=(Fraction f1, Fraction f2)
        {
            int licznik1 = f1.licznik * f2.mianownik;
            int licznik2 = f2.licznik * f1.mianownik;

            f1.repairFraction();
            f2.repairFraction();
            return licznik1 >= licznik2;
        }


        /// <summary>   . </summary>
        public static bool operator <=(Fraction f1, Fraction f2)
        {
            int licznik1 = f1.licznik * f2.mianownik;
            int licznik2 = f2.licznik * f1.mianownik;
            f1.repairFraction();
            f2.repairFraction();
            return licznik1 <= licznik2;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Equality operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="f2">   The second Fraction. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator ==(Fraction f1, Fraction f2)
        {
            bool answer = false;
            if (f1.licznik == f2.licznik && f1.mianownik == f2.mianownik)
            {
                answer = true;
            }
            f1.repairFraction();
            f2.repairFraction();
            return answer;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Inequality operator. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="f1">   The first Fraction. </param>
        /// <param name="f2">   The second Fraction. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator !=(Fraction f1, Fraction f2)
        {
            bool answer = false;
            if (f1.licznik != f2.licznik || f1.mianownik != f2.mianownik)
            {
                answer = true;
            }
            f1.repairFraction();
            f2.repairFraction();
            return answer;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Searches for the first nwd. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="l">    An int to process. </param>
        /// <param name="m">    An int to process. </param>
        ///
        /// <returns>   The found nwd. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int findNWD(int l, int m)
        {
            while (l != m)
            {
                if (l > m)
                {
                    l -= m;
                }
                else
                {
                    m -= l;
                }
            }
            return l;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Print fraction. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void printFraction()
        {
            repairFraction();
            if (Math.Abs(licznik) > Math.Abs(mianownik))
            {
                int stalaPrzed = (int)(licznik / mianownik);
                int l = licznik - mianownik * stalaPrzed;
                if (stalaPrzed < 0 && l < 0)
                {
                    l *= -1;
                }
                WriteLine("{0} ( {1} / {2} )", stalaPrzed, l, FracMianownik);
                if (l % mianownik == 0)
                {
                    WriteLine(" {0} ", stalaPrzed);
                }
            }
            else
            {
                WriteLine(" {0} / {1} ", FracLicznik, FracMianownik);
            }

            WriteLine();
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Simply print. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void simplyPrint()
        {
            repairFraction();
            WriteLine(" {0} / {1} ", FracLicznik, FracMianownik);
            WriteLine();
        }
        public int FracMianownik => mianownik;
        public int FracLicznik => licznik;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   A solution. </summary>
    ///
    /// <remarks>   Julita, 2017-11-24. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    class Solution
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Main entry-point for this application. </summary>
        ///
        /// <remarks>   Julita, 2017-11-24. </remarks>
        ///
        /// <param name="args"> An array of command-line argument strings. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        static void Main(string[] args)
        {
            int l1, l2, m1, m2;
            Fraction f1, f2, f3, f4, f5;
            int n;
            string input;

            WriteLine();
            WriteLine("TWORZENIE PIERWSZEGO UŁAMKA - F1");
            WriteLine("Wpisz licznik:");
            input = ReadLine();
            if (input == "")
            {
                l1 = 1;
            }
            else
            {
                l1 = Int32.Parse(input);
            }
            WriteLine("Wpisz mianownik:");
            input = ReadLine();
            if (input == "")
            {
                m1 = 1;
            }
            else
            {
                m1 = Int32.Parse(input);
            }
            WriteLine("F1:");
            f1 = new Fraction(l1, m1);
            f1.simplifyFraction();
            f1.simplyPrint();

            WriteLine("TWORZENIE DRUGIEGO UŁAMKA - F2");
            WriteLine("Wpisz licznik:");
            input = ReadLine();
            if (input == "")
            {
                l2 = 1;
            }
            else
            {
                l2 = Int32.Parse(input);
            }
            WriteLine("Wpisz mianownik:");
            input = ReadLine();
            if (input == "")
            {
                m2 = 1;
            }
            else
            {
                m2 = Int32.Parse(input);
            }
            WriteLine("F2:");
            f2 = new Fraction(l2, m2);
            f2.simplifyFraction();
            f2.simplyPrint();

            WriteLine("LICZBA CAŁKOWITA DO TESTÓW");
            WriteLine("Wpisz liczbę całkowitą:");
            input = ReadLine();
            if (input == "")
            {
                n = 1;
            }
            else
            {
                n = Int32.Parse(input);
            }
            WriteLine($"Liczba n = {n}");
            WriteLine();

            WriteLine("PRZYKŁADY DZIAŁANIA OPERATORÓW");
            WriteLine();

            WriteLine("F1 + F2");
            f3 = f1 + f2;
            f3.printFraction();

            WriteLine($"F1 + {n}");
            f3 = f1 + n;
            f3.simplyPrint();

            WriteLine("F1 - F2");
            f3 = f1 - f2;
            f3.printFraction();

            WriteLine($"F1 - {n}");
            f3 = f1 - n;
            f3.simplyPrint();

            WriteLine("F1 * F2");
            f3 = f1 * f2;
            f3.printFraction();

            WriteLine($"F1 * {n}");
            f3 = f1 * n;
            f3.simplyPrint();

            WriteLine("F1 / F2");
            f3 = f1 / f2;
            f3.printFraction();

            WriteLine($"F1 / {n}");
            f3 = f1 / n;
            f3.simplyPrint();

            WriteLine($"F1 ^ {n}");
            f3 = f1 ^ n;
            f3.simplyPrint();

            WriteLine("OPERATORY RELACJI");
            f4 = new Fraction(l1, m1);
            WriteLine("F4:");
            f4.simplyPrint();
            WriteLine();
            WriteLine(" F1 > F2");
            WriteLine(f1 > f2);
            WriteLine("\n F1 < F2");
            WriteLine(f1 < f2);
            WriteLine("\n F1 >= F2");
            WriteLine(f1 >= f2);
            WriteLine("\n F1 >= F4");
            WriteLine(f1 >= f4);
            WriteLine("\n F1 == F2");
            WriteLine(f1 == f2);
            WriteLine("\n F1 == F4");
            WriteLine(f1 == f4);
            WriteLine("\n F1 != F2");
            WriteLine(f1 != f2);
            WriteLine("\n F1 != F4");
            WriteLine(f1 != f4);

            WriteLine("INNE PRZYŁADY");
            f5 = n;
            f5.simplyPrint();
            WriteLine();

            WriteLine();
            WriteLine("KONIEC");
        }
    }
}