/// <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); }
/// <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()); }
/// <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); } } }
/// <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); }
/// <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)); //Возвращаям измененный массив }
/// <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()); }
/// <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); // Возвращаем остаток от деления }
/// <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); }
/// <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); }
/// <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); }
/// <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); }
/// <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()); // Возвращение НОД }
{/// <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(); } }
/// <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); }
/// <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); }
{/// <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); }
/// <summary> /// Инициализация положительного числа /// </summary> /// <param name="Arr">Массив разрядов</param> public Digit(int[] Arr) { Value = new Natural(Arr); }
/// <summary> /// Инициализация положительного числа /// </summary> /// <param name="data">Модуль числа</param> public Digit(Natural data) { Value = data; }
/// <summary> /// Инициализация положительного числа /// </summary> /// <param name="data">Модуль числа</param> public Digit(string data) { Value = new Natural(data); }
/// <summary> /// На вход подается натуральное число /// </summary> /// <param name="input"> Натуральное число</param> /// <returns>Целое число</returns> public static Digit Run(Natural input) { return(new Digit(true, input.Value).Clear()); }
/// <summary> /// Инициализация числа /// </summary> /// <param name="sign">Знак числа</param> /// <param name="data">Модуль числа</param> public Digit(bool sign, string data) { Value = new Natural(data); Sign = sign; }
/// <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; }
/// <summary> /// Перевод из натурального в рациональное (знаменатель = 1) /// </summary> /// <param name="num">Числитель, переводимое число</param> public Rational(Natural num) { Numerator = new Digit(num); Denominator = new Natural("1"); }
/// <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); }
/// <summary> /// Инициализация рационального числа /// </summary> /// <param name="num">Числитель</param> /// <param name="denom">Знаменатель</param> public Rational(string num, string denom) { Numerator = new Digit(num); Denominator = new Natural(denom); }
/// <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); }
/// <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); }
/// <summary> /// Перевод из целого в рациональное (знаменатель = 1) /// </summary> /// <param name="num">Числитель, переводимое число</param> public Rational(Digit num) { Numerator = num; Denominator = new Natural("1"); }
/// <summary> /// Инициализация положительного рационального числа /// </summary> /// <param name="num">Числитель</param> /// <param name="denom">Знаменатель</param> public Rational(Natural num, Natural denom) { Numerator = new Digit(num); Denominator = denom; }
/// <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; }