/***************************************************************************
 * blitz/arrayexpr.h     Array<T,N> expression templates
 *
 * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * Suggestions:          blitz-dev@oonumerics.org
 * Bugs:                 blitz-bugs@oonumerics.org
 *
 * For more information, please see the Blitz++ Home Page:
 *    http://oonumerics.org/blitz/
 *
 ****************************************************************************/
#ifndef BZ_ARRAYTERNARYEXPR_H
#define BZ_ARRAYTERNARYEXPR_H

#ifndef BZ_ARRAY_H
 #error <blitz/array/expr.h> must be included via <blitz/array.h>
#endif

#ifndef BZ_OPS_H
 #include <blitz/ops.h>
#endif

#ifndef BZ_PRETTYPRINT_H
 #include <blitz/prettyprint.h>
#endif

#ifndef BZ_SHAPECHECK_H
 #include <blitz/shapecheck.h>
#endif

#ifndef BZ_NUMINQUIRE_H
 #include <blitz/numinquire.h>
#endif

/*
 * The array expression templates iterator interface is followed by
 * these classes:
 *
 * _bz_ArrayExprTernaryOp                    "
 */

BZ_NAMESPACE(blitz)

template<class P_expr1, class P_expr2, class P_expr3, class P_op>
class _bz_ArrayExprTernaryOp {
public:
    typedef P_expr1 T_expr1;
    typedef P_expr2 T_expr2;
    typedef P_expr3 T_expr3;
    typedef _bz_typename T_expr1::T_numtype T_numtype1;
    typedef _bz_typename T_expr2::T_numtype T_numtype2;
    typedef _bz_typename T_expr3::T_numtype T_numtype3;
    typedef _bz_typename P_op::T_numtype T_numtype;
    typedef P_op T_op;
    typedef T_expr1 T_ctorArg1;
    typedef T_expr2 T_ctorArg2;
    typedef T_expr3 T_ctorArg3;

    enum { numArrayOperands = BZ_ENUM_CAST(P_expr1::numArrayOperands)
                            + BZ_ENUM_CAST(P_expr2::numArrayOperands)
                            + BZ_ENUM_CAST(P_expr3::numArrayOperands),
           numIndexPlaceholders = BZ_ENUM_CAST(P_expr1::numIndexPlaceholders)
                            + BZ_ENUM_CAST(P_expr2::numIndexPlaceholders)
                            + BZ_ENUM_CAST(P_expr3::numIndexPlaceholders),
           rank = (BZ_ENUM_CAST(P_expr1::rank) > BZ_ENUM_CAST(P_expr2::rank)) 
                ? ( (BZ_ENUM_CAST(P_expr1::rank) > BZ_ENUM_CAST(P_expr3::rank)) 
                        ? BZ_ENUM_CAST(P_expr1::rank) : BZ_ENUM_CAST(P_expr3::rank) ) 
                : ( (BZ_ENUM_CAST(P_expr2::rank) > BZ_ENUM_CAST(P_expr3::rank)) 
                        ? BZ_ENUM_CAST(P_expr2::rank) : BZ_ENUM_CAST(P_expr3::rank))
    };

    _bz_ArrayExprTernaryOp(const _bz_ArrayExprTernaryOp<P_expr1, P_expr2, P_expr3, P_op>& a)
        : iter1_(a.iter1_), iter2_(a.iter2_), iter3_(a.iter3_)
    { }

    template<class T1, class T2, class T3>
    _bz_ArrayExprTernaryOp(BZ_ETPARM(T1) a, BZ_ETPARM(T2) b, BZ_ETPARM(T3) c)
        : iter1_(a), iter2_(b), iter3_(c)
    { }

//    _bz_ArrayExprTernaryOp(T_expr1 a, T_expr2 b)
//       : iter1_(a), iter2_(b)
//    { }

    T_numtype operator*()
    { return T_op::apply(*iter1_, *iter2_,*iter3_); }

#ifdef BZ_ARRAY_EXPR_PASS_INDEX_BY_VALUE
    template<int N_rank>
    T_numtype operator()(TinyVector<int, N_rank> i)
    { return T_op::apply(iter1_(i), iter2_(i),iter3_(i)); }
#else
    template<int N_rank>
    T_numtype operator()(const TinyVector<int, N_rank>& i)
    { return T_op::apply(iter1_(i), iter2_(i),iter3_(i)); }
#endif

    int ascending(int rank)
    {
        return iter1_.ascending(rank);
    }

    int ordering(int rank)
    {
        return iter1_.ordering(rank);
    }

    int lbound(int rank)
    { 
        return iter1_.lbound(rank);
    }

    int ubound(int rank)
    {
        return iter1_.ubound(rank);
    }

    void push(int position)
    { 
        iter1_.push(position); 
        iter2_.push(position);
        iter3_.push(position);
    }

    void pop(int position)
    { 
        iter1_.pop(position); 
        iter2_.pop(position);
        iter3_.pop(position);
    }

