include/symbolism/N.Binary.h

inline size_t N::two_multiplicity() const
{
    if(this_small)
    {
        return two_multiplicity_small();
    }
    else
    {
        return two_multiplicity_large();
    }
}

inline void N::binary_not(const N& a)
{
    if(this_small)
    {
        reserve(0);
        limb = ~a.limb;
    }
    else
    {
        reserve(a.size);
        for(size_t i=0; i <= size; i++)
        {
            data[i] = ~a.data[i];
        }
    }
}

inline void N::binary_not()
{
    if(this_small)
    {
        limb = ~limb;
    }
    else
    {
        for(size_t i=0; i <= size; i++)
        {
            data[i] = ~data[i];
        }
    }
}

inline void N::binary_and(const N& a, const N& b)
{
    assert(a.size == b.size);
    if(is_small(a))
    {
        reserve(0);
        limb = a.limb & b.limb;
    }
    else
    {
        reserve(a.size);
        for(size_t i=0; i <= size; i++)
        {
            data[i] = a.data[i] & b.data[i];
        }
    }
}

inline void N::binary_and(const N& a)
{
    assert(size == a.size);
    if(this_small)
    {
        limb &= a.limb;
    }
    else
    {
        for(size_t i=0; i <= size; i++)
        {
            data[i] &= a.data[i];
        }
    }
}

inline void N::binary_or(const N& a, const N& b)
{
    assert(a.size == b.size);
    reserve(a.size);
    if(a.size)
    {
        for(size_t i=0; i <= size; i++)
        {
            data[i] = a.data[i] | b.data[i];
        }
    }
    else
    {
        limb = a.limb | b.limb;
    }
}

inline void N::binary_or(const N& a)
{
    assert(size == a.size);
    if(size)
    {
        for(size_t i=0; i <= size; i++)
        {
            data[i] |= a.data[i];
        }
    }
    else
    {
        limb |= a.limb;
    }
}

inline void N::binary_xor(const N& a, const N& b)
{
    assert(a.size == b.size);
    reserve(a.size);
    if(a.size)
    {
        for(size_t i=0; i <= size; i++)
        {
            data[i] = a.data[i] ^ b.data[i];
        }
    }
    else
    {
        limb = a.limb ^ b.limb;
    }
}

inline void N::binary_xor(const N& a)
{
    assert(size == a.size);
    if(size)
    {
        for(size_t i=0; i <= size; i++)
        {
            data[i] ^= a.data[i];
        }
    }
    else
    {
        limb ^= a.limb;
    }
}

inline void N::left_shift(const N& a, unsigned int count)
{
    if(fast_true(count))
    {
        if(a.size)
        {
            left_shift_large(a, count);
        }
        else
        {
            left_shift_small(a.limb, count);
        }
    }
}

inline void N::left_shift(unsigned int count)
{
    if(fast_true(count))
    {
        if(this_small)
        {
            left_shift_small(count);
        }
        else
        {
            left_shift_large(count);
        }
    }
}

inline void N::right_shift(const N& a, unsigned int count)
{
    if(fast_true(count))
    {
        if(a.size)
        {
            right_shift_large(a, count);
        }
        else
        {
            right_shift_small(a.limb, count);
        }
    }
}

inline void N::right_shift(unsigned int count)
{
    if(fast_true(count))
    {
        if(size)
        {
            right_shift_large(count);
        }
        else
        {
            right_shift_small(count);
        }
    }
}




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

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

inline N operator<<(const N& a, unsigned int count)
{
    N r;
    r.left_shift(a, count);
    return r;
}

inline N operator>>(const N& a, unsigned int count)
{
    N r;
    r.right_shift(a, count);
    return r;
}

inline N& N::operator<<=(const limb_t count)
{
    left_shift(count);
    return *this;
}

inline N& N::operator>>=(const limb_t count)
{
    right_shift(count);
    return *this;
}

inline N& N::operator&=(const N& a)
{
    binary_and(a);
    return *this;
}

inline N& N::operator|=(const N& a)
{
    binary_or(a);
    return *this;
}


inline size_t N::two_multiplicity_large() const
{
    size_t i;
    for(i=0; !data[i]; i++);
    return i * 64 + __builtin_ctzll(data[i]);
}

inline size_t N::two_multiplicity_small() const
{
    return __builtin_ctzll(limb);
}

inline void N::left_shift_small(const limb_t a, unsigned int count)
{
    size_t climbs = count / bits_per_limb;
    unsigned int cbits = count % bits_per_limb;

    limb_t lo = a << cbits;
    limb_t hi = a >> (bits_per_limb - cbits);

    if(climbs)
    {
        if(hi)
        {
            reserve(climbs + 1);
            for(size_t i=0; i < climbs; i++)
            {
                data[i] = 0;
            }
            data[climbs] = lo;
            data[size] = hi;
        }
        else
        {
            reserve(climbs);
            for(size_t i=0; i < climbs; i++)
            {
                data[i] = 0;
            }
            data[climbs] = lo;
        }
    }
    else
    {
        if(hi)
        {
            reserve(1);
            data[climbs] = lo;
            data[size] = hi;
        }
        else
        {
            reserve(0);
            limb = lo;
        }
    }
}

inline void N::left_shift_small(unsigned int count)
{
    size_t climbs = count / bits_per_limb;
    unsigned int cbits = count % bits_per_limb;

    limb_t lo = limb << cbits;
    limb_t hi = (cbits) ? limb >> (bits_per_limb - cbits) : 0;

    if(climbs)
    {
        if(hi)
        {
            reserve(climbs + 1);
            for(size_t i=0; i < climbs; i++)
            {
                data[i] = 0;
            }
            data[climbs] = lo;
            data[size] = hi;
        }
        else
        {
            reserve(climbs);
            for(size_t i=0; i < climbs; i++)
            {
                data[i] = 0;
            }
            data[climbs] = lo;
        }
    }
    else
    {
        if(hi)
        {
            reserve(1);
            data[climbs] = lo;
            data[size] = hi;
        }
        else
        {
            reserve(0);
            limb = lo;
        }
    }
}

inline void N::right_shift_small(const limb_t a, unsigned int count)
{
    reserve(0);
    limb = a >> count;
}

inline void N::right_shift_small(unsigned int count)
{
    limb = limb >> count;
}

---

Copyright © 2007-2008 Remco Bloemen.

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

Hosted by