/// <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>
/// Приравнивание массивов чисел
/// Сложение чисел
/// </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="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="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="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>
/// Вспомогательная функция, очищающая "лишние" нули: -0234 станет -234
/// </summary>
/// <returns>Для удобства, возвращает себя же</returns>
public Rational Clear()
{
Numerator.Clear();
Denominator.Clear();
return(this);
}
/// <summary>
/// Вспомогательная функция, очищающая "лишние" нули: -0234 станет -234
/// </summary>
/// <returns>Для удобства, возвращает себя же</returns>
public Digit Clear()
{
Value.Clear();
return(this);
}
/// <summary>
/// Проверка на ноль.
/// </summary>
/// <param name="input">Натуральное число</param>
/// <returns> True, если число равно нулю; False, если число не равно нулю. </returns>
public static bool Run(Natural input)
{
return(input.Clear().Length == 1 && input[0] == 0); //Предворительно очищаем массив от лишних нулей
}