    void advance()
    { 
        iter1_.advance(); 
        iter2_.advance();
        iter3_.advance();
    }

    void advance(int n)
    {
        iter1_.advance(n);
        iter2_.advance(n);
        iter3_.advance(n);
    }

    void loadStride(int rank)
    { 
        iter1_.loadStride(rank); 
        iter2_.loadStride(rank);
        iter3_.loadStride(rank);
    }
    
    _bz_bool isUnitStride(int rank) const
    { return iter1_.isUnitStride(rank) && iter2_.isUnitStride(rank) && iter3_.isUnitStride(rank); }

    void advanceUnitStride()
    { 
        iter1_.advanceUnitStride(); 
        iter2_.advanceUnitStride();
        iter3_.advanceUnitStride();
    }

    _bz_bool canCollapse(int outerLoopRank, int innerLoopRank) const
    { 
        // BZ_DEBUG_MESSAGE("_bz_ArrayExprTernaryOp<>::canCollapse");
        return iter1_.canCollapse(outerLoopRank, innerLoopRank)
            && iter2_.canCollapse(outerLoopRank, innerLoopRank)
            && iter3_.canCollapse(outerLoopRank, innerLoopRank);
    } 

    T_numtype operator[](int i)
    { return T_op::apply(iter1_[i], iter2_[i],iter3_[i]); }

    T_numtype fastRead(int i)
    { return T_op::apply(iter1_.fastRead(i), iter2_.fastRead(i),iter3_.fastRead(i)); }

    int suggestStride(int rank) const
    {
        int stride1 = iter1_.suggestStride(rank);
        int stride2 = iter2_.suggestStride(rank);
        int stride3 = iter2_.suggestStride(rank);
        if (stride1> stride2)
            if(stride1 > stride3) 
                return stride1;
            else 
                return stride3;
        else if (stride2 > stride3) 
                return stride2;
            else 
                return stride3;
//         return (stride1 > stride2) ? stride1 : stride2;
    }

    _bz_bool isStride(int rank, int stride) const
    {
        return iter1_.isStride(rank,stride) && iter2_.isStride(rank,stride) && iter2_.isStride(rank,stride);
    }

    template<int N_rank>
    void moveTo(const TinyVector<int,N_rank>& i)
    {
        iter1_.moveTo(i);
        iter2_.moveTo(i);
        iter3_.moveTo(i);
    }

    void prettyPrint(string& str, prettyPrintFormat& format) const
    {
        T_op::prettyPrint(str, format, iter1_, iter2_,iter3_);
    }

    template<class T_shape>
    _bz_bool shapeCheck(const T_shape& shape)
    { return iter1_.shapeCheck(shape) && iter2_.shapeCheck(shape) && iter2_.shapeCheck(shape); }

protected:
    _bz_ArrayExprTernaryOp() { }

    T_expr1 iter1_;
    T_expr2 iter2_; 
    T_expr3 iter3_; 
};


template <template <typename T1,typename T2, typename T3> class OP,typename O1,typename O2, typename O3>
struct BzTernaryExprResult {
    typedef _bz_ArrayExpr<
                _bz_ArrayExprTernaryOp<
                                typename asExpr<O1>::T_expr,
                                typename asExpr<O2>::T_expr,
                                typename asExpr<O3>::T_expr,
                                OP<typename asExpr<O1>::T_expr::T_numtype,
                                   typename asExpr<O2>::T_expr::T_numtype,
                                   typename asExpr<O3>::T_expr::T_numtype > > > T_result;
};

/*
 * Array expression templates: the macro BZ_DECLARE_ARRAY_ET_BINARY(X,Y)
 * declares a function or operator which takes two operands.
 * X is the function name (or operator), and Y is the functor object
 * which implements the operation.
 */

#define BZ_DECLARE_ARRAY_ET_TERNARY(name, applic)                                \
                                                                                 \
template <typename T_numtype1,int N_rank1,typename T_other1, typename T_other2>  \
_bz_inline_et                                                                    \
typename BzTernaryExprResult<applic,Array<T_numtype1,N_rank1>,T_other1,T_other2>::T_result  \
name (const Array<T_numtype1,N_rank1>& d1, const T_other1& d2, const T_other2& d3) \
{                                                                                \
    typedef typename BzTernaryExprResult<applic,                                 \
                                  Array<T_numtype1,N_rank1>,                     \
                                  T_other1,                                      \
                                  T_other2>::T_result         result;            \
    return result(d1.beginFast(),d2,d3);                                         \
}                                                                                \
                                                                                 \
template <typename T_expr1,typename T_other1, typename T_other2>                 \
_bz_inline_et                                                                    \
typename BzTernaryExprResult<applic,_bz_ArrayExpr<T_expr1>,T_other1,T_other2>::T_result     \
name(const _bz_ArrayExpr<T_expr1>& d1, const T_other1& d2,const T_other2& d3)    \
{                                                                                \
    typedef typename BzTernaryExprResult<applic,                                 \
                                  _bz_ArrayExpr<T_expr1>,                        \
                                  T_other1,                                      \
                                  T_other2>::T_result         result;            \
    return result(d1,d2,d3);                                                     \
}                                                                                \
                                                                                 \
