SIMD.h

#ifndef __LDK_SIMD_H__
#define __LDK_SIMD_H__

#include <assert.h>

#ifdef __sse__
#include <xmmintrin.h>
#endif

#include "LDK/TemplateMeta.h"

namespace LDK
{

#ifdef __sse__
typedef __m128 v4sf;

class ALIGNED16 V4SF
{
protected:
v4sf data;
public:
    inline V4SF() {}
    inline V4SF(const V4SF& val) { data = val.data; } //very fast
    inline V4SF(const v4sf& val) { data = val; } //very fast

    inline V4SF(float* v) { data = _mm_loadu_ps(v); } //medium
    inline V4SF(float a, float b, float c, float d) { _mm_set_ps(a,b,c,d); } //slow
    inline explicit V4SF(float val) { data = _mm_set_ps1(val); } //slow
    inline explicit V4SF(double val) { data = _mm_set_ps1((float)val); } //slow

    inline V4SF& operator=(const V4SF& v) { data = v.data; } //very fast
    inline V4SF& operator=(const v4sf& v) { data = v; } //very fast
    inline V4SF& operator=(float val) { data = _mm_set_ps1(val); return *this; } //slow
    inline V4SF& operator=(double val) { data = _mm_set_ps1((float)val); return *this; }  //slow

    inline operator v4sf() const { return data; }

    inline V4SF operator-()
    {
        V4SF rtn(0.0f);
        rtn -= *this;
        return rtn;
    }

    //Arithmetic operators
    //all these are very fast
    friend inline V4SF operator+(const V4SF& a, const V4SF& b)  { return V4SF(_mm_add_ps(a,b)); }
    friend inline V4SF operator-(const V4SF& a, const V4SF& b)  { return V4SF(_mm_sub_ps(a,b)); }
    friend inline V4SF operator*(const V4SF& a, const V4SF& b)  { return V4SF(_mm_mul_ps(a,b)); }
    friend inline V4SF operator/(const V4SF& a, const V4SF& b)  { return V4SF(_mm_div_ps(a,b)); }
    inline V4SF& operator+=(const V4SF& v) { return *this = _mm_add_ps(data,v.data); }
    inline V4SF& operator-=(const V4SF& v) { return *this = _mm_sub_ps(data,v.data); }
    inline V4SF& operator*=(const V4SF& v) { return *this = _mm_mul_ps(data,v.data); }
    inline V4SF& operator/=(const V4SF& v) { return *this = _mm_div_ps(data,v.data); }
    //this is not optimal use of vector types, but can be handy. Medium speed
    friend inline V4SF operator+(const V4SF& a, float b)  { return V4SF(_mm_add_ps(a,_mm_set_ps1(b))); }
    friend inline V4SF operator-(const V4SF& a, float b)  { return V4SF(_mm_sub_ps(a,_mm_set_ps1(b))); }
    friend inline V4SF operator*(const V4SF& a, float b)  { return V4SF(_mm_mul_ps(a,_mm_set_ps1(b))); }
    friend inline V4SF operator/(const V4SF& a, float b)  { return V4SF(_mm_div_ps(a,_mm_set_ps1(b))); }
    inline V4SF& operator+=(float a) { return *this = V4SF(_mm_add_ps(data,_mm_set_ps1(a))); }
    inline V4SF& operator-=(float a) { return *this = V4SF(_mm_sub_ps(data,_mm_set_ps1(a))); }
    inline V4SF& operator*=(float a) { return *this = V4SF(_mm_mul_ps(data,_mm_set_ps1(a))); }
    inline V4SF& operator/=(float a) { return *this = V4SF(_mm_div_ps(data,_mm_set_ps1(a))); }

    //be carefull to stay in range 0-3!
    inline const float& operator[](int idx) const
    {
        assert((0 <= idx) && (idx <= 3));
        return *(((float*)&data)+idx);
    }
    inline float& operator[](int idx)
    {
        assert((0 <= idx) && (idx <= 3));
        return *(((float*)&data)+idx);
    }

