PowReg.h

Go to the documentation of this file.

// PowReg.h:
// -------------------
//

#ifndef __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_POWREG_H__
#define __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_POWREG_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/InstructionSet/RegType.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/AbsReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/DivReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/IsOddReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/PowReg.h>
#include <IPSDKUtil/InstructionSet/Arithmetic/detail/PowNoCheckReg.h>
#include <IPSDKUtil/InstructionSet/Comparison/detail/IsEqualReg.h>
#include <IPSDKUtil/InstructionSet/Comparison/detail/IsGreaterReg.h>
#include <IPSDKUtil/InstructionSet/Comparison/detail/IsLessReg.h>
#include <IPSDKUtil/InstructionSet/Comparison/detail/IsNotEqualReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseAndReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseAndNotReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseOrReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/BitwiseSelectReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/LogicalAndReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/LogicalOrReg.h>
#include <IPSDKUtil/InstructionSet/Logical/detail/IfElseReg.h>
#include <IPSDKUtil/InstructionSet/detail/AssignReg.h>
#include <IPSDKUtil/Tools/ForceInline.h>

#include <boost/mpl/not_equal_to.hpp>

namespace ipsdk {
namespace simd {
namespace detail {


template <eInstructionSet::domain IS, eInstructionSet::domain ISFma>
struct PowReg<
    IS,
    ISFma,
    ipReal32,
    typename boost::enable_if<
        typename boost::mpl::not_equal_to<
            boost::mpl::int_<IS>,
            boost::mpl::int_<eInstructionSet::eIS_Standard>
        >::type
    >::type
>
{
    static IPSDK_FORCEINLINE
    typename RegType<IS, ipReal32>::Type
    act(const typename RegType<IS, ipReal32>::Type& base,
        const typename RegType<IS, ipReal32>::Type& exp)
    {
        typename RegType<IS, ipReal32>::Type out;
        act(base, exp, out);
        return out;
    }

    static IPSDK_FORCEINLINE
    void
    act(const typename RegType<IS, ipReal32>::Type& base,
        const typename RegType<IS, ipReal32>::Type& exp,
        typename RegType<IS, ipReal32>::Type& out)
    {
        typedef typename RegType<IS, ipReal32>::Type Reg;
        typedef typename RegMaskType<IS, ipReal32>::Type RegMask;
        Reg o;
        PowNoCheckReg<IS, ISFma, ipReal32>::act(base, exp, o);

        Reg zero, one, inf, minf, nan;
        AssignReg<IS, ipReal32>::act(zero, .0f);
        AssignReg<IS, ipReal32>::act(one, 1.0f);
        AssignReg<IS, ipReal32>::act(minf, -std::numeric_limits<ipReal32>::infinity());
        AssignReg<IS, ipReal32>::act(inf, std::numeric_limits<ipReal32>::infinity());
        AssignReg<IS, ipReal32>::act(nan, std::numeric_limits<ipReal32>::quiet_NaN());
        Reg invBase;
        DivReg<IS, ipReal32>::act(one, base, invBase);
        RegMask invBaseIsNeg;
        IsLessReg<IS, ipReal32>::act(invBase, zero, invBaseIsNeg);
        RegMask baseIsNull;
        IsEqualReg<IS, ipReal32>::act(base, zero, baseIsNull);
        
        RegMask baseIsMinusZero;
        LogicalAndReg<IS, ipReal32>::act(baseIsNull, invBaseIsNeg, baseIsMinusZero);
        RegMask expIsPos, expIsNeg, expIsOdd;
        RegMask expIsNegOdd;
        IsGreaterReg<IS, ipReal32>::act(exp, zero, expIsPos);
        IsLessReg<IS, ipReal32>::act(exp, zero, expIsNeg);
        IsOddReg<IS, ipReal32>::act(exp, expIsOdd);

        LogicalAndReg<IS, ipReal32>::act(expIsNeg, expIsOdd, expIsNegOdd);
        Reg absBase;
        AbsReg<IS, ipReal32>::act(base, absBase);
        
        RegMask baseEqualsToInfinity;
        IsEqualReg<IS, ipReal32>::act(base, inf, baseEqualsToInfinity);
        RegMask baseEqualsToMinusInfinity;
        IsEqualReg<IS, ipReal32>::act(base, minf, baseEqualsToMinusInfinity);

        RegMask expEqualsToInfinity;
        IsEqualReg<IS, ipReal32>::act(exp, inf, expEqualsToInfinity);
        RegMask expEqualsToMinusInfinity;
        IsEqualReg<IS, ipReal32>::act(exp, minf, expEqualsToMinusInfinity);

        // pow(+0, exp), where exp is a negative odd integer, returns +infinity (and should raise FE_DIVBYZERO, not the case here for the moment)
        // pow(+/-0, exp) where exp is negative, finite and is an even integer or a non-integer, returns +infinity (and should raise FE_DIVBYZERO, but this is not the case here for the moment
        RegMask baseIsNullAndExpIsNeg;
        LogicalAndReg<IS, ipReal32>::act(baseIsNull, expIsNeg, baseIsNullAndExpIsNeg);
        IfElseReg<IS, ipReal32>::act(baseIsNullAndExpIsNeg, inf, o, o);

        // pow(-0, exp), where exp is a negative odd integer, returns -infinity (and should raise FE_DIVBYZERO, not the case here for the moment)
        RegMask baseIsMinusZeroAndExpIsNegOdd;
        LogicalAndReg<IS, ipReal32>::act(baseIsMinusZero, expIsNegOdd, baseIsMinusZeroAndExpIsNegOdd);
        IfElseReg<IS, ipReal32>::act(baseIsMinusZeroAndExpIsNegOdd, minf, o, o);

        // pow(base, -inf) returns +inf for any |base| < 1
        // pow(base, -inf) returns 0 for any |base| > 1
        RegMask absBaseLessThanOne;
        IsLessReg<IS, ipReal32>::act(absBase, one, absBaseLessThanOne);
        Reg regFromAbsBaseLessThanOne;
        CastReg<IS, ipReal32, ipReal32>::act(absBaseLessThanOne, regFromAbsBaseLessThanOne);
        Reg infIfAbsBaseLessThanOneElse0;
        BitwiseAndReg<IS, ipReal32>::act(regFromAbsBaseLessThanOne, inf, infIfAbsBaseLessThanOneElse0);
        IfElseReg<IS, ipReal32>::act(expEqualsToMinusInfinity, infIfAbsBaseLessThanOneElse0, o, o);

        // pow(base, inf) returns 0 for any |base| < 1
        // pow(base, inf) returns +infinity for any |base| > 1
        Reg zeroIfAbsBaseLessThanOneElseInf;
        BitwiseAndNotReg<IS, ipReal32>::act(inf, regFromAbsBaseLessThanOne, zeroIfAbsBaseLessThanOneElseInf);
        IfElseReg<IS, ipReal32>::act(expEqualsToInfinity, zeroIfAbsBaseLessThanOneElseInf, o, o);

        // pow(-1, +/-infinity) returns 1
        RegMask expEqualsToPlusInfinity;
        IsEqualReg<IS, ipReal32>::act(exp, inf, expEqualsToPlusInfinity);
        LogicalOrReg<IS, ipReal32>::act(expEqualsToPlusInfinity, expEqualsToMinusInfinity, expEqualsToPlusInfinity);
        RegMask baseEqualsToMinusOne;
        const Reg minusOne = AssignReg<IS, ipReal32>::act(-1.0f);
        IsEqualReg<IS, ipReal32>::act(
            base,
            minusOne,
            baseEqualsToMinusOne);
        
        RegMask baseEqualsToMinusOneAndAbsExpEqualsToInf;
        LogicalAndReg<IS, ipReal32>::act(baseEqualsToMinusOne, expEqualsToPlusInfinity, baseEqualsToMinusOneAndAbsExpEqualsToInf);
        IfElseReg<IS, ipReal32>::act(baseEqualsToMinusOneAndAbsExpEqualsToInf, one, o, o);

        // pow(-inf, exp) returns -0 if exp is a negative odd integer
        // pow(-inf, exp) returns +0 if exp is a negative non-integer or even integer
        // pow(-inf, exp) returns -inf if exp is a positive odd integer
        // pow(-inf, exp) returns +inf if exp is a positive non-integer or even integer
        Reg mzeroIfExpisOddElseZero, minfIfExpIsOddElseInf, zeroIfExpIsNegElseInf;
        const Reg minusZero = AssignReg<IS, ipReal32>::act(-.0f);
        IfElse0Reg<IS, ipReal32>::act(expIsOdd, minusZero, mzeroIfExpisOddElseZero);
        IfElseReg<IS, ipReal32>::act(expIsOdd, minf, inf, minfIfExpIsOddElseInf);
        IfElseReg<IS, ipReal32>::act(
            expIsNeg,
            mzeroIfExpisOddElseZero,
            minfIfExpIsOddElseInf,
            zeroIfExpIsNegElseInf);
        IfElseReg<IS, ipReal32>::act(baseEqualsToMinusInfinity, zeroIfExpIsNegElseInf, o, o);

        // pow(+inf, exp) returns +0 for any negative exp
        // pow(+inf, exp) returns +inf for any positive exp
        IfElse0Reg<IS, ipReal32>::act(expIsPos, inf, zeroIfExpIsNegElseInf);
        IfElseReg<IS, ipReal32>::act(baseEqualsToInfinity, zeroIfExpIsNegElseInf, o, o);

        // pow(nan, exp) returns nan if exp not null
        RegMask baseIsNan;
        IsNotEqualReg<IS, ipReal32>::act(base, base, baseIsNan);
        IfElseReg<IS, ipReal32>::act(baseIsNan, nan, o, o);

        // pow(base, nan) returns nan if base is different from 1
        RegMask expIsNan;
        IsNotEqualReg<IS, ipReal32>::act(exp, exp, expIsNan);
        IfElseReg<IS, ipReal32>::act(expIsNan, nan, o, o);

        // pow(1, exp) returns one for any exp
        RegMask baseEqualsToOne;
        IsEqualReg<IS, ipReal32>::act(base, one, baseEqualsToOne);
        IfElseReg<IS, ipReal32>::act(baseEqualsToOne, one, o, o);

        // pow(base, +/-0) returns one for any base
        RegMask expIsNull;
        IsEqualReg<IS, ipReal32>::act(exp, zero, expIsNull);
        IfElseReg<IS, ipReal32>::act(expIsNull, one, o, out);
    }
};


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

#endif // __IPSDKUTIL_INSTRUCTIONSET_ARITHMETIC_DETAIL_COMMON_POWREG_H__