/// <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="R1"> Дробь </param>
/// <param name="R2"> Дробь </param>
/// <returns>Будет возвращенa сумма R1 и R2 </returns>
public static Rational Run(Rational R1, Rational R2)
{
Digit NOK = new Digit(N_14.Run(R1.Denominator, R2.Denominator)); //Находим наибольшее общее кратное знаменателей
//Находим, на что надо домножить числитель, чтобы привести к единому знаменателю и, собственно, домножаем
R1.Numerator = Z_8.Run(R1.Numerator, Z_9.Run(NOK, R1.Denominator));
R2.Numerator = Z_8.Run(R2.Numerator, Z_9.Run(NOK, R2.Denominator));
//Складываем 2 дроби. Новый числитель - сумма 2-х предыдущих, новый знаменатель - НОК
Rational R = new Rational(Z_6.Run(R1.Numerator, R2.Numerator), NOK);
return(Q_1.Run(R)); //сокращенная дробь на выходе
}
/// <summary>
/// Костыль, приводящий дробь к адекватному виду
/// </summary>
/// <param name="A">Дробь</param>
/*public static void Kostil(ref Rational A)
* {
* if (A.Denominator.Sign==false)
* {
* A.Numerator.Sign = !A.Numerator.Sign;
* A.Denominator.Sign = true;
* }
* } */
/// <summary>
/// Вычитание дробей
/// </summary>
/// <param name="A">Уменьшаемое</param>
/// <param name="B">Вычитаемое</param>
/// <returns>Результирующая дробь</returns>
public static Rational Run(Rational A, Rational B)
{
//инкостыляция
/*Kostil(ref A);
* Kostil(ref B);*/
//Перевод НОК из натурального в целое
Digit NOK = new Digit(true, N_14.Run(A.Denominator, B.Denominator));
//Под общий знаменатель
Rational Num1 = new Rational("1", "1");
Rational Num2 = new Rational("1", "1");
Num1.Numerator = Z_8.Run(A.Numerator, Z_9.Run(NOK, A.Denominator));
Num2.Numerator = Z_8.Run(B.Numerator, Z_9.Run(NOK, B.Denominator));
//Формируем результат: числитель как разность числителей, а знаменатель как НОК знаменателей
Rational Result = new Rational(Z_7.Run(Num1.Numerator, Num2.Numerator), NOK);
//Результат - сокращенная дробь
return(Q_1.Run(Result));
}
/// <summary>
/// На вход подается целое число
/// </summary>
/// <param name="input"></param>
/// <returns>Натуральное число</returns>
public static Natural Run(Digit input)
{
return(input.Value.Clear());
}
/// <summary>
/// Умножение целых чисел
/// </summary>
/// <param name="A">Первый множитель</param>
/// <param name="B">Второй мнжитель</param>
/// <returns>Перемноженные числа</returns>
public static Digit Run(Digit A, Digit B)
{
return(new Digit(A.Sign == B.Sign, N_8.Run(A.Value, B.Value)));
}
/// <summary>
/// Перевод из целого в дробное
/// В знаменателе "1"
/// </summary>
/// <param name="input">Целое число</param>
/// <returns>Дробное число</returns>
public static Rational Run(Digit input)
{
return(new Rational(input));
}
/// <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="num">Числитель</param>
/// <param name="denom">Знаменатель</param>
public Rational(Natural num, Natural denom)
{
Numerator = new Digit(num);
Denominator = denom;
}
/// <summary>
/// Проверка на ноль.
/// </summary>
/// <param name="input">Целое число</param>
/// <returns> True, если число равно нулю; False, если число не равно нулю. </returns>
public static bool Run(Digit input)
{
return(Run(input.Value));
}
/// <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;
}
/// <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>
/// Инициализация рационального числа
/// </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="num">Числитель</param>
/// <param name="denom">Знаменатель</param>
public Rational(Digit num, Digit denom)
{
Numerator = num;
Denominator = denom.Value;
Sign = !(denom.Sign ^ num.Sign);
}
/// <summary>
/// Перевод из натурального в рациональное (знаменатель = 1)
/// </summary>
/// <param name="num">Числитель, переводимое число</param>
public Rational(Natural num)
{
Numerator = new Digit(num);
Denominator = new Natural("1");
}
/// <summary>
/// Перевод из целого в рациональное (знаменатель = 1)
/// </summary>
/// <param name="num">Числитель, переводимое число</param>
public Rational(Digit num)
{
Numerator = num;
Denominator = new Natural("1");
}
/// <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>
/// Вычитание целых чисел (в т.ч. отрицательных)
/// </summary>
/// <param name="A">Уменьшаемое</param>
/// <param name="B">Вычитаемое</param>
/// <returns>Разность</returns>
public static Digit Run(Digit A, Digit B)
{
return(Z_6.Run(A, new Digit(!B.Sign, B.Value)));
}