    friend inline V4SF recip(const V4SF& v) { return _mm_rcp_ps(v); }
    //sse squareroot uses a lookup table, and is inaccurate but around 50x faster than c sqrt()
    friend inline V4SF sqrt(const V4SF& v) { return _mm_sqrt_ps(v); }
    friend inline V4SF recipsqrt(const V4SF& v) { return _mm_rsqrt_ps(v); }
};

#else //emulate the VPU with the FPU.
#include <math.h>
struct ALIGNED16 v4sf
{
float f0, f1, f2, f3;
    v4sf() {}
};

class ALIGNED16 V4SF
{
protected:
v4sf data;
public:
    V4SF() {}
    inline V4SF(float f0, float f1, float f2, float f3) { data.f0=f0; data.f1=f1; data.f2=f2; data.f3=f3; }
    inline V4SF(const v4sf& val) { data = val; }
    inline V4SF(float* dat) { data = (*(v4sf*)dat); }
    inline V4SF(float val) { *this = val; }
    inline V4SF& operator=(float val) { data.f0 = data.f1 = data.f2 = data.f3 = val; return *this; }

    inline operator v4sf() const { return data; }
    inline V4SF operator-()
    {
        V4SF rtn(0.0f);
        rtn -= *this;
        return rtn;
    }

    //all these are very slow. Strange. Numerous permutations of the code
    //have made no difference. Just a "feature" of the FPU :(
    //very slow with MSVC too, so it is not a g++ bug. Slow on both athlon and p4.
    friend inline V4SF operator+(const V4SF& a, const V4SF& b)
    {
        return V4SF(a.data.f0+b.data.f0, a.data.f1+b.data.f1,
            a.data.f2+b.data.f2, a.data.f3+b.data.f3);
    }
    friend inline V4SF operator-(const V4SF& a, const V4SF& b)
    {
        return V4SF(a.data.f0-b.data.f0, a.data.f1-b.data.f1,
            a.data.f2-b.data.f2, a.data.f3-b.data.f3);
    }
    friend inline V4SF operator*(const V4SF& a, const V4SF& b)
    {
        return V4SF(a.data.f0*b.data.f0, a.data.f1*b.data.f1,
            a.data.f2*b.data.f2, a.data.f3*b.data.f3);
    }
    friend inline V4SF operator/(const V4SF& a, const V4SF& b)
    {
        return V4SF(a.data.f0/b.data.f0, a.data.f1/b.data.f1,
            a.data.f2/b.data.f2, a.data.f3/b.data.f3);
    }

    //these are 3-4 times faster than the ops above
    //about 1/3 slower than the SSE ops i.e. very fast for an FPU
    inline V4SF& operator+=(const V4SF& val)
    {
        data.f0 += val.data.f0;
        data.f1 += val.data.f1;
        data.f2 += val.data.f2;
        data.f3 += val.data.f3;
        return *this;
    }
    inline V4SF& operator-=(const V4SF& val)
    {
        data.f0 -= val.data.f0;
        data.f1 -= val.data.f1;
        data.f2 -= val.data.f2;
        data.f3 -= val.data.f3;
        return *this;
    }
    inline V4SF& operator*=(const V4SF& val)
    {
        data.f0 *= val.data.f0;
        data.f1 *= val.data.f1;
        data.f2 *= val.data.f2;
        data.f3 *= val.data.f3;
        return *this;
    }
    inline V4SF& operator/=(const V4SF& val)
    {
        data.f0 /= val.data.f0;
        data.f1 /= val.data.f1;
        data.f2 /= val.data.f2;
        data.f3 /= val.data.f3;
        return *this;
    }

