SignedUnsignedOpReg.h

Go to the documentation of this file.

// SignedUnsignedOpReg.h:
// -------------------
//

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_STD_SIGNEDUNSIGNEDOPREG_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_STD_SIGNEDUNSIGNEDOPREG_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/SignedUnsignedOpReg.h>
#include <IPSDKUtil/Tools/ForceInline.h>

#include <boost/type_traits/make_unsigned.hpp>

namespace ipsdk {
namespace simd {
namespace detail {


/*
 * Copied from boost_1_53_0/include/boost/random/detail/signed_unsigned_tools.hpp
 * Compute x - y, we know that x >= y, return an unsigned value.
 */

template<typename T>
struct SignedUnsignedSubtractReg<eInstructionSet::eIS_Standard,
                                 T, /* signed */ false>
{
    typedef T result_type;

    static IPSDK_FORCEINLINE result_type act(T x, T y)
    {
        return x - y;
    }

    static IPSDK_FORCEINLINE result_type act(T x, T y, result_type& out)
    {
        out = x - y;
    }
};

template<typename T>
struct SignedUnsignedSubtractReg<eInstructionSet::eIS_Standard,
                                 T, /* signed */ true>
{
    typedef typename boost::make_unsigned<T>::type result_type;

    static IPSDK_FORCEINLINE result_type act(T x, T y)
    {
        if (y >= 0)   // because x >= y, it follows that x >= 0, too
            return result_type(x) - result_type(y);
        if (x >= 0)   // y < 0
            // avoid the nasty two's complement case for y == min()
            return result_type(x) + result_type(-(y+1)) + 1;
        // both x and y are negative: no signed overflow
        return result_type(x - y);
    }

    static IPSDK_FORCEINLINE void act(T x, T y, result_type& out)
    {
        if (y >= 0)   // because x >= y, it follows that x >= 0, too
            out =result_type(x) - result_type(y);
        else if (x >= 0)   // y < 0
            // avoid the nasty two's complement case for y == min()
            out = result_type(x) + result_type(-(y+1)) + 1;
        else
        // both x and y are negative: no signed overflow
            out = result_type(x - y);
    }
};

/*
 * Copied from boost_1_53_0/include/boost/random/detail/signed_unsigned_tools.hpp
 * Compute x + y, x is unsigned, result fits in type of "y".
 */

template<typename T1, typename T2>
struct SignedUnsignedAddReg<eInstructionSet::eIS_Standard, 
                            T1, T2, /* signed */ false>
{
    typedef T2 result_type;
    static IPSDK_FORCEINLINE result_type act(T1 x, T2 y)
    {
        return T2(x) + y;
    }

    static IPSDK_FORCEINLINE void act(T1 x, T2 y, result_type& out)
    {
        out = T2(x) + y;
    }
};

template<typename T1, typename T2>
struct SignedUnsignedAddReg<eInstructionSet::eIS_Standard,
                            T1, T2, /* signed */ true>
{
    typedef T2 result_type;
    static IPSDK_FORCEINLINE result_type act(T1 x, T2 y)
    {
        if (y >= 0)
            return T2(x) + y;
        // y < 0
        if (x > T1(-(y+1)))  // result >= 0 after subtraction
            // avoid the nasty two's complement edge case for y == min()
            return T2(x - T1(-(y+1)) - 1);
        // abs(x) < abs(y), thus T2 able to represent x
        return T2(x) + y;
    }

    static IPSDK_FORCEINLINE void act(T1 x, T2 y, result_type& out)
    {
        if (y >= 0)
            out = T2(x) + y;
        // y < 0
        else if (x > T1(-(y+1)))  // result >= 0 after subtraction
            // avoid the nasty two's complement edge case for y == min()
            out = T2(x - T1(-(y+1)) - 1);
        else
            // abs(x) < abs(y), thus T2 able to represent x
            out = T2(x) + y;
    }
};


} // end of namespace detail
} // end of namespace simd
} // end of namespace ipsdk

#endif // __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_STD_ADDREG_H__