SIMDExpression.h

/*
 * Expression Template Matrix Library
 *
 * Copyright (C) 2004 - 2006 Ricky Lung <mtlung@users.sourceforge.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


#ifdef _MSC_VER
#   pragma once
#   pragma warning( push )
#   pragma warning( disable : 4324 4702 4714 )
#endif  // _MSC_VER

namespace exmat {


#if (HAVE_TT_PARAMETER)
template<class Exp, class newL, class newR> struct RefillBinExp;
template<template<class,class,class> class Exp, class L, class R, class SpecTag, class newL, class newR>
struct RefillBinExp< exmat::SIMD::SSCon<Exp<L,R,SpecTag> >, newL, newR> {
    typedef Exp<newL, newR, SpecTag> RET;
};
#endif  // HAVE_TT_PARAMETER


#if HAVE_PARTIAL_SPECIALIZATION && EXMAT_ENABLE_SIMD
using namespace exmat::SIMD;


template<typename T, int ROWS, int COLS, class Left, class Right>
struct GetBinExpTmpType<T,ROWS,COLS,SSCon<Left>,SSCon<Right> > {
    typedef Mat<SSCon<SCon<ROWS,COLS,T> >, EmptyErrorChecker> RET;
};
template<typename T, int ROWS, int COLS, class Left, class Right>
struct GetBinExpTmpType<T,ROWS,COLS,SSCon<Left>,ScalarCon<Right> > {
    typedef Mat<SSCon<SCon<ROWS,COLS,T> >, EmptyErrorChecker> RET;
};
template<typename T, int ROWS, int COLS, class Left, class Right>
struct GetBinExpTmpType<T,ROWS,COLS,ScalarCon<Left>,SSCon<Right> > {
    typedef Mat<SSCon<SCon<ROWS,COLS,T> >, EmptyErrorChecker> RET;
};


// Common typedefs for different SIMD expressions
/*  The typedef of rep_type do the magic that the resulting AddExp
 *  will be wrapped by the SSCon
 */
#define COMMON_SIMDEXP_TYPEDEFS(LOrR)                   \
typedef SSCon<self_type>                rep_type;       \
typedef const ExpRow<self_type>         const_row_type; \
typedef typename super_type::index_type index_type;     \
typedef typename LOrR::SIMD_unit_type   SIMD_unit_type; \
typedef typename super_type::value_type value_type;     \
enum {  ROWS = super_type::ROWS,                        \
        COLS = super_type::COLS     };                  \
typedef Left left_type;                                 \
typedef Right right_type;                               \
using super_type::leftOp;                               \
using super_type::rightOp;                              \
typedef typename GetBinExpTmpType<value_type,ROWS,COLS,Left,Right>::RET temp_type;



// The new specialization is inherited form the general one,
// so the ability of per element access is still there.
template<class Left_, class Right_>
class AddExp<SSCon<Left_>, SSCon<Right_> > :
public AddExp<Left_, Right_>,
public SIMDTag
{
    typedef SSCon<Left_>            Left;
    typedef SSCon<Right_>           Right;
    typedef AddExp<Left_, Right_>   super_type;
    typedef AddExp<Left, Right>     self_type;
public:

    COMMON_SIMDEXP_TYPEDEFS(Left);

    EXMAT_INLINE2 AddExp(const self_type& self)
        : super_type(self) {}
    EXMAT_INLINE2 AddExp(const Left& l, const Right& r)
        : super_type(l, r) {}

    /************************************************/
    // Index function
    EXMAT_INLINE2 SIMD_unit_type getUnitAt(const index_type i) const {
        return Intrinsics::add_p(leftOp.getUnitAt(i), rightOp.getUnitAt(i));
    }
};

