Exemple #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);                         // Возвращаем остаток от деления
        }
Exemple #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)); //сокращенная дробь на выходе
        }
Exemple #3
0
        /// <summary>
        /// сокращение дроби
        /// </summary>
        /// <param name="A"> Дробь </param>
        /// <returns>Будет возвращенa сокращенная дробь </returns>
        public static Rational Run(Rational A)
        {
            if (A.Clear().Numerator[0] == 0 && A.Numerator.Length == 1)
            {
                return(new Rational("0"));
            }
            Natural HOD = N_13.Run(Z_5.Run(new Digit(A.Denominator)), Z_5.Run(A.Numerator)); // Находим НОД числителя и знаменателя

            A.Numerator   = Z_9.Run(A.Numerator, HOD);                                       //Сокращаем числитель на НОД числителя и знаменятеля
            A.Denominator = N_11.Run(A.Denominator, HOD);                                    // Сокращаем знаменатель на нод

            return(A);
        }
Exemple #4
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));
        }
Exemple #5
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);
        }