Atan2Pack.h

Go to the documentation of this file.

// Atan2Pack.h:
// -----------------
//

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_ATAN2PACK_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_ATAN2PACK_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/InstructionSet/InstructionSetTypes.h>
#include <IPSDKUtil/InstructionSet/IS2Pack.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/Atan2Reg.h>
#include <IPSDKUtil/InstructionSet/detail/BinaryPackOp.h>
#include <IPSDKUtil/Tools/ForceInline.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/atan.h>
#include <IPSDKUtil/Tools/NumericLimits.h>
#include <boost/type_traits/is_float.hpp>

namespace ipsdk {
namespace simd {
namespace detail {


template <eInstructionSet::domain instructionSet, typename T,
          typename Enable=void>
struct Atan2Pack;


// implementation for standard instruction set and floating points type
template <typename T>
struct Atan2Pack<eInstructionSet::eIS_Standard, T,
                 typename boost::enable_if<boost::is_float<T> >::type>
{
    static
    IPSDK_FORCEINLINE
    typename IS2Pack<eInstructionSet::eIS_Standard, T>::Type
    act(const typename IS2Pack<eInstructionSet::eIS_Standard, T>::Type& y,
        const typename IS2Pack<eInstructionSet::eIS_Standard, T>::Type& x)
    {
        return BinaryPackOp<eInstructionSet::eIS_Standard, T,
            Atan2Reg<eInstructionSet::eIS_Standard, T> >::act(y, x);
    }

    static
    IPSDK_FORCEINLINE
    void
    act(const typename IS2Pack<eInstructionSet::eIS_Standard, T>::Type& y,
        const typename IS2Pack<eInstructionSet::eIS_Standard, T>::Type& x,
        typename IS2Pack<eInstructionSet::eIS_Standard, T>::Type& out)
    {
        BinaryPackOp<eInstructionSet::eIS_Standard, T,
            Atan2Reg<eInstructionSet::eIS_Standard, T> >::act(y, x, out);
    }
};

// implementation for floating points type
template <eInstructionSet::domain IS, typename T>
struct Atan2Pack<IS, T,
                 typename boost::enable_if<boost::is_float<T> >::type>
{
    static
    IPSDK_FORCEINLINE
    const typename IS2Pack<IS, T>::Type
    act(const typename IS2Pack<IS, T>::Type& yPack,
        const typename IS2Pack<IS, T>::Type& xPack)
    {
        typename IS2Pack<IS, T>::Type outPack;
        act(yPack, xPack, outPack);

        return outPack;
    }

    static
    IPSDK_FORCEINLINE
    void
    act(const typename IS2Pack<IS, T>::Type& yPack,
        const typename IS2Pack<IS, T>::Type& xPack,
        typename IS2Pack<IS, T>::Type& outPack)
    {
        // define used constants
        typedef typename IS2Pack<IS, T>::Type PackT;
        typedef typename IS2MaskPack<IS, T>::Type MaskPackT;
        const T epsilon = NumericLimits<T>::sqrt_epsilon();
        PackT cste0Pack, csteEpsilonPack, cste1Pack, cstePiPack, csteMPiPack, cstePiD2Pack, csteMPiD2Pack;
        simd::assign<IS>(cste0Pack, 0);
        simd::assign<IS>(csteEpsilonPack, epsilon);
        simd::assign<IS>(cste1Pack, 1);
        simd::assign<IS>(cstePiPack, static_cast<T>(M_PI));
        simd::assign<IS>(csteMPiPack, -static_cast<T>(M_PI));
        simd::assign<IS>(cstePiD2Pack, static_cast<T>(M_PI_2));
        simd::assign<IS>(csteMPiD2Pack, -static_cast<T>(M_PI_2));
    
        // compute absolute value for x and y
        PackT absXPack, absYPack;
        simd::abs<IS>(xPack, absXPack);
        simd::abs<IS>(yPack, absYPack);

        // test for data range
        MaskPackT testAbsXEpsilonPack, testAbsYEpsilonPack, testX0Pack, testY0Pack;
        simd::isGreater<IS>(absXPack, csteEpsilonPack, testAbsXEpsilonPack);
        simd::isGreater<IS>(absYPack, csteEpsilonPack, testAbsYEpsilonPack);
        simd::isGreater<IS>(xPack, cste0Pack, testX0Pack);
        simd::isGreater<IS>(yPack, cste0Pack, testY0Pack);

        // compute atan value associated to y / x
        PackT usedValuePack, resValuePack;
        simd::ifElse<IS>(testAbsXEpsilonPack, xPack, cste1Pack, usedValuePack);
        simd::div<IS>(yPack, usedValuePack, usedValuePack);
        resValuePack = simd::atan<IS>(usedValuePack);

        // modify computed value in function of y and x sign
        PackT wPack;
        simd::ifElse<IS>(testY0Pack, cstePiPack, csteMPiPack, wPack);
        simd::ifElse<IS>(testX0Pack, cste0Pack, wPack, wPack);
        simd::add<IS>(resValuePack, wPack, resValuePack);

        // handle case where x < epsilon
        PackT ePack;
        simd::ifElse<IS>(testY0Pack, cstePiD2Pack, csteMPiD2Pack, ePack);
        simd::ifElse<IS>(testAbsYEpsilonPack, ePack, cste0Pack, ePack);
        simd::ifElse<IS>(testAbsXEpsilonPack, resValuePack, ePack, outPack);
    }
};



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

#endif // __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_ATAN2PACK_H__