src/N.Multiplication.cpp

#include <symbolism/N.h>

namespace symbolism {
namespace ring {

// Multiplication algorithms
void N::mul_large_large(const N& a, const N& b)
{
    reserve(a.size + b.size + 1);
    if(a.size == b.size)
    {
        mpn_mul_n(data, a.data, b.data, a.size + 1);
    }
    else if(a.size > b.size)
    {
        mpn_mul(data, a.data, a.size + 1, b.data, b.size + 1);
    }
    else
    {
        mpn_mul(data, b.data, b.size + 1, a.data, a.size + 1);
    }
    normalize();
}

void N::mul_large_large(const N& a)
{
    // Overlap is _not_ permitted, so make copies
    // TODO: Is copy constructor faster? Should look better!
    if(size == a.size)
    {
        size_t newsize = 2 * size + 1;
        void* space = malloc((newsize + 1) * sizeof(limb_t));
        limb_t* newdata = reinterpret_cast<limb_t*>(space);
        mpn_mul_n(newdata, data, a.data, size + 1);
        free(data);
        data = newdata;
        size = newsize;
    }
    else if(size > a.size)
    {
        size_t newsize = size + a.size + 1;
        void* space = malloc((newsize + 1) * sizeof(limb_t));
        limb_t* newdata = reinterpret_cast<limb_t*>(space);
        mpn_mul(newdata, data, size + 1, a.data, a.size + 1);
        free(data);
        data = newdata;
        size = newsize;
    }
    else
    {
        size_t newsize = size + a.size + 1;
        void* space = malloc((newsize + 1) * sizeof(limb_t));
        limb_t* newdata = reinterpret_cast<limb_t*>(space);
        mpn_mul(newdata, a.data, a.size + 1, data, size + 1);
        free(data);
        data = newdata;
        size = newsize;
    }
    normalize();
}

void N::mul_large_small(const N& a, const limb_t b)
{
    if(fast_true(b))
    {
        reserve(a.size);
        limb_t carry;
        carry = mpn_mul_1(data, a.data, a.size + 1, b);
        add_carry_large(carry);
    }
    else
    {
        set(0);
    }
}

void N::mul_large_small(const limb_t a)
{
    if(fast_true(a))
    {
        limb_t carry;
        carry = mpn_mul_1(data, data, size + 1, a);
        add_carry_large(carry);
    }
    else
    {
        set(0);
    }
}

void N::mul_small_large(const N& a)
{
    if(fast_true(limb))
    {
        limb_t value = limb;
        reserve(a.size);
        limb_t carry;
        carry = mpn_mul_1(data, a.data, size + 1, value);
        add_carry_large(carry);
    }
    else
    {
        set(0);
    }
}

}}

---

Copyright © 2007-2008 Remco Bloemen.

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

Hosted by