/// <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;
}
