Деление Ньютона-Рафсона На Большие Числа

Я делаю класс BigInt как упражнение по программированию. Он использует вектор 2-х дополняющих подписанных ints в base-65536 (так что 32-разрядные умножения не переполняются. Я увеличу базу, как только она полностью заработает).

все основные математические операции закодированы, с одной проблемой: деление больно медленно с основным алгоритмом, который я смог создать. (Это работает как двоичное деление для каждой цифры частного... Я не собираюсь его публиковать. если только кто-то не захочет посмотреть....)

вместо моего медленного алгоритма я хочу использовать Ньютона-Рафсона, чтобы найти (сдвинутый) взаимный, а затем умножить (и сдвинуть). Я думаю, что у меня есть голова вокруг основ: вы даете формулу (x1 = x0 (2 - x0 * делитель)) хорошее начальное предположение, а затем после некоторого количества итераций x сходится к взаимному. Эта часть кажется достаточно простой... но я сталкиваюсь с некоторыми проблемами при попытке применить эту формулу к big целые числа:

Проблема 1:

потому что я работаю с целыми числами... что ж... Я не могу использовать дроби. Это, по-видимому, заставляет x всегда расходиться (x0 * делитель должен быть d здесь d * [base^somePower]? Может ли быть какое-то уравнение типа (x1 = x0 (2 - x0 * d)), который работает с целыми числами?

Проблема 2:

когда я использую формулу Ньютона, чтобы найти реципрокность некоторых чисел, результат оказывается просто небольшой фракцией ниже того, что должен быть ответ... бывший. при попытке найти взаимное значение 4 (в десятичном формате):

x0 = 0.3
x1 = 0.24
x2 = 0.2496
x3 = 0.24999936
x4 = 0.2499999999983616
x5 = 0.24999999999999999999998926258176

Если бы я был представляя числа в базе-10, я хотел бы получить результат 25 (и не забыть сдвинуть вправо произведение на 2). С некоторыми reciprocals как 1/3, вы можете просто усечь Результат после того как вы знаете вы имеете достаточную точность. Но как я могу вытащить правильный ответный из вышеуказанного результата?

Извините, если это слишком расплывчато или если я прошу слишком много. Я просмотрел Википедию и все исследовательские работы, которые я мог найти в Google, но я чувствую, что я бьюсь головой о стена. Я ценю любую помощь, которую кто-либо может мне дать!

...

Edit: алгоритм работает, хотя он намного медленнее, чем я ожидал. Я действительно потерял много скорости по сравнению с моим старым алгоритмом, даже на числах с тысячами цифр... Я все еще чего-то не понимаю. Это не проблема с умножением, которое происходит очень быстро. (Я действительно использую алгоритм Карацубы).

для всех, кто заинтересован, вот моя текущая итерация Ньютона-Рафсона алгоритм:

bigint operator/(const bigint& lhs, const bigint& rhs) {
    if (rhs == 0) throw overflow_error("Divide by zero exception");
    bigint dividend = lhs;
    bigint divisor = rhs;

    bool negative = 0;
    if (dividend < 0) {
        negative = !negative;
        dividend.invert();
    }
    if (divisor < 0) {
        negative = !negative;
        divisor.invert();
    }

    int k = dividend.numBits() + divisor.numBits();
    bigint pow2 = 1;
    pow2 <<= k + 1;

    bigint x = dividend - divisor;
    bigint lastx = 0;
    bigint lastlastx = 0;
    while (1) {
        x = (x * (pow2 - x * divisor)) >> k;
        if (x == lastx || x == lastlastx) break;
        lastlastx = lastx;
        lastx = x;
    }
    bigint quotient = dividend * x >> k;
    if (dividend - (quotient * divisor) >= divisor) quotient++;
    if (negative)quotient.invert();
    return quotient;
}

и вот мой (очень некрасиво) старый алгоритм, который быстрее:

bigint operator/(const bigint& lhs, const bigint & rhs) {
    if (rhs == 0) throw overflow_error("Divide by zero exception");
    bigint dividend = lhs;
    bigint divisor = rhs;

    bool negative = 0;
    if (dividend < 0) {
        negative = !negative;
        dividend.invert();
    }
    if (divisor < 0) {
        negative = !negative;
        divisor.invert();
    }

    bigint remainder = 0;
    bigint quotient = 0;
    while (dividend.value.size() > 0) {
        remainder.value.insert(remainder.value.begin(), dividend.value.at(dividend.value.size() - 1));
        remainder.value.push_back(0);
        remainder.unPad();
        dividend.value.pop_back();

        if (divisor > remainder) {
            quotient.value.push_back(0);
        } else {
            int count = 0;
            int i = MSB;
            bigint value = 0;
            while (i > 0) {
                bigint increase = divisor * i;
                bigint next = value + increase;
                if (next <= remainder) {
                    value = next;
                    count += i;
                }
                i >>= 1;
            }
            quotient.value.push_back(count);
            remainder -= value;
        }
    }

    for (int i = 0; i < quotient.value.size() / 2; i++) {
        int swap = quotient.value.at(i);
        quotient.value.at(i) = quotient.value.at((quotient.value.size() - 1) - i);
        quotient.value.at(quotient.value.size() - 1 - i) = swap;
    }

    if (negative)quotient.invert();
    quotient.unPad();
    return quotient;
}