    //float operators. Slightly faster than vector/vector ops, but these ops are still 3-4 times slower than the compounds
    friend inline V4SF operator+(const V4SF& a, float b) { return V4SF(a.data.f0+b, a.data.f1+b, a.data.f2+b, a.data.f3+b); }
    friend inline V4SF operator-(const V4SF& a, float b) { return V4SF(a.data.f0-b, a.data.f1-b, a.data.f2-b, a.data.f3-b); }
    friend inline V4SF operator*(const V4SF& a, float b) { return V4SF(a.data.f0*b, a.data.f1*b, a.data.f2*b, a.data.f3*b); }
    friend inline V4SF operator/(const V4SF& a, float b) { return V4SF(a.data.f0/b, a.data.f1/b, a.data.f2/b, a.data.f3/b); }
    //these are the fastest emulated VPU ops
    inline V4SF& operator+=(float val)
    {
        data.f0 += val; data.f1 += val;
        data.f2 += val; data.f3 += val;
        return *this;
    }
    inline V4SF& operator-=(float val)
    {
        data.f0 -= val; data.f1 -= val;
        data.f2 -= val; data.f3 -= val;
        return *this;
    }
    inline V4SF& operator*=(float val)
    {
        data.f0 *= val; data.f1 *= val;
        data.f2 *= val; data.f3 *= val;
        return *this;
    }
    inline V4SF& operator/=(float val)
    {
        data.f0 /= val; data.f1 /= val;
        data.f2 /= val; data.f3 /= val;
        return *this;
    }

    inline const float& operator[](int idx) const { return *(((float*)&data)+idx); }
    inline float& operator[](int idx) { return *(((float*)&data)+idx); }

    friend inline V4SF recip(const V4SF& v) { return V4SF(1.0f/v[0], 1.0f/v[1], 1.0f/v[2], 1.0f/v[3]); } //fast
    //very, very, very slow. Need to do lookup tables for sqrt
    friend inline V4SF sqrt(const V4SF& v) { return V4SF(sqrt(v[0]), sqrt(v[1]), sqrt(v[2]), sqrt(v[3])); }
    friend inline V4SF recipsqrt(const V4SF& v) { return V4SF(1.0f/sqrt(v[0]), 1.0f/sqrt(v[1]), 1.0f/sqrt(v[2]), 1.0f/sqrt(v[3])); }
};

#endif //__sse__

namespace V4SFV //private namespace for utilities related to fixed size vectors of V4SFs.
{

// Expr -- a vector expression iterator
template<class A>
class Expr
{
private:
    A mIter;
public:
    Expr(const A& a)
        : mIter(a)
    { }

    V4SF operator*() const
    { return *mIter; }

    const V4SF& operator[](int i) const
    { return mIter[i]; }

    void operator++()
    { ++mIter; }
};

// Applicative templates...

// +
struct ApAdd
{
    static inline V4SF apply(const V4SF& a, const V4SF& b)
    { return a + b; }
};

// /
struct ApDivide
{
    static inline V4SF apply(const V4SF& a, const V4SF& b)
    { return a / b; }
};

// -
struct ApSubtract
{
    static inline V4SF apply(const V4SF& a, const V4SF& b)
    { return a - b; }
};

// *
struct ApMultiply
{
    static inline V4SF apply(const V4SF& a, const V4SF& b)
    { return a * b; }
};

// =
struct ApAssign
{
    static inline void apply(V4SF&a, const V4SF&b)
    { a = b; }
};

// +=
struct ApAddAssign
{
    static inline void apply(V4SF&a, const V4SF&b)
    { a += b; }
};

// -=
struct ApSubtractAssign
{
    static inline void apply(V4SF&a, const V4SF&b)
    { a -= b; }
};

// *=
struct ApMultiplyAssign
{
    static inline void apply(V4SF&a, const V4SF&b)
    { a *= b; }
};

// /=
struct ApDivideAssign
{
    static inline void apply(V4SF&a, const V4SF&b)
    { a /= b; }
};

// A BinExprOp represents an operation on two dereferenced iterators (A,B).
// It can be thought of as an "applicative iterator", combining the
// notion of an STL applicative template, and an iterator.
template<class A, class B, class Op>
class BinExprOp
{
private:
    A mIter1;
    B mIter2;
public:
    BinExprOp(const A& a, const B& b)
        : mIter1(a), mIter2(b)
    { }

    inline void operator++()
    { ++mIter1; ++mIter2; }

    inline V4SF operator*() const
    { return Op::apply(*mIter1,*mIter2); }

