Пример #1
0
        /// <summary>
        /// Вычитание из одного натурального другого, умноженного на цифру
        /// </summary>
        /// <param name="Num1">Уменьшаемое</param>
        /// <param name="Num2">Вычитаемое</param>
        /// <param name="Multiplier">Множитель второго числа</param>
        /// <returns>Разность</returns>
        public static Natural Run(Natural Num1, Natural Num2, Natural Multiplier)
        {
            Natural Difference     = new Natural("0");
            Natural Num2Multiplied = N_8.Run(Num2, Multiplier); // Умножаем второй множитель на цифру

            switch (N_1.Run(Num1, Num2Multiplied))              // Если второе больше, меняем числа местами
            {
            case 0:                                             // Если числа равны, то разность = 0
            {
                return(Difference);
            }

            case 1:                     // Если первое больше, вычитаем из него второе
            {
                Difference = N_5.Run(Num1, Num2Multiplied);
                return(Difference);
            }

            default:                     // Если второе больше, меняем числа местами и вычитаем
            {
                Natural NumSupport = Num1;
                Num1       = Num2Multiplied;
                Num2       = NumSupport;
                Difference = N_5.Run(Num1, Num2);
                return(Difference);
            }
            }
        }
Пример #2
0
        /// <summary>
        /// Остаток от деления большего натурального числана меньшее или равное натуральное
        /// </summary>
        /// <param name="num1">Первое натуральное число</param>
        /// <param name="num2">Второе натуральное число</param>
        /// <returns>Будет возвращен остаток от деления</returns>
        public static Natural Run(Natural num1, Natural num2)
        {
            num1.Clear(); num2.Clear();
            if (N_1.Run(num1, num2) == 2)
            {
                throw new Exception();                          // Если второе число больше, то ошибка
            }
            Natural DivResult = N_11.Run(num1, num2);           // Находим частное от деления
            Natural ModResult = N_9.Run(num1, num2, DivResult); // С помощью частного находим остаток

            return(ModResult);
        }
Пример #3
0
        /// <summary>
        /// Вспомогательная функция, очищающая "лишние" нули: -0234 станет -234
        /// </summary>
        /// <returns>Для удобства, возвращает себя же</returns>
        public Polynomial Clear()
        {
            foreach (Rational R in Values)
            {
                R.Clear();
            }
            int counter = 0;

            for (int i = Length - 1; i >= 0 && N_1.Run(Values[i].Numerator.Value, new Natural("0")) == 0; --i)
            {
                counter++;
            }
            Values = AddMath.SubArray(Values, Length - counter);
            if (Length == 0)
            {
                Values = new Rational[] { }
            }
            ;
            return(this);
        }
Пример #4
0
        /// <summary>
        /// Вычисление частного от деления
        /// </summary>
        /// <param name="num1">Первое число, которое поступает на обработку</param>
        /// <param name="num2">Второе число, которое поступает на обработку</param>
        /// <returns>Будет возвращено частное</returns>
        public static Natural Run(Natural num1, Natural num2)
        {
            num1.Clear(); num2.Clear();
            if (N_1.Run(num1, num2) == 2 || N_2.Run(num2))
            {
                throw new Exception();                        // если второе число больше, то ошибка
            }
            Natural Result     = N_10.Run(num1, num2);        // вычисление первой цифры деления
            Natural Prom       = N_9.Run(num1, num2, Result); // вычитание из первого числа второго, умноженного на первую цифру деления
            Natural PromResult = new Natural(new int[1]);

            while (N_1.Run(num2, Prom) == 2)
            {
                PromResult = N_10.Run(Prom, num2);
                Prom       = N_9.Run(Prom, num2, PromResult);
                Result     = N_4.Run(Result, PromResult);
            }
            num1 = N_4.Run(N_8.Run(num2, Result), Prom);
            return(Result);
        }
