include/symbolism/N.Division.h

//
// Division algorithm selectors
//

inline void N::exact_div(const N& a, const N& b)
{
    if(is_small(a))
    {
        if(is_small(b))
        {
            exact_div_small_small(a.limb, b.limb);
        }
        else
        {
            throw "Inexact division!";
        }
    }
    else
    {
        if(is_small(b))
        {
            exact_div_large_small(a, b.limb);
        }
        else
        {
            exact_div_large_large(a, b);
        }
    }
}

inline void N::exact_div(const N& a)
{
    if(this_small)
    {
        if(is_small(a))
        {
            exact_div_small_small(a.limb);
        }
        else
        {
            throw "Inexact division!";
        }
    }
    else
    {
        if(is_small(a))
        {
            exact_div_large_small(a.limb);
        }
        else
        {
            exact_div_large_large(a);
        }
    }}

inline void N::div(N& rem, const N& a, const N& b)
{
    if(is_small(a))
    {
        if(is_small(b))
        {
            div_small_small(rem, a.limb, b.limb);
        }
        else
        {
            div_small_large(rem, a.limb, b.limb);
        }
    }
    else
    {
        if(is_small(b))
        {
            div_large_small(rem, a, b.limb);
        }
        else
        {
            div_large_large(rem, a, b);
        }
    }
}

inline void N::div(N& rem, const N& a)
{
    if(this_small)
    {
        if(is_small(a))
        {
            div_small_small(rem, a.limb);
        }
        else
        {
            div_small_large(rem, a);
        }
    }
    else
    {
        if(is_small(a))
        {
            div_large_small(rem, a.limb);
        }
        else
        {
            div_large_large(rem, a);
        }
    }
}

inline void N::quo(const N& a, const N& b)
{
    if(is_small(a))
    {
        if(is_small(b))
        {
            quo_small_small(a.limb, b.limb);
        }
        else
        {
            quo_small_large(a.limb, b.limb);
        }
    }
    else
    {
        if(is_small(b))
        {
            quo_large_small(a, b.limb);
        }
        else
        {
            quo_large_large(a, b);
        }
    }
}

inline void N::quo(const N& a)
{
    if(this_small)
    {
        if(is_small(a))
        {
            quo_small_small(a.limb);
        }
        else
        {
            quo_small_large(a);
        }
    }
    else
    {
        if(is_small(a))
        {
            quo_large_small(a.limb);
        }
        else
        {
            quo_large_large(a);
        }
    }
}

inline void N::rem(const N& a, const N& b)
{
    if(is_small(a))
    {
        if(is_small(b))
        {
            rem_small_small(a.limb, b.limb);
        }
        else
        {
            rem_small_large(a.limb, b.limb);
        }
    }
    else
    {
        if(is_small(b))
        {
            rem_large_small(a, b.limb);
        }
        else
        {
            rem_large_large(a, b);
        }
    }
}

inline void N::rem(const N& a)
{
    if(this_small)
    {
        if(is_small(a))
        {
            rem_small_small(a.limb);
        }
        else
        {
            rem_small_large(a);
        }
    }
    else
    {
        if(is_small(a))
        {
            rem_large_small(a.limb);
        }
        else
        {
            rem_large_large(a);
        }
    }
}

//
// Division operators
//

inline N operator/(const N& a, const N& b)
{
    N r;
    r.quo(a, b);
    return r;
}

inline N& N::operator/=(const N& rhs)
{
    quo(rhs);
    return *this;
}

inline N operator%(const N& a, const N& b)
{
    N r;
    r.rem(a, b);
    return r;
}

inline N& N::operator%=(const N& rhs)
{
    rem(rhs);
    return *this;
}

inline N div(N& rem, const N& a, const N& b)
{
    N quo;
    quo.div(rem, a, b);
    return quo;
}

inline N div_exact(const N& a, const N& b)
{
    N quo;
    quo.exact_div(a, b);
    return quo;
}

inline N quo(const N& a, const N& b)
{
    N quo;
    quo.quo(a, b);
    return quo;
}

inline N rem(const N& a, const N& b)
{
    N rem;
    rem.rem(a, b);
    return rem;
}

//
// Division algorithms
//

inline void N::exact_div_small_small(const limb_t a, const limb_t b)
{
    reserve(0);
    limb = a / b;

    if(fast_false(a % b))
    {
        throw "Inexact division!";
    }
}

inline void N::exact_div_small_small(const limb_t b)
{
    if(fast_false(limb % b))
    {
        throw "Inexact division!";
    }
    
    limb /= b;
}

inline void N::div_small_small(N& rem, const limb_t a, const limb_t b)
{
    set(a / b);
    rem = a % b;
}

inline void N::div_small_small(N& rem, const limb_t b)
{
    limb_t a = limb;
    limb = a / b;
    rem = a % b;
}

inline void N::quo_small_small(const limb_t a, const limb_t b)
{
    set(a / b);
}

inline void N::quo_small_small(const limb_t a)
{
    if(fast_true(a))
    {
        limb /= a;
    }
    else
    {
        throw "Division by zero";
    }
}

inline void N::rem_small_small(const limb_t a, const limb_t b)
{
    if(fast_true(b))
    {
        set(a % b);
    }
    else
    {
        throw "Division by zero";
    }
}

inline void N::rem_small_small(const limb_t a)
{
    if(fast_true(a))
    {
        limb %= a;
    }
    else
    {
        throw "Division by zero";
    }
}

---

Copyright © 2007-2008 Remco Bloemen.

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

Hosted by