Esempio n. 1
0
        /// <summary>
        /// Нахождение остатка от деления целого на натуральное
        /// </summary>
        /// <param name="A">Делимое(целое число)</param>
        /// <param name="B">Делитель(меньшее натуральное число)</param>
        /// <returns>Целое число - остаток от деления</returns>
        public static Digit Run(Digit A, Natural B)
        {
            Digit Result = Z_9.Run(A, B);           //Частное от деления большего целого на меньшее или равное натуральное с остатком
            Digit B_1    = new Digit(B);            //преобразуем делитель из типа Natural в тип Digit

            Result      = Z_8.Run(Result, B_1);     // Умножаем частное от деления на делитель
            Result      = Z_7.Run(A, Result);       // Находим остаток от деления
            Result.Sign = true;
            return(Result);                         // Возвращаем остаток от деления
        }
Esempio n. 2
0
        /// <summary>
        /// Сложение дробей
        /// </summary>
        /// <param name="R1"> Дробь </param>
        /// <param name="R2"> Дробь </param>
        /// <returns>Будет возвращенa сумма R1 и R2 </returns>
        public static Rational Run(Rational R1, Rational R2)
        {
            Digit NOK = new Digit(N_14.Run(R1.Denominator, R2.Denominator)); //Находим наибольшее общее кратное знаменателей

            //Находим, на что надо домножить числитель, чтобы привести к единому знаменателю и, собственно, домножаем
            R1.Numerator = Z_8.Run(R1.Numerator, Z_9.Run(NOK, R1.Denominator));
            R2.Numerator = Z_8.Run(R2.Numerator, Z_9.Run(NOK, R2.Denominator));

            //Складываем 2 дроби. Новый числитель - сумма 2-х предыдущих, новый знаменатель - НОК
            Rational R = new Rational(Z_6.Run(R1.Numerator, R2.Numerator), NOK);

            return(Q_1.Run(R)); //сокращенная дробь на выходе
        }
Esempio n. 3
0
        /// <summary>
        /// Костыль, приводящий дробь к адекватному виду
        /// </summary>
        /// <param name="A">Дробь</param>

        /*public static void Kostil(ref Rational A)
         * {
         *  if (A.Denominator.Sign==false)
         *  {
         *      A.Numerator.Sign = !A.Numerator.Sign;
         *      A.Denominator.Sign = true;
         *  }
         * } */

        /// <summary>
        /// Вычитание дробей
        /// </summary>
        /// <param name="A">Уменьшаемое</param>
        /// <param name="B">Вычитаемое</param>
        /// <returns>Результирующая дробь</returns>
        public static Rational Run(Rational A, Rational B)
        {
            //инкостыляция

            /*Kostil(ref A);
            *  Kostil(ref B);*/


            //Перевод НОК из натурального в целое
            Digit NOK = new Digit(true, N_14.Run(A.Denominator, B.Denominator));
            //Под общий знаменатель
            Rational Num1 = new Rational("1", "1");
            Rational Num2 = new Rational("1", "1");

            Num1.Numerator = Z_8.Run(A.Numerator, Z_9.Run(NOK, A.Denominator));
            Num2.Numerator = Z_8.Run(B.Numerator, Z_9.Run(NOK, B.Denominator));
            //Формируем результат: числитель как разность числителей, а знаменатель как НОК знаменателей
            Rational Result = new Rational(Z_7.Run(Num1.Numerator, Num2.Numerator), NOK);

            //Результат - сокращенная дробь
            return(Q_1.Run(Result));
        }
Esempio n. 4
0
 /// <summary>
 /// На вход подается целое число
 /// </summary>
 /// <param name="input"></param>
 /// <returns>Натуральное число</returns>
 public static Natural Run(Digit input)
 {
     return(input.Value.Clear());
 }
Esempio n. 5
0
 /// <summary>
 /// Умножение целых чисел
 /// </summary>
 /// <param name="A">Первый множитель</param>
 /// <param name="B">Второй мнжитель</param>
 /// <returns>Перемноженные числа</returns>
 public static Digit Run(Digit A, Digit B)
 {
     return(new Digit(A.Sign == B.Sign, N_8.Run(A.Value, B.Value)));
 }
Esempio n. 6
0
 /// <summary>
 /// Перевод из целого в дробное
 /// В знаменателе "1"
 /// </summary>
 /// <param name="input">Целое число</param>
 /// <returns>Дробное число</returns>
 public static Rational Run(Digit input)
 {
     return(new Rational(input));
 }
