Expression.hpp

//
// $Id: Expression.hpp,v 1.8 2007/12/06 15:27:37 werner Exp $
//
#ifndef __vectorExpression_HPP
#define __vectorExpression_HPP "Created 25.05.2006 21:42:27 by werner"

#include "Iterator.hpp"

namespace Fiber
{
        using std::type_info;

template <class Operator>
struct  Expression
{
        template <class Data>
        static  void unary(const Iterator<Data>&p)
        {
                for(index_t i=0; i<p.count(); i++)
                {
                        Data&d = p[i];
                        Operator::unary( d );
                }
        }

        template <class Data>
        static  void unary(Operator&Op, const Iterator<Data>&p)
        {
                for(index_t i=0; i<p.count(); i++)
                {
                        Data&d = p[i]; 
                        Op.unary( d );
                }
        }

        template <int C, class Data>
        static  void unary(const Iterator<FixedArray<Data,C> >&p)
        {
                for(index_t i=0; i<p.count(); i++)
                {
                        Operator::begin_component(i);
                        for(int c=0; c<C; c++)
                        {
                                Operator::unary( p.getComponent(i,c) );
                        }
                        Operator::end_component(i);
                }
        }

        template <class Data, class Data2>
        static  void binary(const Iterator<Data>&p, const Iterator<Data2>&q)
        {
                for(index_t i=0; i<p.count(); i++)
                {
                typename Iterator<Data >::reference_t d = p[i];
                typename Iterator<Data2>::reference_t e = q[i];
                        Operator::binary( d, e );
                }
        }

        template <class Data, class Data1, class Data2>
        static  void ternary(const Iterator<Data>&p, const Iterator<Data1>&q, const Iterator<Data2>&r)
        {
        index_t Iend = p.count(); 
                for(index_t i=0; i<Iend; i++)
                {
                typename Iterator<Data >::reference_t a = p[i];
                typename Iterator<Data1>::reference_t b = q[i];
                typename Iterator<Data2>::reference_t c = r[i];
                        Operator::ternary( a, b, c );
                }
        }


        template <int C, class Data, class Data1, class Data2>
        static  void ternary(const Iterator<FixedArray<Data ,C> >&p, 
                             const Iterator<FixedArray<Data1,C> >&q, 
                             const Iterator<FixedArray<Data2,C> >&r)
        {
                for(index_t i=0; i<p.count(); i++)
                {
                        for(int c=0; c<C; c++)
                        {
                                Operator::ternary( p.getComponent(i,c), q.getComponent(i,c), r.getComponent(i,c) );
                        }
                }
        }
};


} /* namespace Fiber */ 

#endif /* __VectorExpression_HPP */