SinReg.h

Go to the documentation of this file.

// SinReg.h:
// -------------------
//

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_SINREG_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_SINREG_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/InstructionSet/RegType.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/AbsReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/AddReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/MulReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/SubReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/PolynomReg.h>
#include <IPSDKUtil/InstructionSet/Comparison/detail/IsEqualReg.h>
#include <IPSDKUtil/InstructionSet/detail/AssignReg.h>
#include <IPSDKUtil/InstructionSet/detail/BitwiseCastReg.h>
#include <IPSDKUtil/InstructionSet/detail/CastReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseAndNotReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseAndReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseXOrReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/ShiftLeftReg.h>
#include <IPSDKUtil/Tools/ForceInline.h>

namespace ipsdk {
namespace simd {
namespace detail {


template <eInstructionSet::domain IS, eInstructionSet::domain ISFma>
struct SinReg<IS, ISFma, 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 RegReal32;
        typedef typename RegType<IS, ipInt32>::Type RegInt32;

        RegReal32 x = in;
        RegReal32 xmm1, xmm2, xmm3, sign_bit;
        AssignReg<IS, ipReal32>::act(xmm2, 0.0f);
        RegInt32 emm0, emm2;
        sign_bit = x;
        /* take the absolute value */
        AbsReg<IS, ipReal32>::act(x, x);
        /* extract the sign bit (upper one) */
        RegInt32 signMaskInt32;
        AssignReg<IS, ipInt32>::act(signMaskInt32, 0x80000000);
        RegReal32 signMask;
        BitwiseCastReg<IS, ipInt32, ipReal32>::act(signMaskInt32, signMask);
        BitwiseAndReg<IS, ipReal32>::act(sign_bit, signMask, sign_bit);
      
        /* scale by 4/Pi */
        RegReal32 cephesFOPI;
        AssignReg<IS, ipReal32>::act(cephesFOPI, 1.27323954473516f); // 4 / M_PI
        MulReg<IS, ipReal32>::act(x, cephesFOPI, out);

        /* store the integer part of out in mm0 */
        CastReg<IS, ipReal32, ipInt32>::act(out, emm2);
        /* j=(j+1) & (~1) (see the cephes sources) */
        RegInt32 zero, one, invOne, two;
        AssignReg<IS, ipInt32>::act(zero, 0);
        AssignReg<IS, ipInt32>::act(one, 1);
        AssignReg<IS, ipInt32>::act(invOne, ~1);
        AssignReg<IS, ipInt32>::act(two, 2);
        AddReg<IS, ipInt32>::act(emm2, one, emm2);
        BitwiseAndReg<IS, ipInt32>::act(emm2, invOne, emm2);
        CastReg<IS, ipInt32, ipReal32>::act(emm2, out);

        /* get the swap sign flag */
        RegInt32 four;
        AssignReg<IS, ipInt32>::act(four, 4);
        BitwiseAndReg<IS, ipInt32>::act(emm2, four, emm0);
        ShiftLeftReg<IS, ipInt32>::act(emm0, 29, emm0);
        /* get the polynom selection mask 
           there is one polynom for 0 <= x <= Pi/4
           and another one for Pi/4<x<=Pi/2

           Both branches will be computed.
        */
        BitwiseAndReg<IS, ipInt32>::act(emm2, two, emm2);
        typename RegMaskType<IS, ipInt32>::Type emm2Mask;
        IsEqualReg<IS, ipInt32>::act(emm2, zero, emm2Mask);
        CastReg<IS, ipInt32, ipInt32>::act(emm2Mask, emm2);

        RegReal32 swap_sign_bit, poly_mask;
        BitwiseCastReg<IS, ipInt32, ipReal32>::act(emm0, swap_sign_bit);
        BitwiseCastReg<IS, ipInt32, ipReal32>::act(emm2, poly_mask);
        BitwiseXOrReg<IS, ipReal32>::act(sign_bit, swap_sign_bit, sign_bit);
      
      /* The magic pass: "Extended precision modular arithmetic" 
         x = ((x - out * DP1) - out * DP2) - out * DP3; */
        RegReal32 minusCephesDP1, minusCephesDP2, minusCephesDP3;
        AssignReg<IS, ipReal32>::act(minusCephesDP1, -0.78515625f);
        AssignReg<IS, ipReal32>::act(minusCephesDP2, -2.4187564849853515625e-4f);
        AssignReg<IS, ipReal32>::act(minusCephesDP3, -3.77489497744594108e-8f);

        MulReg<IS, ipReal32>::act(out, minusCephesDP1, xmm1);
        MulReg<IS, ipReal32>::act(out, minusCephesDP2, xmm2);
        MulReg<IS, ipReal32>::act(out, minusCephesDP3, xmm3);
        AddReg<IS, ipReal32>::act(x, xmm1, x);
        AddReg<IS, ipReal32>::act(x, xmm2, x);
        AddReg<IS, ipReal32>::act(x, xmm3, x);

        /* Evaluate the first polynom  (0 <= x <= Pi/4) */
        RegReal32 z;
        MulReg<IS, ipReal32>::act(x, x, z);
        PolynomReg<IS, ISFma, 2, ipReal32>::act(
            z,
            4.166664568298827E-002f,    // coscof_p2
            -1.388731625493765E-003f,   // coscof_p1
            2.443315711809948E-005f,    // coscof_p0
            out);

        MulReg<IS, ipReal32>::act(out, z, out);
        MulReg<IS, ipReal32>::act(out, z, out);

        RegReal32 halfOne, oneReal32;
        AssignReg<IS, ipReal32>::act(halfOne, 0.5f);
        AssignReg<IS, ipReal32>::act(oneReal32, 1.0f);
        RegReal32 tmp;
        MulReg<IS, ipReal32>::act(z, halfOne, tmp);
        SubReg<IS, ipReal32>::act(out, tmp, out);
        AddReg<IS, ipReal32>::act(out, oneReal32, out);
      
        /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
        RegReal32 y2;
        PolynomReg<IS, ISFma, 2, ipReal32>::act(
            z,
            -1.6666654611E-1f,      // sincof_p2
            8.3321608736E-3f,       // sincof_p1
            -1.9515295891E-4f,      // sincof_p0
            y2);
        MulReg<IS, ipReal32>::act(y2, z, y2);
        MulReg<IS, ipReal32>::act(y2, x, y2);
        AddReg<IS, ipReal32>::act(y2, x, y2);

        /* select the correct result from the two polynoms */  
        BitwiseAndReg<IS, ipReal32>::act(poly_mask, y2, y2);
        BitwiseAndNotReg<IS, ipReal32>::act(out, poly_mask, out);
        AddReg<IS, ipReal32>::act(out, y2, out);
        /* update the sign */
        BitwiseXOrReg<IS, ipReal32>::act(out, sign_bit, out);
    }
};


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

#endif // __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_SINREG_H__