/// <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="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>
/// Вспомогательная функция, очищающая "лишние" нули: -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);
}
/// <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>
/// Вычисление первой цифры деления и умножение ее на 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="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);
}
public override string ToString()
{
return((Sign ? "" : "-") + Numerator.Value + (N_1.Run(Denominator, new Natural("1")) != 0 ? "/" + Denominator : ""));
}