Класс: Обыкновенная дробь

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
using System.Text.RegularExpressions;
 
 
namespace Lab1
{
    /// <summary>
    /// Класс представляющий рациональные числа
    /// </summary>
    public class Ratio : IFormattable, IComparable
    {
        
       private int _numerator;
        /// <summary>
        /// Знаменатель
        /// </summary>
       private int _denomenator;
 
       /// <summary>
       /// Знак дроби (Свойство для чтения)
       /// </summary>
       
        /// <summary>
       /// Числитель (Свойство для чтения)
        /// </summary>
       public int Numer
       {
           get { return _numerator; }
      
       }
        /// <summary>
       ///  Знаменатель (Свойство для чтения)
        /// </summary>
       public int Denomer
       {
           get { return _denomenator; }
         
       }
       
       /// <summary>
       /// Конструктор с параметрами 
       /// </summary>
       /// <param name="num">Числитель</param>
       /// <param name="den">Знаменатель</param>
       /// <param name="ipart">Целая часть</param>
       /// <param name="sig">Знак дроби</param>
       private Ratio(int num, int den)//С параметрами (1)
       {
 
           _numerator = num;
           _denomenator = den;
           Reduction();
       }
 
       public Ratio()//Без параметров (2)
       {
           _numerator = 0;
           _denomenator = 1;
       }
        /// <summary>
        /// Метод для доступа к конструктору (Защищает от создания некорректных значений рац.чисел)
        /// </summary>
        /// <param name="num">Числитель</param>
        /// <param name="den">Знаменатель</param>
        /// <param name="ipart">Целая часть</param>
        /// <param name="sig">Знак</param>
        /// <returns>Объект, если всё ОК – null в противном случае</returns>
       public static Ratio Create(int num, int den)//Метод, вызывающий конструктор (1)
       {
 
 
           if (den != 0)
               return new Ratio(num, den);
           else return default(Ratio);
       }  
      
 
       /// <summary>
       /// Явное приведение к типу double
       /// </summary>
       /// <param name="obj">Приводимый экземппляр</param>
       /// <returns>Число с плавающей точкой</returns>
       public static explicit operator double(Ratio obj) // преобразование дроби к даблу
       {
           return (double)(obj._numerator / obj._denomenator);
       }
        /// <summary>
        /// Перекрытый метод сравнения для объектов
        /// </summary>
        /// <param name="obj">Объект, который пытаются привести к Ratio</param>
        /// <returns>True если равны, False - если не равны или не удалось привести</returns>
       public override bool Equals(object obj)
       {
           if (obj is Ratio)
               return Equals((Ratio)obj);
           else return false; 
 
       }
        /// <summary>
        /// Метод сравнения конкретно для Ratio
        /// </summary>
        /// <param name="obj">Объект, с которым сравнивают экземпляр, вызывающий метод</param>
        /// <returns>True если равны, False если не равны или объект == null</returns>
       public bool Equals(Ratio obj)
       {
           if (this == null && obj == null)
               return true;
           if (obj == null)
               return false;
 
           return ( _numerator == obj._numerator && _denomenator == obj._denomenator);
       }
        /// <summary>
        /// Перекрытый метод получения Хэш-кода
        /// </summary>
        /// <returns>Хэш-код объекта</returns>
       public override int GetHashCode()
       {
           return _numerator * _numerator + _denomenator;
       }
        /// <summary>
        /// Сравнение двух дробей
        /// </summary>
        /// <param name="a">1 дробь</param>
        /// <param name="b">2 дробь</param>
        /// <returns>True, если равны, иначе False</returns>
       public static bool operator ==(Ratio a, Ratio b)
       {
           if ((object)a == null && (object)b == null)
               return true;
           if ((object)a == null || (object)b == null)
               return false;
           return a.Equals(b);
       }
        /// <summary>
        /// Сравнение дробей
        /// </summary>
        /// <param name="a">1 дробь</param>
        /// <param name="b">2 дробь</param>
        /// <returns>True если не равны, иначе False</returns>
       public static bool operator != (Ratio a, Ratio b)
       {
           if ((object)a == null && (object)b == null)
               return false;
           if ((object)a == null || (object)b == null)
               return true;
           return !(a.Equals(b));
       }
        /// <summary>
        /// Сравнение дробей
        /// </summary>
        /// <param name="o1">1 др</param>
        /// <param name="o2">2 др</param>
        /// <returns>True если 1 др больше 2 дроби иначе false</returns>
       public static bool operator > (Ratio o1, Ratio o2)
       {
           if( o1._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o1._denomenator 
               > o2._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o2._denomenator)
               return true;
           else return false;
       }
        /// <summary>
        /// Сравн дробей
        /// </summary>
        /// <param name="o1">1 др</param>
        /// <param name="o2">2 др</param>
        /// <returns>True, если первая меньше, иначе false</returns>
       public static bool operator < (Ratio o1, Ratio o2)
       {
           if (o1._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o1._denomenator
               < o2._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o2._denomenator)
               return true;
           else return false;
 
       }
       /// <summary>
       /// Сравн дробей
       /// </summary>
       /// <param name="o1">1 др</param>
       /// <param name="o2">2 др</param>
       /// <returns>True, если первая больше или равна второй, иначе false</returns>
       public static bool operator >= (Ratio o1, Ratio o2)
       {
           if (o1._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o1._denomenator
                  >= o2._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o2._denomenator)
               return true;
           else return false;
       }
       /// <summary>
       /// Сравн дробей
       /// </summary>
       /// <param name="o1">1 др</param>
       /// <param name="o2">2 др</param>
       /// <returns>True, если первая меньше или равна второй, иначе false</returns>
       public static bool operator <= (Ratio o1, Ratio o2)
       {
           if (o1._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o1._denomenator
               <= o2._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o2._denomenator)
               return true;
           else return false;
 
       }
        /// <summary>
        /// Сумма дробей
        /// </summary>
        /// <param name="o1">1 дробь</param>
        /// <param name="o2">2 дробь</param>
        /// <returns>Объект типа Ratio имеющий поля - почленные суммы элементов двух дробей</returns>
       public static Ratio operator + (Ratio o1, Ratio o2) // Сложение дробей
       {
           var result = new Ratio();
           result._numerator = o1._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o1._denomenator
               + o2._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o2._denomenator;
           result._denomenator = Mathematics.NOK(o1._denomenator, o2._denomenator);
 
           result.Reduction();
 
           return result;
       }
       /// <summary>
       /// Разность дробей
       /// </summary>
       /// <param name="o1">1 дробь</param>
       /// <param name="o2">2 дробь</param>
       /// <returns>Объект типа Ratio имеющий поля - почленные разности элементов двух дробей</returns>
       public static Ratio operator - (Ratio o1, Ratio o2) //Разность дробей
       {
           var result = new Ratio();
           result._numerator = o1._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o1._denomenator
               - o2._numerator * Mathematics.NOK(o1._denomenator, o2._denomenator) / o2._denomenator;
           result._denomenator = Mathematics.NOK(o1._denomenator, o2._denomenator);
 
 
           result.Reduction();
 
           return result;
       }
       /// <summary>
       /// Произведение двух дробей
       /// </summary>
       /// <param name="o1">1 дробь</param>
       /// <param name="o2">2 дробь</param>
       /// <returns>Объект типа Ratio имеющий поля-элементы, как при обычном перемножении рациональных чисел (См. Математика, школьный курс)</returns>
       public static Ratio operator *(Ratio o1, Ratio o2)
       {
           var result = new Ratio();
           result._numerator = o1._numerator * o2._numerator;
           result._denomenator = o1._denomenator * o2._denomenator;
           
           result.Reduction();
 
           return result;
       }
       /// <summary>
       /// Частное двух дробей
       /// </summary>
       /// <param name="o1">1 дробь</param>
       /// <param name="o2">2 дробь</param>
       /// <returns>Объект типа Ratio имеющий поля-элементы, как при обычном делении рациональных чисел (См. Математика, школьный курс)</returns>
       public static Ratio operator /(Ratio o1, Ratio o2)
       {
           var result = new Ratio();
           result._numerator = o1._numerator * o2._denomenator;
           result._denomenator = o1._denomenator * o2._numerator;
 
           result.Reduction();
 
           return result;
 
       }
        /// <summary>
        /// Метод сравения рациональных чисел
        /// </summary>
        /// <param name="obj">Объект класса (предполагается рац. число)</param>
        /// <returns>-1 если вызывающий метод экземпляр меньше экземпляра-параметра, 1 если больше, 0 если равны </returns>
       public int CompareTo(object obj)
       {
           if (this < (obj as Ratio))
               return -1;
           else
               if (this > (obj as Ratio))
                   return 1;
               else
                   return 0;
       }
       
 
       
