src/Field/Assign.h

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/

#ifndef ASSIGN_H
#define ASSIGN_H

// include files
#include "PETE/IpplExpressions.h"
#include "AppTypes/dcomplex.h"

// forward declarations
template<class T, unsigned Dim> class BareField;
template<class T, unsigned Dim> class LField;
template<class T, unsigned Dim, unsigned Brackets> class IndexedBareField;

// a debugging output message macro for assign functions.  This is
// only enabled if you specificall add -DDEBUG_ASSIGN somewhere.
#ifdef DEBUG_ASSIGN
#define ASSIGNMSG(x) x
#else
#define ASSIGNMSG(x)
#endif


//
// Currently, some of the assignment algorithms depend
// on knowing that there is just one Field on the rhs.
// We detect these here by building a simple tag class ExprTag
// that has a bool template argument.  The arg is true
// if the the assign should deal with general expressions,
// and false if it can use the special purpose single field version.
//
// This wouldn't be needed if we had partial specialization,
// but this will disambiguate expressions even without it.
//

template <bool IsExpr>
class ExprTag
{
#ifdef IPPL_PURIFY
public:
  ExprTag() {}
  ExprTag(const ExprTag<IsExpr> &) {}
  ExprTag<IsExpr>& operator=(const ExprTag<IsExpr> &) { return *this; }
#endif
};


// BareField = Expression 
template<class T, unsigned Dim, class RHS, class OP>
void
assign(const BareField<T,Dim>& a, RHS b, OP op, ExprTag<true>);

// IndexedBareField = Expression 
template<class T1, unsigned Dim, class RHS, class OP>
void
assign(const IndexedBareField<T1,Dim,Dim> &a, RHS b, OP op, ExprTag<true>,
       bool fillGC); // tjw added fillGC 12/16/1997 new BC hack

// IndexedBareField = Expression 
template<class T1, unsigned Dim, class RHS, class OP>
inline void
assign(const IndexedBareField<T1,Dim,Dim> &a, RHS b, OP op, ExprTag<true> et) {
  assign(a, b, op, et, true);
}

#ifdef __MWERKS__
// Work around CodeWarrior 4.0 bug
// Component = Expression
template<class A, class RHS, class OP, class Tag, class TP>
void
assign(PETE_TUTree<OpParens<TP>,A> lhs, RHS rhs, OP op, Tag tag) {
  assign(lhs, rhs, op, tag, true);
}

// Component = Expression
template<class A, class RHS, class OP, class Tag, class TP>
void
assign(PETE_TUTree<OpParens<TP>,A> lhs, RHS rhs, OP op, Tag,
       bool fillGC); // tjw added fillGC 12/16/1997 new BC hack

#else
// Component = Expression
template<class A, class RHS, class OP, class Tag, class TP>
void
assign(PETE_TUTree<OpParens<TP>,A> lhs, RHS rhs, OP op, Tag,
       bool fillGC=true); // tjw added fillGC 12/16/1997 new BC hack
#endif // __MWERKS__

// BareField = BareField, with communication.
template<class T1, unsigned D1, class RHS, class Op>
void
assign(const BareField<T1,D1>& lhs, RHS rhs, Op op, ExprTag<false>);

// IndexedBareField = IndexedBareField, different dimensions.
template<class T1, unsigned D1, class RHS, class Op>
void
assign(IndexedBareField<T1,D1,D1> lhs, RHS rhs, Op, ExprTag<false>);


// Expression = constant; 
template<class T, unsigned D, class OP>
inline void
assign(BareField<T,D>& a,const T& b, OP op, ExprTag<true>)
{
  assign(a, PETE_Scalar<T>(b), op, ExprTag<true>());
}

template<class T, unsigned D, class OP>
inline void
assign(IndexedBareField<T,D,D> a, const T& b, OP op, ExprTag<true>)
{
  assign(a, PETE_Scalar<T>(b), op, ExprTag<true>());
}


template<class T> struct IsExprTrait { enum { IsExpr = T::IsExpr } ; };
template<> struct IsExprTrait<double>   { enum { IsExpr = 1 }; };
template<> struct IsExprTrait<dcomplex> { enum { IsExpr = 1 }; };
template<> struct IsExprTrait<float>    { enum { IsExpr = 1 }; };
template<> struct IsExprTrait<short>    { enum { IsExpr = 1 }; };
template<> struct IsExprTrait<int>      { enum { IsExpr = 1 }; };
template<> struct IsExprTrait<long>     { enum { IsExpr = 1 }; };
template<> struct IsExprTrait<Index>    { enum { IsExpr = 1 }; };

#define ASSIGNMENT_OPERATORS(FUNC,OP)                           \
                                                                \
template<class LHS, class RHS>                                  \
inline void                                                     \
FUNC(const PETE_Expr<LHS>& lhs, const PETE_Expr<RHS>& rhs)      \
{                                                               \
  assign(lhs.PETE_unwrap(), rhs.PETE_unwrap().MakeExpression(), \
         OP(),ExprTag< IsExprTrait<RHS>::IsExpr >());           \
}                                                               \
                                                                \
