Beispiel #1
0
        /// <summary>
        /// Нахождение частного от деления целого на натуральное
        /// </summary>
        /// <param name="A">Делимое(целое число)</param>
        /// <param name="B">Делитель(меньшее натуральное число)</param>
        /// <returns>Целое число - частное от деления</returns>

        public static Digit Run(Digit A, Natural B)
        {
            //запоминаем знак целого числа
            int sign = Z_2.Run(A);

            // делаем из целого числа натуральное с равным модулем
            Natural abs = Z_1.Run(A);

            //частное от деления одного натурального на другое
            abs = N_11.Run(abs, B);

            Digit Result;

            //добавление знака (преобразование натурального в целое)
            //если число отрицательное
            if (sign == 2)
            {
                Result = new Digit(false, abs);
            }

            //если число неотрицательное
            else
            {
                Result = new Digit(true, abs);
            }

            return(Result);
        }
Beispiel #2
0
        /// <summary>
        /// Приравнивание массивов чисел
        /// Сложение чисел
        /// </summary>
        /// <param name="arr">Первое слагаемое</param>
        /// <param name="arr2">Второе слагаемое</param>
        /// <returns>Сумма сложения</returns>
        public static Natural Run(Natural n1, Natural n2)
        {
            Natural output = new Natural(new int[Math.Max(n1.Length, n2.Length) + 1]);

            for (int i = 0; i < output.Length; i++)
            {
                int a1 = 0;
                int a2 = 0;

                if (n1.Length - 1 >= i)
                {
                    a1 = n1[i];
                }
                if (n2.Length - 1 >= i)
                {
                    a2 = n2[i];
                }

                if ((output[i] + a1 + a2) >= 10)
                {
                    output[i + 1]++;
                    output[i] = ((output[i] + a1 + a2) - 10);
                }
                else
                {
                    output[i] = output[i] + a1 + a2;
                }
            }
            return(output.Clear());
        }
Beispiel #3
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);
            }
            }
        }
Beispiel #4
0
        /// <summary>
        /// НОК натуральных чисел
        /// </summary>
        /// <param name="A">Первое натуральное число</param>
        /// <param name="B">Второе натуральное число</param>
        /// <returns>Будет возвращено Наименьшее общее кратное </returns>
        public static Natural Run(Natural A, Natural B)
        {
            A.Clear(); B.Clear();                                     // Переменные очищаются от лишних нулей
            Natural output = N_11.Run(N_8.Run(A, B), N_13.Run(A, B)); // НОК = (a*b)/НОД(a,b) - это формула

            return(output);
        }
Beispiel #5
0
        /// <summary>
        /// Умноженает исходное число на 10^k
        /// </summary>
        /// <param name="k">Степень в которую возводится 10</param>
        /// <param name="newArr">новый массив в который перезаписывается исходный</param>

        public static Natural Run(Natural input, int k)

        {
            int[] newArr = new int[input.Length + k]; //создание массива большоего на k элементов

            input.Value.CopyTo(newArr, k);            //Переносим число в расширенный массив с нуными нулями

            return(new Natural(newArr));              //Возвращаям измененный массив
        }
Beispiel #6
0
        /// <summary>
        /// Умножение натуральных чисел
        /// </summary>
        /// <param name="A">Первый множитель</param>
        /// <param name="B">Второй мнжитель</param>
        /// <returns>Перемноженные числа</returns>
        public static Natural Run(Natural A, Natural B)
        {
            Natural ret = new Natural(new int[A.Clear().Length + B.Clear().Length]);

            for (int i = 0; i < B.Length; i++)
            {
                ret = N_4.Run(ret, N_7.Run(N_6.Run(A, B[i]), i));
            }
            return(ret.Clear());
        }
Beispiel #7
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);                         // Возвращаем остаток от деления
        }
Beispiel #8
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);
        }
Beispiel #9
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);
        }
Beispiel #10
0
        /// <summary>
        /// +1 к числу
        /// </summary>
        /// <param name="input">Число</param>
        /// <returns>Число + 1</returns>
        public static Natural Run(Natural input)
        {
            int i = 0;

            while (input[i] == 9)
            {
                input[i++] = 0;
                if (i == input.Length)
                {
                    int[] temp = new int[input.Length + 1];
                    input.Value.CopyTo(temp, 0);
                    input.Value = temp;
                    break;
                }
            }
            input[i]++;
            return(input);
        }
Beispiel #11
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);
        }
Beispiel #12
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());  // Возвращение НОД
        }