        /// <summary>
        /// Сокращает числитель и знаменатель на НОД
        /// </summary>
       private void Reduction()
       {
           if (_numerator != 0)
           {
 
               int gcd;
               gcd = Mathematics.GCD(_numerator, _denomenator);
               _numerator /= gcd;
               _denomenator /= gcd;
           }
           else
           {
               _denomenator = 1;
           }
       }
       
        
        /// <summary>
        /// Перекрытый метод перевода в строку
        /// </summary>
        /// <returns>Строковое представление числа</returns>
       public override string ToString()
       {
           return this.ToString("G", CultureInfo.CurrentCulture);
       }
        /// <summary>
        /// Метод перевода в строку
        /// </summary>
        /// <param name="format">Формат вывода</param>
        /// <returns>Значение метода перевода в строку рац. числа (основного)</returns>
       private string ToString(string format)
       {
           return this.ToString(format, CultureInfo.CurrentCulture);
       }
        /// <summary>
        /// Форматированный вывод в строку числа типа Рациональное число
        /// </summary>
        /// <param name="format">Формат вывода</param>
        /// <param name="provider">Способ управления форматом</param>
        /// <returns>Строковое представление рац.числа, опираясь на формат. Если формат не распознан -- null</returns>
       public string ToString(string format, IFormatProvider provider)
       {
 
           if (String.IsNullOrEmpty(format))
               format = "G";
 
           if (provider == null)
               provider = CultureInfo.CurrentCulture;
 
           Regex reg = new Regex(@"^[Aa]\d+$", RegexOptions.Compiled); // Вывод с определённой точностью
           Match match = reg.Match(format);
           if (match.Success)
           {
               int precision = int.Parse(format.Substring(1));
               return Math.Round((double)Numer / (double)Denomer, precision).ToString();
           }
 
           switch (format.ToUpperInvariant())
           {
               case "G": // С плавающей запятой
               case "A":
                   
                   return ((double)Numer / (double)Denomer).ToString(); 
 
               case "B"://Правильная дробь
                   return (GetIPart()).ToString() + " " + (Math.Abs(_numerator % _denomenator)).ToString() + "/" + _denomenator.ToString();
                                              
               case "C": // Неправильна дробь
                   return (Numer).ToString() + "/" + Denomer.ToString() ;
 
               case "D": // Периодическая десятичная дробь
                   Reduction();
                   return ToPeriodString();
               default:
                   return null;
           }
       }
 
