RoundToEvenReg.h

// RoundToEvenReg.h:
// -------------------
//

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_ROUNDTOEVENREG_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_ROUNDTOEVENREG_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/InstructionSet/RegType.h>
#include <IPSDKUtil/InstructionSet/detail/AssignReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/AddReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/RoundToEvenReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/SubReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseAndReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseOrReg.h>
#include <IPSDKUtil/Tools/ForceInline.h>

namespace ipsdk {
namespace simd {
namespace detail {


template <eInstructionSet::domain IS>
struct RoundToEvenReg<IS, ipReal32>
{
    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)
    {
        typedef typename RegType<IS, ipReal32>::Type Reg;
        /*Reg absIn;
        AbsReg<IS, ipReal32>::act(in, absIn);
        Reg twoExp23;
        AssignReg<IS, ipReal32>::act(twoExp23, static_cast<ipReal32>(1 << 23));
        Reg addRes, subRes;
        AddReg<IS, ipReal32>::act(absIn, twoExp23, addRes);
        SubReg<IS, ipReal32>::act(addRes, twoExp23, subRes);
        Reg absInLTExp23;
        IsLessReg<IS, ipReal32>::act(subRes, twoExp23, absInLTExp23);
        Reg absInRounded;
        BitwiseSelectReg<IS, ipReal32>::act(absInLTExp23, subRes, absIn, absInRounded);
        Reg inNeg;
        IsNotEqualReg<IS, ipReal32>::act(in, absIn, inNeg);
        Reg minusAbsInRounded;
        UnaryMinusReg<IS, ipReal32>::act(absInRounded, minusAbsInRounded);
        BitwiseSelectReg<IS, ipReal32>::act(inNeg, minusAbsInRounded, absInRounded, out);*/

        Reg signMask, magic;
        AssignReg<IS, ipReal32>::act(signMask, -.0f);
        AssignReg<IS, ipReal32>::act(magic, static_cast<ipReal32>(1 << 23));
        Reg sign;
        BitwiseAndReg<IS, ipReal32>::act(in, signMask, sign);
        Reg signedMagic;
        BitwiseOrReg<IS, ipReal32>::act(magic, sign, signedMagic);
        Reg inPlusSignedMagic;
        AddReg<IS, ipReal32>::act(in, signedMagic, inPlusSignedMagic);
        SubReg<IS, ipReal32>::act(inPlusSignedMagic, signedMagic, out);
    }
};

template <eInstructionSet::domain IS>
struct RoundToEvenReg<IS, ipReal64>
{
    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)
    {
        typedef typename RegType<IS, ipReal64>::Type Reg;

        Reg signMask, magic;
        AssignReg<IS, ipReal64>::act(signMask, -.0f);
        AssignReg<IS, ipReal64>::act(magic, static_cast<ipReal64>(static_cast<ipUInt64>(1) << static_cast<ipUInt64>(52)));
        Reg sign;
        BitwiseAndReg<IS, ipReal64>::act(in, signMask, sign);
        Reg signedMagic;
        BitwiseOrReg<IS, ipReal64>::act(magic, sign, signedMagic);
        Reg inPlusSignedMagic;
        AddReg<IS, ipReal64>::act(in, signedMagic, inPlusSignedMagic);
        SubReg<IS, ipReal64>::act(inPlusSignedMagic, signedMagic, out);
    }
};


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

#endif // __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_ROUNDTOEVENREG_H__