Esempio n. 7
0
        /// <summary>
        /// Функция сокращает многочлен
        /// </summary>
        /// <param name="polynom"> многочлен</param>
        /// <returns>Многочлен</returns>
        public static Polynomial Run(Polynomial polynom)
        {
            int        i, j;
            int        Len = polynom.Values.Length;
            Polynomial Pol = new Polynomial(polynom.Values); //Создается новая переменная полином

            Pol.Clear();                                     // очищаем от лишних нулей
            Natural E = new Natural(new int[] { 1 });

            //Проверка на нулевые
            Digit Null = new DiskMat.Digit(new int[] { 0 });

            // Алгоритм нахождения Нок
            Pol.Clear();              // очищаем от лишних нулей
            E = Pol.Values[0].Denominator;
            for (i = 0; i < Len; ++i) // Алгоритм нахождения Нок
            {
                E = N_14.Run((E), (Pol.Values[i].Denominator));
            }
            Natural Gt  = new Natural(E.Value);
            Digit   HOK = new Digit(new int[] { 1 });

            HOK = new Digit(Gt.Value);

            //Алгоритм вынесения НОК
            Pol.Clear();// очищаем от лишних нулей
            bool e;

            for (i = 0; i < Len; i++)
            {
                e = Pol.Values[i].Numerator.Sign;
                Pol.Values[i].Numerator      = Z_8.Run((Pol.Values[i].Numerator), Z_9.Run(HOK, Pol.Values[i].Denominator));// При убирании из знаменателя НОК, мы домножаем числитель на частное знаменателя и НОК
                Pol.Values[i].Denominator    = new Natural(new int[] { 1 });
                Pol.Values[i].Numerator.Sign = e;
            }

            // Алгоритм нахождения НОД
            Pol.Clear();              // очищаем от лишних нулей
            E = Z_5.Run(Pol.Values[0].Numerator);
            for (i = 0; i < Len; i++) // Алгоритм нахождения НОД
            {
                if (Pol.Values[i].Numerator != Null)
                {
                    E = N_13.Run(E, Z_5.Run(Pol.Values[i].Numerator));
                }
            }
            Natural HOD = E;    // Запоминаем Наибольший общий делитель

            //Алгоритм вынесения НОД
            Pol.Clear();    // очищаем от лишних нулей
            bool w;

            for (i = 0; i < Len; i++)
            {
                if (N_1.Run(Z_5.Run(Pol.Values[i].Numerator), Z_5.Run(new Digit(new int[] { 0 }))) != 0)    // Если в знаменателе не ноль, то работаем с ним
                {
                    w = Pol.Values[i].Numerator.Sign;
                    Pol.Values[i].Numerator      = Z_9.Run(Pol.Values[i].Numerator, HOD);// При убирании из числителя НОД , мы делим числитель на общий нод всех числителей
                    Pol.Values[i].Numerator.Sign = w;
                }
            }
            Pol.Clear();    // очищаем от лишних нулей
            return(Pol);
        }
Esempio n. 8
0
 /// <summary>
 /// Инициализация положительного рационального числа
 /// </summary>
 /// <param name="num">Числитель</param>
 /// <param name="denom">Знаменатель</param>
 public Rational(Natural num, Natural denom)
 {
     Numerator   = new Digit(num);
     Denominator = denom;
 }
Esempio n. 9
0
 /// <summary>
 /// Проверка на ноль.
 /// </summary>
 /// <param name="input">Целое число</param>
 /// <returns> True, если число равно нулю; False, если число не равно нулю. </returns>
 public static bool Run(Digit input)
 {
     return(Run(input.Value));
 }
Esempio n. 10
0
 /// <summary>
 /// Инициализация рационального числа
 /// </summary>
 /// <param name="sign">Знак</param>
 /// <param name="num">Числитель</param>
 /// <param name="denom">Знаменатель</param>
 public Rational(bool sign, Digit num, Digit denom)
 {
     Numerator   = num;
     Denominator = denom.Value;
     Sign        = sign;
 }
Esempio n. 11
0
 /// <summary>
 /// Инициализация рационального числа
 /// </summary>
 /// <param name="sign">Знак</param>
 /// <param name="num">Числитель</param>
 /// <param name="denom">Знаменатель</param>
 public Rational(bool sign, string num, string denom)
 {
     Numerator   = new Digit(sign, num);
     Denominator = new Natural(denom);
 }
Esempio n. 12
0
 /// <summary>
 /// Инициализация рационального числа
 /// </summary>
 /// <param name="num">Числитель</param>
 /// <param name="denom">Знаменатель</param>
 public Rational(string num, string denom)
 {
     Numerator   = new Digit(num);
     Denominator = new Natural(denom);
 }
Esempio n. 13
0
 /// <summary>
 /// Инициализация рационального числа
 /// </summary>
 /// <param name="num">Числитель</param>
 /// <param name="denom">Знаменатель</param>
 public Rational(Digit num, Digit denom)
 {
     Numerator   = num;
     Denominator = denom.Value;
     Sign        = !(denom.Sign ^ num.Sign);
 }
Esempio n. 14
0
 /// <summary>
 /// Перевод из натурального в рациональное (знаменатель = 1)
 /// </summary>
 /// <param name="num">Числитель, переводимое число</param>
 public Rational(Natural num)
 {
     Numerator   = new Digit(num);
     Denominator = new Natural("1");
 }
Esempio n. 15
0
 /// <summary>
 /// Перевод из целого в рациональное (знаменатель = 1)
 /// </summary>
 /// <param name="num">Числитель, переводимое число</param>
 public Rational(Digit num)
 {
     Numerator   = num;
     Denominator = new Natural("1");
 }
Esempio n. 16
0
 /// <summary>
 /// Инициализация рационального числа
 /// </summary>
 /// <param name="sign">Знак</param>
 /// <param name="num">Числитель</param>
 /// <param name="denom">Знаменатель</param>
 public Rational(bool sign, Natural num, Natural denom)
 {
     Numerator   = new Digit(sign, num);
     Denominator = denom;
 }
Esempio n. 17
0
 /// <summary>
 /// Вычитание целых чисел (в т.ч. отрицательных)
 /// </summary>
 /// <param name="A">Уменьшаемое</param>
 /// <param name="B">Вычитаемое</param>
 /// <returns>Разность</returns>
 public static Digit Run(Digit A, Digit B)
 {
     return(Z_6.Run(A, new Digit(!B.Sign, B.Value)));
 }