HW1_TICD.cpp

#include <vector>
#include <iostream>
#include "Models/BigInt.h"

#define MAX_MANTISA_SIZE 30
using namespace std;
//= type;

bool compare(vector<int>& a, vector<int>& b); // возвращает ture если первое число больше

void subdivide(vector<int>& a, vector<int>& b); // вычитает из первого числа второе

void print(vector<int>& a) { // функция для печати вектора
    for (auto i : a) {
        //cout << i << ' ';
        cout << i;
    } cout << endl;
}


void divive(BigInt first, BigInt second) {


    // порядок ответа
    int e = 0;

    // мантиса ответа
    vector< int > ans = { 0 };

    bool a_sing = first.isSign();
    bool b_sing = second.isSign();
    // знак ответа
    bool ans_sing = a_sing == b_sing;

    vector<int> a = first.getNumber();
    vector<int> b = second.getNumber();


    while (a.size() < MAX_MANTISA_SIZE) {
        a.insert(a.begin(), 0);
    }

    while ( a.size() > MAX_MANTISA_SIZE )  {
      a.pop_back();
      e++;
    }

    while (b.size() < MAX_MANTISA_SIZE) {
        b.insert(b.begin(), 0);
    }

    while ( b.size() > MAX_MANTISA_SIZE )  {
      b.pop_back();
      e--;
    }

    for (int i = 0; i < MAX_MANTISA_SIZE; i++) {
        a.push_back(0);
        b.push_back(0);
    }


    // первый ненулевой знак числа a
    int first_non_zero_a = 0;
    for (first_non_zero_a = 0; a[first_non_zero_a] == 0; first_non_zero_a++);
    // первый ненулевой знак числа b
    int first_non_zero_b = 0;
    for (first_non_zero_b = 0; b[first_non_zero_b] == 0; first_non_zero_b++);


    // если первое число больше то двигаем второе число левее
    // чтобы столбиком делить
    if (compare(a, b)) {
        for (int i = 0; i < first_non_zero_b - first_non_zero_a; i++) {
            // двигаем на 1 влево
            b.erase(b.begin());
            b.push_back(0);
        }
    }

    // считаем на 30 знаков больше, чтобы точность была больше 30

    //cout << "first_non_zero_a " << first_non_zero_a << endl;
    //cout << "first_non_zero_b " << first_non_zero_b << endl;
    for (int i = 0; i < first_non_zero_b - first_non_zero_a + 1 + MAX_MANTISA_SIZE; i++) {

        // вычитаем пока можем
        // чтобы получить частное
        int n = 0;
        while (compare(a, b)) { // вычитаем пока первое число больше
            subdivide(a, b);
            n++;
        }

        ans.push_back(n);

        b.insert(b.begin(), 0); // двигаем челитель на 1 вправо
        b.pop_back();

    }


    e -= MAX_MANTISA_SIZE;



    for (int i = 0; i < ans.size() && i < 30; i++) {
        cout << ans[i];
    }
    cout << 'E';
    cout << e << endl;

    // вначале ответа могут быть незачащие нули
    // их надо убрать
    while (ans[0] == 0) {

        // если у нас осталась лишь одна цифра ноль
        // то её оставляем
        if (ans[0] == 0 && ans.size() == 1) {
            break;
        }

        ans.erase(ans.begin());
    }

    e += ans.size();

    while (ans[ans.size() - 1] == 0) {
        ans.pop_back();
    }
    e += first_non_zero_a - first_non_zero_b;


    cout << "0.";
    for (int i = 0; i < ans.size() && i < 30; i++) {
        cout << ans[i];
    }
    cout << 'E';
    cout << e << endl;


}


int main() {

    setlocale(LC_ALL, "Ru");

    BigInt a, b;
    string input1;
    string input2;
    cout << "Введите 1 число (до 30 знаков): ";
    cin >> input1;
    cout << "Введите 2 число (до 30 знаков): ";
    cin >> input2;
    if (input1 == "0") {
        cout << "0.0E0\n";
    }
    else {
        a.inputInt(input1);
        if (input2 == "0") {
            cout << "На 0 делить нельзя!\n";
        }
        else {
            b.inputInt(input2);
            divive(a, b);
        }
    }


    return 0;
}


bool compare(vector<int>& a, vector<int>& b) { // возвращает ture если первое число больше
    if (a.size() > b.size()) {
        return true;
    }
    else if (a.size() < b.size()) {
        return false;
    }
    else {
        for (int i = 0; i < a.size(); i++) {
            if (b[i] > a[i]) {
                return false;
            }
            else if (a[i] > b[i]) {
                return true;
            }
        }
    }
    // если числа равны возвращаю true
    // проверено, так надо
    // иначе 2 / 1 = 1.999999
    return true;
}

void subdivide(vector<int>& a, vector<int>& b) { // вычитает из первого числа второе
    // считается, что первое число в этой функции больше второго

    // Добавление недостающих разрядов
    // если одно число длиннее
    int max_size = max(a.size(), b.size());
    if (a.size() != max_size) {
        vector<int> tmp;
        for (int i = 0; i < max_size - a.size(); i++) {
            tmp.push_back(0);
        }
        for (int i = 0; i < a.size(); i++) {
            tmp.push_back(a[i]);
        }
        a = tmp;
    }
    if (b.size() != max_size) {
        vector<int> tmp;
        for (int i = 0; i < max_size - b.size(); i++) {
            tmp.push_back(0);
        }
        for (int i = 0; i < b.size(); i++) {
            tmp.push_back(b[i]);
        }
        b = tmp;
    }

    bool add = false;
    bool flag = false; // перенос разряда
    for (int i = 0; i < a.size(); i++) {
        int I = a.size() - i - 1; // Индекс с конца массива

        // Действие над числом
        if (add) {
            a[I] += b[I];
        }
        else {
            a[I] -= b[I];
        }

        // Проверка на то заняли ли мы разряд
        if (flag) {
            if (add) {
                a[I]++;
            }
            else {
                a[I]--;
            }
            flag = false;
        }

        // Проверка на то, что мы занимали разряд
        if (add) {
            if (a[I] >= 10) {
                flag = true;
                a[I] -= 10;
            }
        }
        else {
            if (a[I] < 0) {
                flag = true;
                a[I] += 10;
            }
        }
    }

}