Пример #5
0
        /// <summary>
        /// НОД натуральных чисел
        /// </summary>
        /// <param name="num1">Первое натуральное число</param>
        /// <param name="num2">Второе натуральное число</param>
        /// <returns>Будет возвращен наибольший общий делитель</returns>
        public static Natural Run(Natural num1, Natural num2)
        {
            num1.Clear(); num2.Clear();
            Natural A1     = num1;
            Natural A2     = num2;
            Natural NodSup = new Natural("0");

            if (N_1.Run(num1, num2) == 2)      // Если второе число больше, меняем их местами
            {
                Natural Asupport = num1;
                A1 = A2;
                A2 = Asupport;
            }
            while (N_2.Run(A2) == false)  // Пока второе число не будет равно 0
            {
                NodSup = N_12.Run(A1, A2);
                A1     = A2;
                A2     = NodSup;
            }
            return(A1.Clear());  // Возвращение НОД
        }
Пример #6
0
    {/// <summary>
        /// Вычитание из первого большего натурального числа второго меньшего или равного
        /// </summary>
        /// <param name="A">Большее число, которое поступает на обработку</param>
        /// <param name="B">Меньшее или равное число, которое поступает на обработку</param>
        /// <returns>Результат вычитания из большего меньшего</returns>
        public static Natural Run(Natural A, Natural B)
        {
            Natural Result = new Natural(new int[A.Length]);

            switch (N_1.Run(A, B))
            {
            case 0:      //Если оба числа равны, результатом вычитания будет 0
                return(new Natural("0"));

            case 1:       //Если первое число больше, вычитаем из него первое
            {
                int h = 0;
                for (int i = 0; i <= B.Length - 1; i++)
                {
                    Result[i] = A[i] - B[i] - h;        //Поразрядное вычитание
                    h         = 0;
                    if (Result[i] < 0)
                    {
                        Result[i] = Result[i] + 10; //Избавление от отрицательности
                        h         = 1;              //"Занятие" единицы у следующего разряда
                    }
                }
                for (int i = B.Length; i < A.Length; i++)
                {
                    Result[i] = A[i] - h;
                    h         = 0;
                    if (Result[i] < 0)
                    {
                        Result[i] = Result[i] + 10; //Избавление от отрицательности
                        h         = 1;              //"Занятие" единицы у следующего разряда
                    }
                }
            }
                return(Result.Clear());

            default:       // Если второе число больше, то условие не выполняется
                throw new Exception();
            }
        }
Пример #7
0
        /// <summary>
        /// Вычисление первой цифры деления и умножение ее на 10^k, где k - ее разряд (второе число не меньше первого)
        /// </summary>
        /// <param name="n1">Первое натуральное число</param>
        /// <param name="n2">Второе натуральное число</param>
        /// <returns>Будет возвращен результат вычисления первой цифры деления и умноженной на 10^k, где k - ее разряд</returns>
        public static Natural Run(Natural n1, Natural n2)
        {
            n1.Clear(); n2.Clear();

            if (N_1.Run(n1, n2) == 2)
            {
                throw new Exception();                                                  // Если первое число меньше второго, то ошибка
            }
            Natural temp = new Natural(new int[1]);
            int     k    = 0;

            do
            {
                if (temp.Length == k)
                {
                    temp = new Natural(new int[temp.Length + 1]);                       // Если длинна передаваемого числа болььше длинны массива, увеличить его на 1
                }
                for (int p = 0; p <= k; p++)                                            // Передача числа по разрядно из входящего во временный
                {
                    temp.Value[temp.Length - p - 1] = n1.Value[n1.Length - p - 1];
                }

                k++;
            } while (N_1.Run(temp, n2) == 2);

            int i = 1;

            while (N_1.Run(N_6.Run(n2, ++i), temp) != 1)
            {
                ;                                                                       // Вычисление первой цифры от деления чисел
            }
            Natural result = new Natural(new int[n1.Length - k + 1]);

            result[result.Length - 1] = i - 1;

            return(result);
        }
Пример #8
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);
        }
Пример #9
0
 public override string ToString()
 {
     return((Sign ? "" : "-") + Numerator.Value + (N_1.Run(Denominator, new Natural("1")) != 0 ? "/" + Denominator : ""));
 }