Beispiel #13
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();
            }
        }
Beispiel #14
0
        /// <summary>
        /// Умножение натурального числа на цифру
        /// </summary>
        /// <param name="input">Число, которое поступает на обработку</param>
        /// <param name="numeral">Цифра, на которую умножается число</param>
        /// <returns>Будет возвращен результат умножения натурального числа на цифру</returns>
        public static Natural Run(Natural input, int numeral)
        {
            Natural Result      = new Natural(new int[input.Length + numeral.ToString().Length]);
            int     edinicavyme = 0;
            int     val;

            for (int k = 0; k < Result.Length - 1; k++)
            {
                if (k >= input.Length)
                {
                    val = 0;
                }
                else
                {
                    val = input[k];
                }
                Result[k]   = ((numeral * val) % 10 + edinicavyme) % 10;
                edinicavyme = (numeral * val + edinicavyme) / 10;
            }
            Result[Result.Length - 1] = edinicavyme % 10;
            Result.Clear();
            return(Result);
        }
Beispiel #15
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);
        }
Beispiel #16
0
    {/// <summary>
     /// Сравнение натуральных чисел
     /// </summary>
     /// <param name="num1">Число, которое поступает на обработку</param>
     /// <param name="num2">Число, которое поступает на обработку</param>
     /// <returns>Будет возвращено: 0 (равны), 1 (первое больше), 2 (второе больше) </returns>

        public static int Run(Natural num1, Natural num2)
        {
            if (num1.Clear().Length > num2.Clear().Length)
            {
                return(1);
            }
            if (num1.Length < num2.Length)
            {
                return(2);
            }

            int a     = Math.Max(num1.Length, num2.Length);
            int Count = 0;

            for (int i = a - 1; i >= 0; i--)
            {
                if (num1[i] == num2[i])
                {
                    Count++;
                }
                else
                {
                    break;
                }
            }

            if (Count == a)
            {
                return(0);
            }
            if (num1[a - Count - 1] > num2[a - Count - 1])
            {
                return(1);
            }
            return(2);
        }
Beispiel #17
0
 /// <summary>
 /// Инициализация положительного числа
 /// </summary>
 /// <param name="Arr">Массив разрядов</param>
 public Digit(int[] Arr)
 {
     Value = new Natural(Arr);
 }
Beispiel #18
0
 /// <summary>
 /// Инициализация положительного числа
 /// </summary>
 /// <param name="data">Модуль числа</param>
 public Digit(Natural data)
 {
     Value = data;
 }
Beispiel #19
0
 /// <summary>
 /// Инициализация положительного числа
 /// </summary>
 /// <param name="data">Модуль числа</param>
 public Digit(string data)
 {
     Value = new Natural(data);
 }
Beispiel #20
0
 /// <summary>
 /// На вход подается натуральное число
 /// </summary>
 /// <param name="input"> Натуральное число</param>
 /// <returns>Целое число</returns>
 public static Digit Run(Natural input)
 {
     return(new Digit(true, input.Value).Clear());
 }
Beispiel #21
0
 /// <summary>
 /// Инициализация числа
 /// </summary>
 /// <param name="sign">Знак числа</param>
 /// <param name="data">Модуль числа</param>
 public Digit(bool sign, string data)
 {
     Value = new Natural(data);
     Sign  = sign;
 }
Beispiel #22
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;
 }
Beispiel #23
0
 /// <summary>
 /// Перевод из натурального в рациональное (знаменатель = 1)
 /// </summary>
 /// <param name="num">Числитель, переводимое число</param>
 public Rational(Natural num)
 {
     Numerator   = new Digit(num);
     Denominator = new Natural("1");
 }
Beispiel #24
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);
 }
Beispiel #25
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);
 }
Beispiel #26
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);
        }
Beispiel #27
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);
 }
Beispiel #28
0
 /// <summary>
 /// Перевод из целого в рациональное (знаменатель = 1)
 /// </summary>
 /// <param name="num">Числитель, переводимое число</param>
 public Rational(Digit num)
 {
     Numerator   = num;
     Denominator = new Natural("1");
 }
Beispiel #29
0
 /// <summary>
 /// Инициализация положительного рационального числа
 /// </summary>
 /// <param name="num">Числитель</param>
 /// <param name="denom">Знаменатель</param>
 public Rational(Natural num, Natural denom)
 {
     Numerator   = new Digit(num);
     Denominator = denom;
 }
Beispiel #30
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;
 }