template <typename T1,typename T2,typename T3>                                   \
_bz_inline_et                                                                    \
typename BzTernaryExprResult<applic,ETBase<T1>,T2, T3>::T_result                 \
name(const ETBase<T1>& d1, const T2& d2, const T3& d3 )                          \
{                                                                                \
    typedef typename BzTernaryExprResult<applic,ETBase<T1>,T2, T3>::T_result result; \
    return result(static_cast<const T1&>(d1),d2,d3);                             \
}                                                                                \
                                                                                 \
template <typename T1,typename T2,typename T3>                                   \
_bz_inline_et                                                                    \
typename BzTernaryExprResult<applic,ETBase<T1>,T2, T3>::T_result                 \
name(const T1& d1, const ETBase<T2>& d2, const T3& d3 )                          \
{                                                                                \
    typedef typename BzTernaryExprResult<applic,T1,ETBase<T2>, T3>::T_result result; \
    return result(static_cast<const T1&>(d1),d2,d3);                             \
}                                                                                \
                                                                                 \
template <typename T1,typename T2,typename T3>                                   \
_bz_inline_et                                                                    \
typename BzTernaryExprResult<applic,ETBase<T1>,T2, T3>::T_result                 \
name(const T1& d1, const T2& d2, const ETBase<T3>& d3 )                          \
{                                                                                \
    typedef typename BzTernaryExprResult<applic,T1,T2, ETBase<T3> >::T_result result; \
    return result(static_cast<const T1&>(d1),d2,d3);                             \
}                                                                                \
                                                                                 \
template <int N1,typename T_other1, typename T_other2>                           \
_bz_inline_et                                                                    \
typename BzTernaryExprResult<applic,IndexPlaceholder<N1>,T_other1,T_other2>::T_result       \
name(IndexPlaceholder<N1> d1, const T_other1& d2, const T_other2& d3)            \
{                                                                                \
    typedef typename BzTernaryExprResult<applic,                                 \
                                  IndexPlaceholder<N1>,                          \
                                  T_other1,                                      \
                                  T_other2>::T_result    result;                 \
    return result(d1,d2,d3);                                                     \
}

#define BZ_DECLARE_FUNCTION3(name)                                                               \
    template <typename P_numtype1,typename P_numtype2, typename P_numtype3>                      \
    struct name ## _impl {                                                                       \
        typedef BZ_PROMOTE(P_numtype1,BZ_PROMOTE(P_numtype2,P_numtype3)) T_numtype;              \
                                                                                                 \
        static inline T_numtype                                                                  \
        apply(P_numtype1 x,P_numtype2 y, P_numtype3 z) {                                         \
            return static_cast<T_numtype>(name(x,y,z));                                          \
        }                                                                                        \
                                                                                                 \
        template <typename T1,typename T2, typename T3>                                          \
        static void prettyPrint(string& str,prettyPrintFormat& format,const T1& a,const T2& b,   \
                                const T3& c ) {                                                  \
            str += #name;                                                                        \
            str += "(";                                                                          \
            a.prettyPrint(str,format);                                                           \
            str += ",";                                                                          \
            b.prettyPrint(str,format);                                                           \
            str += ",";                                                                          \
            c.prettyPrint(str,format);                                                           \
            str += ")";                                                                          \
        }                                                                                        \
    };                                                                                           \
    BZ_DECLARE_ARRAY_ET_TERNARY(name, name ## _impl)
                                                                                                 
#define BZ_DECLARE_FUNCTION3_RET(name, return_type)                                              \
    template <typename P_numtype1,typename P_numtype2, typename P_numtype3>                      \
    struct name ## _impl {                                                                       \
        typedef return_type T_numtype;                                                           \
                                                                                                 \
        static inline T_numtype apply(P_numtype1 x,P_numtype2 y, P_numtype3 z) {                 \
            return name(x,y,z);                                                                  \
        }                                                                                        \
                                                                                                 \
        template <typename T1,typename T2, typename T3>                                          \
        static void prettyPrint(string& str,prettyPrintFormat& format,const T1& a,const T2& b,   \
                                const T3& c ) {                                                  \
            str += #name;                                                                        \
            str += "(";                                                                          \
            a.prettyPrint(str,format);                                                           \
            str += ",";                                                                          \
            b.prettyPrint(str,format);                                                           \
            str += ",";                                                                          \
            c.prettyPrint(str,format);                                                           \
            str += ")";                                                                          \
        }                                                                                        \
    };                                                                                           \
                                                                                                 \
  BZ_DECLARE_ARRAY_ET_TERNARY(name, name ## _impl)


BZ_NAMESPACE_END

#endif // BZ_ARRAYTERNARYEXPR_H