template<class Left_, typename Right_>
class AddExp<SSCon<Left_>, ScalarCon<Right_> > :
public AddExp<Left_, ScalarCon<Right_> >,
public SIMDTag
{
    typedef SSCon<Left_>            Left;
    typedef ScalarCon<Right_>       Right;
    typedef AddExp<Left_, Right>    super_type;
    typedef AddExp<Left, Right>     self_type;
public:

    COMMON_SIMDEXP_TYPEDEFS(Left);

    EXMAT_INLINE2 AddExp(const self_type& self)
        : super_type(self), unitData(self.unitData)
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }
    EXMAT_INLINE2 AddExp(const Left& l, const Right& r)
        : super_type(l, r), unitData(SIMD::Intrinsics::load1_p(&r.scalar))
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }

    /************************************************/
    // Index function
    EXMAT_INLINE2 SIMD_unit_type getUnitAt(const index_type i) const {
        return Intrinsics::add_p(leftOp.getUnitAt(i), unitData);
    }
protected:
    SIMD_unit_type unitData;
};

template<class Left_, typename Right_>
class AddExp<ScalarCon<Left_>, SSCon<Right_> > :
public AddExp<ScalarCon<Left_>, Right_>,
public SIMDTag
{
    typedef ScalarCon<Left_>        Left;
    typedef SSCon<Right_>           Right;
    typedef AddExp<Left, Right_>    super_type;
    typedef AddExp<Left, Right>     self_type;
public:

    COMMON_SIMDEXP_TYPEDEFS(Right);

    EXMAT_INLINE2 AddExp(const self_type& self)
        : super_type(self), unitData(self.unitData)
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }
    EXMAT_INLINE2 AddExp(const Left& l, const Right& r)
        : super_type(l, r), unitData(SIMD::Intrinsics::load1_p(&l.scalar))
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }

    /************************************************/
    // Index function
    EXMAT_INLINE2 SIMD_unit_type getUnitAt(const index_type i) const {
        return Intrinsics::add_p(unitData, rightOp.getUnitAt(i));
    }
protected:
    SIMD_unit_type unitData;
};



template<class Left_, class Right_>
class SubExp<SSCon<Left_>, SSCon<Right_> > :
public SubExp<Left_, Right_>,
public SIMDTag
{
    typedef SSCon<Left_>            Left;
    typedef SSCon<Right_>           Right;
    typedef SubExp<Left_, Right_>   super_type;
    typedef SubExp<Left, Right>     self_type;
public:

    COMMON_SIMDEXP_TYPEDEFS(Left);

    EXMAT_INLINE2 SubExp(const self_type& self)
        : super_type(self) {}
    EXMAT_INLINE2 SubExp(const Left& l, const Right& r)
        : super_type(l, r) {}

    /************************************************/
    // Index function
    EXMAT_INLINE2 SIMD_unit_type getUnitAt(const index_type i) const {
        return Intrinsics::sub_p(leftOp.getUnitAt(i), rightOp.getUnitAt(i));
    }
};

template<class Left_, typename Right_>
class SubExp<SSCon<Left_>, ScalarCon<Right_> > :
public SubExp<Left_, ScalarCon<Right_> >,
public SIMDTag
{
    typedef SSCon<Left_>            Left;
    typedef ScalarCon<Right_>       Right;
    typedef SubExp<Left_, Right>    super_type;
    typedef SubExp<Left, Right>     self_type;
public:

    COMMON_SIMDEXP_TYPEDEFS(Left);

    EXMAT_INLINE2 SubExp(const self_type& self)
        : super_type(self), unitData(self.unitData)
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }
    EXMAT_INLINE2 SubExp(const Left& l, const Right& r)
        : super_type(l, r), unitData(SIMD::Intrinsics::load1_p(&r.scalar))
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }

    /************************************************/
    // Index function
    EXMAT_INLINE2 SIMD_unit_type getUnitAt(const index_type i) const {
        return Intrinsics::sub_p(leftOp.getUnitAt(i), unitData);
    }
protected:
    SIMD_unit_type unitData;
};

