src/N.Division.cpp

#include <symbolism/N.h>

namespace symbolism {
namespace ring {

void N::exact_div_large_large(const N& a, const N& b)
{
    if(fast_false(a.size >= b.size))
    {
        throw "Inexact division!";
    }
    
    // Reserver space for the quotient
    reserve(a.size - b.size);

    // Allocate space for the remainder
    void* rem_space = malloc((b.size + 1) * sizeof(limb_t));
    limb_t* rem = reinterpret_cast<limb_t*>(rem_space);
    
    mpn_tdiv_qr(data, rem, 0, a.data, a.size + 1, b.data, b.size + 1);

    // Check the exactness
    for(size_t i=0; i <= b.size; i++)
    {
        if(rem[i])
        {
            throw "Inexact division!";
        }
    }

    free(rem);
}

void N::exact_div_large_large(const N& b)
{
    /*
    if(fast_false(size >= b.size))
    {
    throw "Inexact division!";
}

    void* rem_space = malloc((b.size + 1) * sizeof(limb_t));
    limb_t* rem = reinterpret_cast<limb_t*>(rem_space);

    void* quo_space = malloc((a.size - b.size + 1) * sizeof(limb_t));
    limb_t* quo = reinterpret_cast<limb_t*>(rem_space);

    mpn_tqdiv_qr(quo, rem, 0, data, size + 1, b.data, b.size + 1);
    free(data);

    // Check the exactness
    for(size_t i=0; i <= b.size; i++)
    {
    if(rem[i]])
    {
    throw "Inexact division!";
}
}
    free(rem);
    
    size = a.size - b.size;
    data = quo;
    */
}

void N::exact_div_large_small(const N& a, const limb_t b)
{
    reserve(a.size);
    limb_t remainder;
    remainder = mpn_divrem_1(data, 0, a.data, a.size + 1, b);
    
    if(fast_false(remainder))
    {
        throw "Inexact division!";
    }
}

void N::exact_div_large_small(const limb_t b)
{
    limb_t remainder;
    remainder = mpn_divrem_1(data, 0, data, size + 1, b);
    
    if(fast_false(remainder))
    {
        throw "Inexact division!";
    }
}

void N::div_large_large(N& rem, const N& a, const N& b)
{
    if(a.size < b.size)
    {
        rem = a;
        set(0);
    }
    else
    {
        reserve(a.size - b.size);
        rem.reserve(b.size);
        mpn_tdiv_qr(data, rem.data, 0, a.data, a.size + 1, b.data, b.size + 1);
        normalize();
        rem.normalize();
    }
}

void N::div_large_small(N& rem, const N& a, const limb_t b)
{
    reserve(a.size);
    rem = mpn_divrem_1(data, 0, a.data, a.size + 1, b);
    normalize();
}

void N::div_small_large(N& rem, const limb_t a, const N& b)
{
    swap(*this, rem);
    set(0);
}

void N::div_large_large(N& rem, const N& a)
{
    if(size < a.size)
    {
        swap(*this, rem);
        set(0);
    }
    else
    {
        N quo;
        quo.div_large_large(rem, *this, a);
        swap(*this, quo);
    }
}

void N::div_large_small(N& rem, const limb_t a)
{
    rem = mpn_divrem_1(data, 0, data, size + 1, a);
    normalize();
}

void N::div_small_large(N& rem, const N& a)
{
    swap(*this, rem);
    set(0);
}

void N::quo_large_large(const N& a, const N& b)
{
    if(a.size < b.size)
    {
        set(0);
    }
    else
    {
        reserve(a.size - b.size);
        N rem;
        rem.reserve(b.size);
        mpn_tdiv_qr(data, rem.data, 0, a.data, a.size + 1, b.data, b.size + 1);
        normalize();
    }
}

void N::quo_large_small(const N& a, const limb_t b)
{
    reserve(a.size);
    mpn_divrem_1(data, 0, a.data, a.size + 1, b);
    normalize();
}

void N::quo_small_large(const limb_t a, const N& b)
{
    set(0);
}

void N::quo_large_large(const N& a)
{
    if(size < a.size)
    {
        set(0);
    }
    else
    {
        N quo;
        quo.div_large_large(*this, a);
        swap(*this, quo);
    }
}

void N::quo_large_small(const limb_t a)
{
    mpn_divrem_1(data, 0, data, size + 1, a);
    normalize();
}

void N::quo_small_large(const N& a)
{
    set(0);
}

void N::rem_large_large(const N& a, const N& b)
{
    if(a.size < b.size)
    {
        set(a);
    }
    else
    {
        N quo;
        quo.reserve(a.size - b.size);
        reserve(b.size);
        mpn_tdiv_qr(quo.limbs(), data, 0, a.data, a.size + 1, b.data, b.size + 1);
        normalize();
    }
}

void N::rem_large_small(const N& a, const limb_t b)
{
    set(mpn_mod_1(a.data, a.size + 1, b));
}

void N::rem_small_large(const limb_t a, const N& b)
{
    set(a);
}

void N::rem_large_large(const N& a)
{
    if(size >= a.size)
    {
        N quo, rem;
        quo.div_large_large(rem, *this, a);
        swap(*this, rem);
    }
}

void N::rem_large_small(const limb_t a)
{
    set(mpn_divrem_1(data, 0, data, size + 1, a));
}

void N::rem_small_large(const N& a)
{
}


}}

---

Copyright © 2007-2008 Remco Bloemen.

Generated on Tue Jan 22 17:35:31 2008 for symbolism by doxygen 1.5.4

Hosted by