    inline V4SF operator[](int i) const
    { return Op::apply(mIter1[i], mIter2[i]); }
};

// A class that holds a float literal as a V4SF of identical values
class ALIGNED16 FExprLiteral
{
private:
V4SF mValue;
public:
    FExprLiteral(float val) : mValue(val) {}
    inline void operator++() {}
    inline const V4SF& operator*() const { return mValue; }
    inline const V4SF& operator[](int idx) const { return mValue; }
};

// Template meta-program loop unrolling assignment policy
template <int I, class A, class Op>
struct AssignUnroll
{
    static inline void loop(V4SF* a, V4SFV::Expr<A> expr)
    {
        Op::apply(*a,*expr);
        ++expr;
        AssignUnroll<I-1,A,Op>::loop(++a,expr);
    }
};

// meta-loop terminator
template <class A, class Op>
struct AssignUnroll<0, A, Op>
{
    static inline void loop(V4SF* a, V4SFV::Expr<A> expr)
    { Op::apply(*a,*expr); }
};

// for loop assignment policy
template <int Size, class A, class Op>
struct AssignLoop
{
    static inline void loop(V4SF* a, V4SFV::Expr<A> expr)
    {
        for(int i=0;i<Size;i++) //likely to be unrolled by the compiler anyway due to compile time Size :)
        {
            Op::apply(*a,*expr);
            ++a;
            ++expr;
        }
    }
};

}//namespace V4SFV

// V4SFVector:
template <int SizeInFloats, int Unroll=48>
class V4SFVector
{
public:
    static const int SizeInF  = SizeInFloats;
    static const int Spare = SizeInF%4;
    static const int SizeInV = (SizeInF/4) + (Spare ? 1 : 0);
    typedef V4SF* iterator;
    typedef const V4SF* const_iterator;
    typedef V4SF element;
protected:

    V4SF mData[SizeInV];
public:

    inline V4SFVector()
    {}

    inline V4SFVector(const V4SFVector& rhs)
    {
        *this = rhs;
    }

    inline V4SFVector(const float *array)
    {
        for(int i=0;i<SizeInFloats;i++)
        {
            ((float*)mData)[i] = array[i];
        }
    }

    inline ~V4SFVector()
    {}

    explicit inline V4SFVector(V4SFVector& b) : mData(b.mData)
    {}

    inline explicit V4SFVector(float val)
    { *this = val; }

    inline const_iterator begin() const { return &mData[0]; }
    inline const_iterator end() const { return &mData[SizeInV-1]; }
    inline iterator      begin() { return mData; }
    inline iterator      end() { return &mData[SizeInV-1]; }

    //element access
    inline float& operator[](int idx)
    {
        assert((0 <= idx) && (idx<SizeInF+Spare));
        return ((float*)mData)[idx];
    }
    inline const float& operator[](int idx) const
    {
        assert((0 <= idx) && (idx<SizeInF+Spare));
        return ((float*)mData)[idx];
    }
    inline const V4SF& at(int idx)
    {
        assert((0 <= idx) && (idx<SizeInV));
        return mData[idx];
    }
    inline void at(int idx, const V4SF& v)
    {
        assert((0 <= idx) && (idx<SizeInV));
        mData[idx] = v;
    }
    //float element read with linear interpolation
    inline float interpolate(float idx)
    {
        int i = idx;
        assert((0 <= i) && (i<SizeInF+Spare));

        float difference = ((float*)mData)[i+1] - ((float*)mData)[i];
        difference *= (idx - (float)i);
        return (((float*)mData)[i])+difference;
    }

    //ASSIGNMENT OPERATORS
    template<class A>
    inline V4SFVector& operator=(V4SFV::Expr<A> expr)
    {
        typedef typename Meta::If<(SizeInV>Unroll),V4SFV::AssignUnroll<SizeInV,A,V4SFV::ApAssign>,\
            V4SFV::AssignLoop<SizeInV,A,V4SFV::ApAssign> >::result AssignP;
        AssignP::loop(begin(),expr);
        return *this;
    }
    inline V4SFVector& operator=(float b)
    {
        V4SFV::FExprLiteral bLit(b);
        *this = V4SFV::Expr<V4SFV::FExprLiteral>(bLit);
        return *this;
    }