template<class Left_, typename Right_>
class SubExp<ScalarCon<Left_>, SSCon<Right_> > :
public SubExp<ScalarCon<Left_>, Right_>,
public SIMDTag
{
    typedef ScalarCon<Left_>        Left;
    typedef SSCon<Right_>           Right;
    typedef SubExp<Left, Right_>    super_type;
    typedef SubExp<Left, Right>     self_type;
public:

    COMMON_SIMDEXP_TYPEDEFS(Right);

    EXMAT_INLINE2 SubExp(const self_type& self)
        : super_type(self), unitData(self.unitData)
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }
    EXMAT_INLINE2 SubExp(const Left& l, const Right& r)
        : super_type(l, r), unitData(SIMD::Intrinsics::load1_p(&l.scalar))
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }

    /************************************************/
    // Index function
    EXMAT_INLINE2 SIMD_unit_type getUnitAt(const index_type i) const {
        return Intrinsics::sub_p(unitData, rightOp.getUnitAt(i));
    }
protected:
    SIMD_unit_type unitData;
};



template<class Left_, class Right_>
class MulExp<SSCon<Left_>, SSCon<Right_> > :
public MulExp<Left_, Right_>,
public SIMDTag
{
    typedef SSCon<Left_>            Left;
    typedef SSCon<Right_>           Right;
    typedef MulExp<Left_, Right_>   super_type;
    typedef MulExp<Left, Right>     self_type;
public:

    COMMON_SIMDEXP_TYPEDEFS(Left);

    EXMAT_INLINE2 MulExp(const self_type& self)
        : super_type(self) {}
    EXMAT_INLINE2 MulExp(const Left& l, const Right& r)
        : super_type(l, r) {}


    EXMAT_INLINE2 SIMD_unit_type getUnitAt(const index_type i) const {
        THROWMSG(false, InternalErrMsg, __FILE__);
        return leftOp.getUnitAt(i);
    }
};

template<class Left_, class Right_>
class ScalarMulExp<SSCon<Left_>, ScalarCon<Right_> > :
public ScalarMulExp<Left_, ScalarCon<Right_> >,
public SIMDTag
{
    typedef SSCon<Left_>                Left;
    typedef ScalarCon<Right_>           Right;
    typedef ScalarMulExp<Left_, Right>  super_type;
    typedef ScalarMulExp<Left, Right>   self_type;
public:

    COMMON_SIMDEXP_TYPEDEFS(Left);

    EXMAT_INLINE2 ScalarMulExp(const self_type& self)
        : super_type(self), unitData(self.unitData)
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }
    EXMAT_INLINE2 ScalarMulExp(const Left& l, const Right& r)
        : super_type(l, r), unitData(SIMD::Intrinsics::load1_p(&r.scalar))
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }

    /************************************************/
    // Index function
    EXMAT_INLINE2 SIMD_unit_type getUnitAt(const index_type i) const {
        return Intrinsics::mul_p(leftOp.getUnitAt(i), unitData);
    }
protected:
    SIMD_unit_type unitData;
};

template<class Left_, class Right_>
class ScalarMulExp<ScalarCon<Left_>, SSCon<Right_> > :
public ScalarMulExp<ScalarCon<Left_>, Right_>,
public SIMDTag
{
    typedef ScalarCon<Left_>            Left;
    typedef SSCon<Right_>               Right;
    typedef ScalarMulExp<Left, Right_>  super_type;
    typedef ScalarMulExp<Left, Right>   self_type;
public:

    COMMON_SIMDEXP_TYPEDEFS(Right);

    EXMAT_INLINE2 ScalarMulExp(const self_type& self)
        : super_type(self), unitData(self.unitData)
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }
    EXMAT_INLINE2 ScalarMulExp(const Left& l, const Right& r)
        : super_type(l, r), unitData(SIMD::Intrinsics::load1_p(&l.scalar))
    {   ALIGNMENT_CHECK(sizeof(SIMD_unit_type));    }

    /************************************************/
    // Index function
    EXMAT_INLINE2 SIMD_unit_type getUnitAt(const index_type i) const {
        return Intrinsics::mul_p(unitData, rightOp.getUnitAt(i));
    }
protected:
    SIMD_unit_type unitData;
};


#undef COMMON_SIMDEXP_TYPEDEFS


#endif  // HAVE_PARTIAL_SPECIALIZATION


};

#ifdef _MSC_VER
#   pragma warning( pop )
#endif  // _MSC_VER

---