       public int GetIPart()
       {
           return _numerator / _denomenator;
       }
 
 
 
        /// <summary>
        /// Преобразование значения экземпляра дроби в строковое представление десятичной дроби с периодом.
        /// </summary>
        /// <param name="precision">Максимальная точность дроби</param>
        /// <returns>Строковое представление данного экземпляра в виде десятичной дроби с периодом.</returns>
        string ToPeriodString()
        {
            if (Denomer > 1e9) //если знаменатель дроби огромный //невозможно завести массив такого размера
                return (Numer / (decimal)Denomer).ToString(); //вернуть значение обычным делением
 
            byte[] StepRem = new byte[Denomer]; //в индекс "остаток от деления" записывается номер шага
            byte[] StepNum = new byte[byte.MaxValue]; // в индекс "номер шага" записывается цифра на данном шаге    
            byte step = 0,
            StartP = byte.MaxValue, EndP = byte.MaxValue,
            number = (byte)(Math.Abs((Numer % Denomer) * 10) / Denomer);
            long remainder = Math.Abs(Numer % Denomer);
 
            string answ = "";
            if (Numer < 0)
                answ += "-"; //записать знак
            answ += Math.Abs(Numer / Denomer).ToString();
            if (Numer % Denomer == 0) //если целое число, вернуть его
                return answ;
            answ += ",";
 
            while (true)
            {
                step++;
                remainder = (remainder * 10) % Denomer;
                if (remainder == 0) 
                    return (Numer / (decimal)Denomer).ToString(); //если нет периода вернуть обычным делением
                StepNum[step] = number;
 
                if (StepRem[remainder] != 0)
                {
                    EndP = --step; //записать конец периода
                    StartP = StepRem[remainder]; //записать начало периода
                    if (StepNum[StartP] != StepNum[EndP + 1]) //если между периодом и десятичной точкой
                    { //есть цифры, - сдвинуть период
                        StartP++;
                        EndP++;
                    }
                    break;
                }
 
                StepRem[remainder] = step;
                number = (byte)((remainder * 10) / Denomer); 
                
            }
 
            step = 0;
            number = (byte)Math.Abs((Numer % Denomer) * 10 / Denomer);
            remainder = Math.Abs(Numer % Denomer);
 
            while (step != EndP) //запись числа
            {
                step++;
                if (step == StartP)
                    answ += "(";
                answ += number.ToString();
                remainder = (remainder * 10) % Denomer;
                number = (byte)((remainder * 10) / Denomer);
            }
            return answ + ")";
        }
 
 
 
 
 
 
 
   }
 
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Lab1
{
    /// <summary>
    /// Класс для перевода строки в тип Рациональное число.
    /// </summary>
    public static class PParse
    {
        /// <summary>
        /// Метод позволяющий получить рациональное число из строки
        /// </summary>
        /// <param name="str">Строка, где, предположительно, находится число</param>
        /// <returns>Экземпляр класса рациональное число</returns>
        public static Ratio Parse(string str)
        {
 
            string[] str_comma = str.Split(',');
 
            if (str_comma.Length != 1)
                return ParseWithOutSlash(str);
            else return ParseWithSlash(str);
        }
        /// <summary>
        /// Метод парсинга не десятичных дробей (вызывается из основного метода)
        /// </summary>
        /// <param name="str">Строка, где, предположительно, находится число</param>
        /// <returns>Экземпляр класса рациональное число</returns>
        private static Ratio ParseWithSlash(string str)
        {
            {
                int n, d;
 
                string[] str_space = str.Split(' ');
                string[] str_div;
 
                if (str_space.Length == 1)//не было найдено пробелов
                {
                    str_div = str.Split('/');
 
                    if (str_div.Length == 1)//число задано только в виде целой части
                    {
                        n = int.Parse(str_div[0]);
 
                        if (n != 0)
                            return Ratio.Create(n,1);
                        else
                            return new Ratio();
 
                    }
                    else//число задано только в виде дробной части
                    {
                        n = int.Parse(str_div[0]);
                        d = int.Parse(str_div[1]);
 
                        return Ratio.Create(n, d);
                       
                    }
                }
 
                //дробь задана в смешанном виде
                str_div = str_space[1].Split('/');
 
                d = int.Parse(str_div[1]);
                if(int.Parse(str_space[0]) < 0)
                {
                    n = (int.Parse(str_div[0])  - int.Parse(str_space[0]) * d);
                    return Ratio.Create(-n, d);
                   
                }
                n = int.Parse(str_div[0]) + int.Parse(str_space[0]) * d;
 
                return Ratio.Create(n, d);
                
            }
        }
        /// <summary>
        /// Метод парсинга десятичных дробей (вызывается из основного метода)
        /// </summary>
        /// <param name="str">Строка, где, предположительно, находится число</param>
        /// <returns>Экземпляр класса рациональное число</returns>
        private static Ratio ParseWithOutSlash(string str)
        {
            int n = 0, d = 0, ipart = 0;
 
            string[] str_comma = str.Split(',');
            string[] str_bkt1 = str_comma[1].Split('(');
            string[] str_bkt2;
 
            ipart = int.Parse(str_comma[0]);
 
            if (str_bkt1.Length == 1)//Если не было найдено скобок (то бишь дробь не периодическая)
            {
                d = (int)(Math.Pow(10, str_comma[1].Length));
                n = int.Parse(str_comma[1]) + (int)Math.Abs(ipart * d);
                if(ipart < 0)
                    n *= -1;
                return Ratio.Create(n, d);
 
            }
            else//Иначе число задано в виде периодической дроби
            {
                str_bkt2 = str_bkt1[1].Split(')');
 
                if (str_bkt1[0].Length == 0)//не было найдено непериодической части (после запятой)
                {
                    for (int i = 0; i < str_bkt2[0].Length; i++)
                        d = 10 * d + 9;
                    if (ipart < 0)
                    {
                        ipart *= -1;
                        n = -(int.Parse(str_bkt2[0]) + ipart * d);
                    }
                    else n = int.Parse(str_bkt2[0]) + ipart * d;
 
                    if(n < 0)
                    {
                       n *= -1;
                       return Ratio.Create(-n, d);
                    }
                    else
                        return Ratio.Create(n, d);
 
                    
                }
                else
                {
                    string[] str_num = str.Split(',', '(',')');
                    int min = Math.Abs(int.Parse(str_num[0] + str_num[1] + str_num[2]));
                    int sub = Math.Abs(int.Parse(str_num[0] + str_num[1]));
 
                    string den ="";
                    int h;
                    for (h = 0; h < str_num[2].Length; h++)
                    {
                        den += "9";
                    }
                    for (h = 0; h < str_num[1].Length; h++)
                    {
                        den += "0";
                    }
 
                    d = int.Parse(den);
                    n = min - sub;
                    if (ipart < 0)
                        n *= -1;
                    return Ratio.Create(n, d);
                    
                }
            }
        }
 
 
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Lab1
{
    public static class Mathematics
    {
        /// <summary>
        /// НОК двух чисел
        /// </summary>
        /// <param name="a">1 число</param>
        /// <param name="b">2 число</param>
        /// <returns>НОК этих двух чисел</returns>
        public static int NOK(int a, int b)
        {
            return a * b / GCD(a, b);
        }
 
        /// <summary>
        /// НОД двух чисел
        /// </summary>
        /// <param name="a">Первое число</param>
        /// <param name="b">Второе число</param>
        /// <returns>НОД а и b</returns>
        public static int GCD(int a, int b)
        {
            int remainder;
 
            a = (int)Math.Abs(a);
            b = (int)Math.Abs(b);
            if (b > a)
            {
                remainder = a;
                a = b;
                b = remainder;
            }
 
            do
            {
                remainder = a % b;
                a = b;
                b = remainder;
            }
            while (remainder != 0);
            return a;
        }
 
        /// <summary>
        /// Сокращает два числа, поступившие по ссылкам, на их НОД
        /// </summary>
        /// <param name="n">Первое число</param>
        /// <param name="d">Второе число</param>
        public static void PReduction(ref int n, ref int d)
        {
            if (n != 0)
            {
                int gcd = Mathematics.GCD(n, d);
 
                if (gcd != 1)
                {
                    n /= gcd;
                    d /= gcd;
                }
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Lab1
{
    class Program
    {
        static void Main(string[] args)
        {
            Ratio num = Ratio.Create(-7,3);
            if (num != null)
            {
                Console.WriteLine("Число 0 C плавающей запятой " + num.ToString("A", null));
                Console.WriteLine("Число 0 С плавающей запятой (с точностью 3 знака) " + num.ToString("A3", null));
                Console.WriteLine("Число 0 Неправильная дробь " + num.ToString("C", null));
                Console.WriteLine("Число 0 Десятичная дробь (период)" + num.ToString("D", null));
 
            }
            Ratio lol = PParse.Parse("-1 1/4");
            Ratio test = PParse.Parse("-12,1(6)");
            if (lol != null)
            {
                Console.WriteLine("Число 1 полученное из строки в десятичной дроби (период) " + lol.ToString("D", null));
                Console.WriteLine("Число 1 полученное из строки в правильной дроби " + lol.ToString("B", null));
            }
            if (test != null)
            {
                Console.WriteLine("Число 2 полученное из строки в десятичной дроби (период)" + test.ToString("D", null));
                Console.WriteLine("Число 2 полученное из строки в неправильной дроби " + test.ToString("C", null));
            }
            Ratio sum = num + lol;
            if(sum != null)
                Console.WriteLine("Сумма двух дробей (0) и (1) " + sum.ToString("C", null));
 
            Console.ReadLine();
        }
    }
}