DivReg.h

Go to the documentation of this file.

// DivReg.h:
// -------------------
//

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_DIVREG_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_DIVREG_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/InstructionSet/RegType.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/DivReg.h>
#include <IPSDKUtil/InstructionSet/detail/CastReg.h>
#include <IPSDKUtil/Tools/ForceInline.h>

#include <boost/mpl/and.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/not_equal_to.hpp>
#include <boost/mpl/sizeof.hpp>

namespace ipsdk {
namespace simd {
namespace detail {


template <eInstructionSet::domain IS, typename T>
struct DivReg<
    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_Standard>
            >::type,
            typename boost::mpl::and_<
                typename boost::is_integral<T>::type,
                typename boost::mpl::equal_to<
                    boost::mpl::sizeof_<T>,
                    boost::mpl::int_<1>
                >::type
            >::type
        >::type
    >::type
>
{
    static IPSDK_FORCEINLINE
    typename RegType<IS, T>::Type
    act(const typename RegType<IS, T>::Type& in1,
        const typename RegType<IS, T>::Type& in2)
    {
        typename RegType<IS, T>::Type out;
        act(in1, in2, out);
        return out;
    }

    static IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, T>::Type& in1,
        const typename RegType<IS, T>::Type& in2,
        typename RegType<IS, T>::Type& out)
    {
        typename RegType<IS, ipInt16>::Type in1I16_1, in1I16_2;
        typename RegType<IS, ipInt16>::Type in2I16_1, in2I16_2;
        typename RegType<IS, ipReal32>::Type in1f1, in1f2, in1f3, in1f4;
        typename RegType<IS, ipReal32>::Type in2f1, in2f2, in2f3, in2f4;
        typename RegType<IS, ipReal32>::Type outf1, outf2, outf3, outf4;

        CastReg<IS, T, ipInt16>::act(in1, in1I16_1, in1I16_2);
        CastReg<IS, T, ipInt16>::act(in2, in2I16_1, in2I16_2);
        CastReg<IS, ipInt16, ipReal32>::act(in1I16_1, in1f1, in1f2);
        CastReg<IS, ipInt16, ipReal32>::act(in1I16_2, in1f3, in1f4);
        CastReg<IS, ipInt16, ipReal32>::act(in2I16_1, in2f1, in2f2);
        CastReg<IS, ipInt16, ipReal32>::act(in2I16_2, in2f3, in2f4);

        DivReg<IS, ipReal32>::act(in1f1, in2f1, outf1);
        DivReg<IS, ipReal32>::act(in1f2, in2f2, outf2);
        DivReg<IS, ipReal32>::act(in1f3, in2f3, outf3);
        DivReg<IS, ipReal32>::act(in1f4, in2f4, outf4);

        CastReg<IS, ipReal32, ipInt16>::act(outf1, outf2, in1I16_1);
        CastReg<IS, ipReal32, ipInt16>::act(outf3, outf4, in1I16_2);
        CastReg<IS, ipInt16, T>::act(in1I16_1, in1I16_2, out);
    }
};

template <eInstructionSet::domain IS, typename T>
struct DivReg<
    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_Standard>
            >::type,
            typename boost::mpl::and_<
                typename boost::is_integral<T>::type,
                typename boost::mpl::equal_to<
                    boost::mpl::sizeof_<T>,
                    boost::mpl::int_<2>
                >::type
            >::type
        >::type
    >::type
>
{
    static IPSDK_FORCEINLINE
    typename RegType<IS, T>::Type
    act(const typename RegType<IS, T>::Type& in1,
        const typename RegType<IS, T>::Type& in2)
    {
        typename RegType<IS, T>::Type out;
        act(in1, in2, out);
        return out;
    }

    static IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, T>::Type& in1,
        const typename RegType<IS, T>::Type& in2,
        typename RegType<IS, T>::Type& out)
    {
        typename RegType<IS, ipReal32>::Type in1f1, in1f2, in2f1, in2f2, outf1, outf2;
        CastReg<IS, T, ipReal32>::act(in1, in1f1, in1f2);
        CastReg<IS, T, ipReal32>::act(in2, in2f1, in2f2);
        DivReg<IS, ipReal32>::act(in1f1, in2f1, outf1);
        DivReg<IS, ipReal32>::act(in1f2, in2f2, outf2);
        CastReg<IS, ipReal32, T>::act(outf1, outf2, out);
    }
};

template <eInstructionSet::domain IS, typename T>
struct DivReg<
    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_Standard>
            >::type,
            typename boost::mpl::and_<
                typename boost::is_integral<T>::type,
                typename boost::mpl::equal_to<
                    boost::mpl::sizeof_<T>,
                    boost::mpl::int_<4>
                >::type
            >::type
        >::type
    >::type
>
{
    static IPSDK_FORCEINLINE
    typename RegType<IS, T>::Type
    act(const typename RegType<IS, T>::Type& in1,
        const typename RegType<IS, T>::Type& in2)
    {
        typename RegType<IS, T>::Type out;
        act(in1, in2, out);
        return out;
    }

    static IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, T>::Type& in1,
        const typename RegType<IS, T>::Type& in2,
        typename RegType<IS, T>::Type& out)
    {
        typename RegType<IS, ipReal32>::Type in1f, in2f, outf;
        CastReg<IS, T, ipReal32>::act(in1, in1f);
        CastReg<IS, T, ipReal32>::act(in2, in2f);
        DivReg<IS, ipReal32>::act(in1f, in2f, outf);
        CastReg<IS, ipReal32, T>::act(outf, out);
    }
};


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

#endif // __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_DIVREG_H__