integer ADD_ZZ_Z(const integer& a, const integer& b) {
integer first = a;
integer second = b;
integer result;
if (first.isPositive == second.isPositive) { // Если знаки равны
// Знак результата - знак одного из чисел, а модуль - сумма модулей
result.isPositive = first.isPositive;
result.module = ADD_NN_N(first.module, second.module);
} else { // Если знаки разные
// Если первое по модулю больше, то знак результата равен знаку первого
if (COM_NN_D(first.module, second.module) == ordinal::GT) {
result.isPositive = first.isPositive;
result.module = SUB_NN_N(first.module, second.module);
}
//Если второе по модулю больше, то знак результата равен знаку второго
if (COM_NN_D(first.module, second.module) == ordinal::LT) {
result.isPositive = second.isPositive;
result.module = SUB_NN_N(second.module, first.module);
}
// Модуль в обоих случаях равен разнице модулей
// Иначе результат останется равным 0
}
return result;
}
DM_N SUB_NN_N(DM_N n1, DM_N n2){
DM_N temp;
if(COM_NN_D(n1, n2) == 2){ //Если n1 > n2 число больше
for(int i = n1.n; i > n2.n; i--){
if(n1.a[i] - n2.a[i] >= 0){ //Если разность чисел больше нуля,
temp.a[i] = n1.a[i] - n2.a[i]; //Тогда просто вычитаем большее из меньшего
}else{ //Иначе
n1.a[i - 1]--; //"Занимаем" 10 из следующего разряда, а затем вычитаем
n1.a[i] += 10;
temp.a[i] = n1.a[i] - n2.a[i];
}
}
} else if (COM_NN_D(n1, n2) == 1){ // Если n2 > n1 число больше
for(int i = n2.n; i > n1.n; i--){
if(n2.a[i] - n1.a[i] >= 0){ //Если разность чисел больше нуля,
temp.a[i] = n2.a[i] - n1.a[i]; //Тогда просто вычитаем большее из меньшего
}else{ //Иначе
n2.a[i - 1]--; //"Занимаем" 10 из следующего разряда, а затем вычитаем
n2.a[i] += 10;
temp.a[i] = n2.a[i] - n1.a[i];
}
}
//Удаление лишних нулей
int k = 0;
int newLength //Размер массива без лишних нулей
int pos; //Номер первого ненулевого элемента
while(temp.a[k] == 0){ //Вычисление длины нового числа
k++;
}
if(k != 0){//Если есть лишние нули
newLength = temp.n - k;
for(int j = 0; j < newLength; j++){ //Сдвигаем число в начало массива
temp.a[j] = temp.a[j + pos];
}
temp.a = (short unsigned int*) realloc(temp.a, sizeof(short unsigned int)*newLength); //Изменяем размер массива, чтобы он был равен новой длине числа
temp.n = newLength;
}
}else{ //Если n1 = n2
temp.a = (short unsigned int*) realloc(temp.a, sizeof(short unsigned int));
temp.n = 1;
temp.a[0] = 0;
}
return temp;
}
DM_Z DIV_ZZ_Z (DM_Z X1, DM_Z X2)
{
DM_N t; //Объявляем переменную счётчик
DM_N natX1 = TRANS_Z_N (X1); //Объявляем натуральные аналоги целым числам
DM_N natX2 = TRANS_Z_N (X2);
if (!NZER_N_B(natX2)) //Если делитель равен нулю. выдаем ошибку
printf("Делитель равен нулю.");
else if (COM_NN_D(natX1, natX2)==2) //Если Первое число больше второго:
{
do
{
natX1=SUB_NN_N(natX1, natX2); //Вычитаем из большего числа меньшее
t=ADD_1N_N(t); //Наращиваем t
}
while (COM_NN_D(natX1, natX2)==2); //Цикл пока делимое больше делителя
t = TRANS_N_Z(t); //Переводим результат в целое
if (POZ_Z_D(X1)==1 && POZ_Z_D(X2)==2 || POZ_Z_D(X1)==2 && POZ_Z_D(X2)==1)
t= MUL_Z-_Z(t); //Если исходные числа имеют разные знаки,
//Поменять знак у результата
return t;
}
else if (COM_NN_D(natX1, natX2)==1) //Если второе число больше первого:
{ //Выполняем аналогичные действия.
do
{
natX1=SUB_NN_N(natX1,natX1);
t=ADD_1N_N(t);
}
while (COM_NN_D(natX1, natX1)==2);
t = TRANS_N_Z(t);
if (POZ_Z_D(X1)==1 && POZ_Z_D(X2)==2 || POZ_Z_D(X1)==2 && POZ_Z_D(X2)==1)
t= MUL_Z-_Z(t);
return t;
}
else if (COM_N_D(natX1, natX2)==0) // Если числа равны:
{
t = TRANS_N_Z(t); // Переводим t в целое
t.a[0]=1; //Присваиваем результату значение 1
t.n=1;
if ((POZ_Z_D(X2)==2 && POZ_Z_D(X1)==1) || (POZ_Z_D(X2)==1 && POZ_Z_D(X1)==2))
t.b=!t.b; //Если исходные числа имели разные знаки, меняем знак результата.
}
return t;
}
DM_N DIV_NN_N (DM_N X1, DM_N X2)
{
DM_N xCopy; //Объявляем временную переменную, которая будет
//хранить копию делимого
DM_N t=DM_N(); //Объявляем переменную счётчик, обнуляем.
if (!NZER_N_B(X2)) //Если делитель равен нулю, выдает ошибку
printf("Делитель равен нулю.");
else
if (COM_NN_D(X1, X2)==2) //Если Первое число больше второго:
{
xCopy=X1; //Во временную переменную записываем значение большего числа
do
{
xCopy=SUB_NN_N(xCopy, X2); //Вычитаем из большего числа меньшее
t=ADD_1N_N(t); //Наращиваем t
}
while (COM_NN_D(xCopy, X2)==2 || COM_NN_D(xCopy, X2)==0); //Цикл пока делимое больше или равно делителя
return t; //Возвращаем t
}
else
if (COM_NN_D(X1, X2)==1) //Если второе число больше первого: (Делаем те же операции)
{
xCopy = X2;
do
{
xCopy=SUB_NN_N(xCopy,X1);
t=ADD_1N_N(t);
}
while (COM_NN_D(xCopy, X1)==2);
return t;
}
else
if (COM_N_D(X1, X2)==0) //Если числа равны
{
t=ADD_1N_N(t); //Наращиваем один раз t, чтобы t равнялось 1
return t; //Возвращаем t;
}
}
natural SUB_NDN_N(const natural& a, const natural& b, const digit& n) {
natural res = a;
natural mul_sub = b;
digit fact = n;
mul_sub = MUL_ND_N(mul_sub, fact);
if (COM_NN_D(res, mul_sub) == ordinal::GT) {
auto res_2 = SUB_NN_N(res, mul_sub);
return res_2;
} else {
throw std::invalid_argument("Your digit is too big");
}
}
struct INTEGER SUB_ZZ_Z(struct INTEGER summand1, struct INTEGER summand2) // result = summand1 + summand2
{
struct INTEGER result;
/* Проверить числа на равенство */
if (COM_NN_D(ABS_Z_N(summand1), ABS_Z_N(summand2)) == 0)
{
/* Числа равны по модулю */
if (POZ_Z_D(summand1) == POZ_Z_D(summand2))
/* знаки одинаковы */
{
result.natural_part = ADD_NN_N(ABS_Z_N(summand1), ABS_Z_N(summand2));
result.sign = summand1.sign;
}
else
{
/* знаки разные */
result.natural_part.index = 0;
result.natural_part.number = (int*)malloc( sizeof(int) );
result.natural_part.number[0] = 0;
result.sign = 0;
}
}
else
{
/* Числа не равны */
if (POZ_Z_D(summand1) == POZ_Z_D(summand2))
{
/* Знаки совпадают */
result.natural_part = ADD_NN_N(ABS_Z_N(summand1), ABS_Z_N(summand2));
result.sign = POZ_Z_D(summand1);
}
else
{
/* Знаки разные */
result.natural_part = SUB_NN_N(ABS_Z_N(summand1), ABS_Z_N(summand2));
result.sign = POZ_Z_D(summand1);
}
}
return result;
}
TEST_CASE ( "Натуральные числа", "[natural]" ) {
#ifdef COM_NN_D_CPP
SECTION ( "COM_NN_D [сравнение]" ) {
natural a, b;
a = { _4, _2 };
// рефлексивность
REQUIRE ( a == a );
a = { _9, _8 };
b = { _8, _9 };
// Симметричность
REQUIRE ( COM_NN_D(a, b) == ordinal::GT );
REQUIRE ( COM_NN_D(b, a) == ordinal::LT );
natural c = { _7 };
// транзитивность
REQUIRE ( COM_NN_D(b, c) == ordinal::GT );
REQUIRE ( COM_NN_D(a, c) == ordinal::GT );
a = { _0, _1, _2 };
b = { _1, _0, _0 };
REQUIRE ( COM_NN_D(a, b) == ordinal::LT );
}
#endif // COM_NN_D_CPP