    //COMPOUND OPERATORS
    /*not working :(
    template<class A>
    inline V4SFVector& operator+=(V4SFV::Expr<A> expr)
    {
        typedef typename Meta::If<(SizeInV>Unroll),V4SFV::AssignUnroll<SizeInV,A,V4SFV::ApAddAssign>,\
            V4SFV::AssignLoop<SizeInV,A,V4SFV::ApAddAssign> >::result AssignAddP;
        AssignAddP::loop(begin(),expr);
        return *this;
    }

    template<class A>
    inline V4SFVector& operator-=(V4SFV::Expr<A> expr)
    {
        typedef typename Meta::If<(SizeInV>Unroll),V4SFV::AssignUnroll<SizeInV,A,V4SFV::ApSubtractAssign>,\
            V4SFV::AssignLoop<SizeInV,A,V4SFV::ApSubtractAssign> >::result AssignSubtractP;
        AssignSubtractP::loop(begin(),expr);
        return *this;
    }

    template<class A>
    inline V4SFVector& operator*=(V4SFV::Expr<A> expr)
    {
        typedef typename Meta::If<(SizeInV>Unroll),V4SFV::AssignUnroll<SizeInV,A,V4SFV::ApMultiplyAssign>,\
            V4SFV::AssignLoop<SizeInV,A,V4SFV::ApMultiplyAssign> >::result AssignMultiplyP;
        AssignMultiplyP::loop(begin(),expr);
        return *this;
    }

    template<class A>
    inline V4SFVector& operator/=(V4SFV::Expr<A> expr)
    {
        typedef typename Meta::If<(SizeInV>Unroll),V4SFV::AssignUnroll<SizeInV,A,V4SFV::ApDivideAssign>,\
            V4SFV::AssignLoop<SizeInV,A,V4SFV::ApDivideAssign> >::result AssignDivideP;
        AssignDivideP::loop(begin(),expr);
        return *this;
    }*/

    //ADDITION OPERATORS

    friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,const_iterator,V4SFV::ApAdd> >
    operator+(const V4SFVector& a, const V4SFVector& b)
    {
        typedef V4SFV::BinExprOp<const_iterator,const_iterator,V4SFV::ApAdd> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b.begin()));
    }

    friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,V4SFV::FExprLiteral,V4SFV::ApAdd> >
    operator+(const V4SFVector& a, float b)
    {
        typedef V4SFV::BinExprOp<const_iterator,V4SFV::FExprLiteral,V4SFV::ApAdd> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,const_iterator,V4SFV::ApAdd> >
    operator+(const V4SFV::Expr<A>& a, const V4SFVector& b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,const_iterator,V4SFV::ApAdd> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b.begin()));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::FExprLiteral,V4SFV::ApAdd> >
    operator+(const V4SFV::Expr<A>& a, float b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::FExprLiteral,V4SFV::ApAdd> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,V4SFV::Expr<A>,V4SFV::ApAdd> >
    operator+(const V4SFVector& a, const V4SFV::Expr<A>& b)
    {
        typedef V4SFV::BinExprOp<const_iterator,V4SFV::Expr<A>,V4SFV::ApAdd> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b));
    }

    template<class A, class B> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::Expr<B>,V4SFV::ApAdd> >
    operator+(const V4SFV::Expr<A>& a, const V4SFV::Expr<B>& b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::Expr<B>,V4SFV::ApAdd> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b));
    }

    //SUBTRACTION OPERATORS

    friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,const_iterator,V4SFV::ApSubtract> >
    operator-(const V4SFVector& a, const V4SFVector& b)
    {
        typedef V4SFV::BinExprOp<const_iterator,const_iterator,V4SFV::ApSubtract> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b.begin()));
    }

    friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,V4SFV::FExprLiteral,V4SFV::ApSubtract> >
    operator-(const V4SFVector& a, float b)
    {
        typedef V4SFV::BinExprOp<const_iterator,V4SFV::FExprLiteral,V4SFV::ApSubtract> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,const_iterator,V4SFV::ApSubtract> >
    operator-(const V4SFV::Expr<A>& a, const V4SFVector& b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,const_iterator,V4SFV::ApSubtract> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b.begin()));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::FExprLiteral,V4SFV::ApSubtract> >
    operator-(const V4SFV::Expr<A>& a, float b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::FExprLiteral,V4SFV::ApSubtract> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,V4SFV::Expr<A>,V4SFV::ApSubtract> >
    operator-(const V4SFVector& a, const V4SFV::Expr<A>& b)
    {
        typedef V4SFV::BinExprOp<const_iterator,V4SFV::Expr<A>,V4SFV::ApSubtract> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b));
    }

    template<class A, class B> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::Expr<B>,V4SFV::ApSubtract> >
    operator-(const V4SFV::Expr<A>& a, const V4SFV::Expr<B>& b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::Expr<B>,V4SFV::ApSubtract> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b));
    }

    //DIVISION OPERATORS

    friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,const_iterator,V4SFV::ApDivide> >
    operator/(const V4SFVector& a, const V4SFVector& b)
    {
        typedef V4SFV::BinExprOp<const_iterator,const_iterator,V4SFV::ApDivide> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b.begin()));
    }

    friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,V4SFV::FExprLiteral,V4SFV::ApDivide> >
    operator/(const V4SFVector& a, float b)
    {
        typedef V4SFV::BinExprOp<const_iterator,V4SFV::FExprLiteral,V4SFV::ApDivide> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,const_iterator,V4SFV::ApDivide> >
    operator/(const V4SFV::Expr<A>& a, const V4SFVector& b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,const_iterator,V4SFV::ApDivide> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b.begin()));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::FExprLiteral,V4SFV::ApDivide> >
    operator/(const V4SFV::Expr<A>& a, float b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::FExprLiteral,V4SFV::ApDivide> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,V4SFV::Expr<A>,V4SFV::ApDivide> >
    operator/(const V4SFVector& a, const V4SFV::Expr<A>& b)
    {
        typedef V4SFV::BinExprOp<const_iterator,V4SFV::Expr<A>,V4SFV::ApDivide> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b));
    }

    template<class A, class B> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::Expr<B>,V4SFV::ApDivide> >
    operator/(const V4SFV::Expr<A>& a, const V4SFV::Expr<B>& b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::Expr<B>,V4SFV::ApDivide> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b));
    }

    //MULTIPLICATION OPERATORS

    friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,const_iterator,V4SFV::ApMultiply> >
    operator*(const V4SFVector& a, const V4SFVector& b)
    {
        typedef V4SFV::BinExprOp<const_iterator,const_iterator,V4SFV::ApMultiply> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b.begin()));
    }

    friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,V4SFV::FExprLiteral,V4SFV::ApMultiply> >
    operator*(const V4SFVector& a, float b)
    {
        typedef V4SFV::BinExprOp<const_iterator,V4SFV::FExprLiteral,V4SFV::ApMultiply> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,const_iterator,V4SFV::ApMultiply> >
    operator*(const V4SFV::Expr<A>& a, const V4SFVector& b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,const_iterator,V4SFV::ApMultiply> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b.begin()));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::FExprLiteral,V4SFV::ApMultiply> >
    operator*(const V4SFV::Expr<A>& a, float b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::FExprLiteral,V4SFV::ApMultiply> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b));
    }

    template<class A> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<const_iterator,V4SFV::Expr<A>,V4SFV::ApMultiply> >
    operator*(const V4SFVector& a, const V4SFV::Expr<A>& b)
    {
        typedef V4SFV::BinExprOp<const_iterator,V4SFV::Expr<A>,V4SFV::ApMultiply> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a.begin(),b));
    }

    template<class A, class B> friend inline
    V4SFV::Expr<V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::Expr<B>,V4SFV::ApMultiply> >
    operator*(const V4SFV::Expr<A>& a, const V4SFV::Expr<B>& b)
    {
        typedef V4SFV::BinExprOp<V4SFV::Expr<A>,V4SFV::Expr<B>,V4SFV::ApMultiply> ExprT;
        return V4SFV::Expr<ExprT>(ExprT(a,b));
    }
};

}//namespace LDK

#endif //__LDK_SIMD_H__

---