include/symbolism/N.Multiplication.h

// Multiplication algorithm selectors
inline void N::mul(const N& a, const N& b)
{
    // If a or b is large limb will contain a nonzero pointer
    if(a.limb  == 0 || b.limb == 0)
    {
        set(0);
    }
    else if(is_small(a))
    {
        if(is_small(b))
        {
            mul_small_small(a.limb, b.limb);
        }
        else
        {
            if(a.limb > 1)
            {
                mul_large_small(b, a.limb);
            }
            else
            {
                set(b);
            }
        }
    }
    else
    {
        if(is_small(b))
        {
            if(b.limb > 1)
            {
                mul_large_small(a, b.limb);
            }
            else
            {
                set(a);
            }
        }
        else
        {
            mul_large_large(a, b);
        }
    }
}

inline void N::mul(const N& a)
{
    // If this or a is large limb will contain a nonzero pointer
    if(limb  == 0 || a.limb == 0)
    {
        set(0);
    }
    if(this_small)
    {
        if(is_small(a))
        {
            mul_small_small(a.limb);
        }
        else
        {
            if(limb > 1)
            {
                mul_small_large(a);
            }
            else
            {
                set(a);
            }
        }
    }
    else
    {
        if(is_small(a))
        {
            if(a.limb > 1)
            {
                mul_large_small(a.limb);
            }
        }
        else
        {
            mul_large_large(a);
        }
    }
}

// Multiplication operators
inline N operator*(const N& a, const N& b)
{
    N r;
    r.mul(a, b);
    return r;
}

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

inline void N::mul_small_small(const limb_t a, const limb_t b)
{
    limb_t lo, hi;
    asm("mulq %3" : "=a"(lo), "=d"(hi) : "a"(a), "rm"(b));
    if(hi == 0)
    {
        reserve(0);
        limb = lo;
    }
    else
    {
        reserve(1);
        data[0] = lo;
        data[1] = hi;
    }
}

inline void N::mul_small_small(const limb_t a)
{
    limb_t lo, hi;
    asm("mulq %3" : "=a"(lo), "=d"(hi) : "a"(a), "rm"(limb));
    limb = lo;
    add_carry_small(hi);
}

---

Copyright © 2007-2008 Remco Bloemen.

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

Hosted by