AbsReg.h

// AbsReg.h:
// -----------------
//

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_ABSREG_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_ABSREG_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/InstructionSet/RegType.h>
#include <IPSDKUtil/InstructionSet/detail/AssignReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/MaxReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/UnaryMinusReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseNotReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseAndReg.h>

#include <boost/mpl/not_equal_to.hpp>
#include <boost/type_traits/is_float.hpp>

namespace ipsdk {
namespace simd {
namespace detail {


template <eInstructionSet::domain IS,
          typename T, typename Enable=void>
struct AbsReg;

template <eInstructionSet::domain IS, typename T>
struct AbsReg<
    IS,
    T,
    typename boost::enable_if<
        typename boost::mpl::and_<
            typename boost::is_integral<T>::type,
            typename boost::mpl::not_<boost::is_signed<T> >::type
        >::type
    >::type
>
{
    static
    IPSDK_FORCEINLINE
    typename RegType<IS, T>::Type
    act(const typename RegType<IS, T>::Type& in)
    {
        return in;
    }
    
    static
    IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, T>::Type& in, typename RegType<IS, T>::Type& out)
    {
        out = in;
    }
};

template <eInstructionSet::domain IS, typename T>
struct AbsReg<
    IS,
    T,
    typename boost::enable_if<
        typename boost::mpl::and_<
            typename boost::mpl::not_equal_to<
                boost::mpl::int_<IS>,
                boost::mpl::int_<eInstructionSet::eIS_Avx512>
            >::type,
            typename boost::mpl::and_<
                typename boost::is_integral<T>::type,
                typename boost::is_signed<T>::type
            >::type
        >::type
    >::type
>
{
    static
    IPSDK_FORCEINLINE
    typename RegType<IS, T>::Type
    act(const typename RegType<IS, T>::Type& in)
    {
        typename RegType<IS, T>::Type out;
        act(in, out);
        return out;
    }

    static
    IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, T>::Type& in, typename RegType<IS, T>::Type& out)
    {
        typename RegType<IS, T>::Type minusIn;
        UnaryMinusReg<IS, T>::act(in, minusIn);
        MaxReg<IS, T>::act(in, minusIn, out);
    }
};

template <eInstructionSet::domain IS>
struct AbsReg<
    IS,
    ipReal32,
    typename boost::enable_if<
        typename boost::mpl::not_equal_to<
            boost::mpl::int_<IS>,
            boost::mpl::int_<eInstructionSet::eIS_Avx512>
        >::type
    >::type
>

{
    static
    IPSDK_FORCEINLINE
    typename RegType<IS, ipReal32>::Type
    act(const typename RegType<IS, ipReal32>::Type& in)
    {
        typename RegType<IS, ipReal32>::Type out;
        act(in, out);
        return out;
    }
    
    static
    IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, ipReal32>::Type& in, typename RegType<IS, ipReal32>::Type& out)
    {
        typename RegType<IS, ipReal32>::Type mzero, notmzero;
        AssignReg<IS, ipReal32>::act(mzero, -.0f);
        BitwiseNotReg<IS, ipReal32>::act(mzero, notmzero);
        BitwiseAndReg<IS, ipReal32>::act(in, notmzero, out);
    }
};

template <eInstructionSet::domain IS>
struct AbsReg<
    IS,
    ipReal64,
    typename boost::enable_if<
        typename boost::mpl::not_equal_to<
            boost::mpl::int_<IS>,
            boost::mpl::int_<eInstructionSet::eIS_Avx512>
        >::type
    >::type
>
{
    static
    IPSDK_FORCEINLINE
    typename RegType<IS, ipReal64>::Type
    act(const typename RegType<IS, ipReal64>::Type& in)
    {
        typename RegType<IS, ipReal64>::Type out;
        act(in, out);
        return out;
    }

    static
    IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, ipReal64>::Type& in, typename RegType<IS, ipReal64>::Type& out)
    {
        typename RegType<IS, ipReal64>::Type mzero, notmzero;
        AssignReg<IS, ipReal64>::act(mzero, -.0);
        BitwiseNotReg<IS, ipReal64>::act(mzero, notmzero);
        BitwiseAndReg<IS, ipReal64>::act(in, notmzero, out);
    }
};


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

#ifdef IPSDK_WITH_AVX512
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/AVX512/AbsReg.h>
#endif

#endif // __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_ABSREG_H__