template<class T, unsigned D>                                   \
inline void                                                     \
FUNC(const IndexedBareField<T,D,D>& lhs, const T& rhs)          \
{                                                               \
  assign(lhs,PETE_Scalar<T>(rhs), OP(),ExprTag<true>(),true);   \
}                                                               \
                                                                \
template<class T, unsigned D>                                   \
inline void                                                     \
FUNC(const BareField<T,D>& lhs, const T& rhs)                   \
{                                                               \
  assign(lhs,PETE_Scalar<T>(rhs),OP(),ExprTag<true>());         \
}                                                               \
                                                                \
template<class A, class TP>                                     \
inline void                                                     \
FUNC(const PETE_TUTree<OpParens<TP>,A>& lhs, const bool& rhs)   \
{                                                               \
  assign(lhs,PETE_Scalar<bool>(rhs),OP(),ExprTag<true>());      \
}                                                               \
template<class A, class TP>                                     \
inline void                                                     \
FUNC(const PETE_TUTree<OpParens<TP>,A>& lhs, const char& rhs)   \
{                                                               \
  assign(lhs,PETE_Scalar<char>(rhs),OP(),ExprTag<true>());      \
}                                                               \
template<class A, class TP>                                     \
inline void                                                     \
FUNC(const PETE_TUTree<OpParens<TP>,A>& lhs, const int& rhs)    \
{                                                               \
  assign(lhs,PETE_Scalar<int>(rhs),OP(),ExprTag<true>());       \
}                                                               \
template<class A,class TP>                                      \
inline void                                                     \
FUNC(const PETE_TUTree<OpParens<TP>,A>& lhs, const float& rhs)  \
{                                                               \
  assign(lhs,PETE_Scalar<float>(rhs),OP(),ExprTag<true>());     \
}                                                               \
template<class A, class TP>                                     \
inline void                                                     \
FUNC(const PETE_TUTree<OpParens<TP>,A>& lhs, const double& rhs) \
{                                                               \
  assign(lhs,PETE_Scalar<double>(rhs),OP(),ExprTag<true>());    \
}                                                               \
template<class A, class TP>                                     \
inline void                                                     \
FUNC(const PETE_TUTree<OpParens<TP>,A>& lhs, const dcomplex& rhs)\
{                                                               \
  assign(lhs,PETE_Scalar<dcomplex>(rhs),OP(),ExprTag<true>());  \
}

#ifdef UNDEFINED

template<class LHS>                                                     \
inline void                                                             \
FUNC(const PETE_Expr<LHS>& lhs, double rhs)                             \
{                                                                       \
  assign(lhs.PETE_unwrap(),PETE_Scalar<double>(rhs),OP(),ExprTag<true>());      \
}                                                                       \
                                                                        \
template<class LHS>                                                     \
inline void                                                             \
FUNC(const PETE_Expr<LHS>& lhs, float rhs)                              \
{                                                                       \
  assign(lhs.PETE_unwrap(),PETE_Scalar<float>(rhs),OP(),ExprTag<true>());       \
}                                                                       \
                                                                        \
template<class LHS>                                                     \
inline void                                                             \
FUNC(const PETE_Expr<LHS>& lhs, int rhs)                                \
{                                                                       \
  assign(lhs.PETE_unwrap(),PETE_Scalar<int>(rhs),OP(),ExprTag<true>()); \
}

#endif

ASSIGNMENT_OPERATORS(assign,OpAssign)
ASSIGNMENT_OPERATORS(operator<<,OpAssign)
ASSIGNMENT_OPERATORS(operator+=,OpAddAssign)                                  
ASSIGNMENT_OPERATORS(operator-=,OpSubtractAssign)                             
ASSIGNMENT_OPERATORS(operator*=,OpMultipplyAssign)
ASSIGNMENT_OPERATORS(operator/=,OpDivideAssign)
ASSIGNMENT_OPERATORS(mineq,OpMinAssign)
ASSIGNMENT_OPERATORS(maxeq,OpMaxAssign)


// Determine whether to compress or uncompress the
// left hand side given information about the expression.
// This prototype is defined here because the SubField assignment
// files need this functionality as well.
template<class T, unsigned Dim, class A, class Op>
bool TryCompressLHS(LField<T,Dim>&, A&, Op, const NDIndex<Dim>&);


// Include the .cpp function definitions.
#include "Field/Assign.cpp"
#include "Field/AssignGeneralBF.cpp"
#include "Field/AssignGeneralIBF.cpp"

#endif // ASSIGN_H

/***************************************************************************
 * $RCSfile: Assign.h,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:26 $
 * IPPL_VERSION_ID: $Id: Assign.h,v 1.1.1.1 2003/01/23 07:40:26 adelmann Exp $ 
 ***************************************************************************/

---