source: Sophya/trunk/Poubelle/DPC:FitsIOServer/Blitz/blitz/indexexpr.h@ 1420

/***************************************************************************
 * blitz/indexexpr.h     Declaration of the IndexPlaceholder<N> class
 *
 * $Id: indexexpr.h,v 1.1.1.1 1999-11-26 16:37:03 ansari Exp $
 *
 * Copyright (C) 1997,1998 Todd Veldhuizen <tveldhui@seurat.uwaterloo.ca>
 *
 * 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-suggest@cybervision.com
 * Bugs:                 blitz-bugs@cybervision.com
 *
 * For more information, please see the Blitz++ Home Page:
 *    p://seurat.uhttwaterloo.ca/blitz/
 *
 ***************************************************************************
 * $Log: not supported by cvs2svn $
 * Revision 1.1.1.1  1999/04/09  17:59:02  ansari
 * Creation module DPC/Blitz (blitz 0.4) Reza 09/04/99
 *
 * Revision 1.2  1998/03/14 00:04:47  tveldhui
 * 0.2-alpha-05
 *
 * Revision 1.1  1997/07/16 14:51:20  tveldhui
 * Update: Alpha release 0.2 (Arrays)
 *
 */

#ifndef BZ_INDEXEXPR_H
#define BZ_INDEXEXPR_H

#ifndef BZ_TINYVEC_H
 #include <blitz/tinyvec.h>
#endif

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

BZ_NAMESPACE(blitz)

template<int N>
class IndexPlaceholder {
public:
    IndexPlaceholder()
    { }

    IndexPlaceholder(const IndexPlaceholder<N>&)
    { }

    ~IndexPlaceholder()
    { }

    void operator=(const IndexPlaceholder<N>&)
    { }

    typedef int T_numtype;
    typedef int T_ctorArg1;     // Dummy; not used
    typedef int T_ctorArg2;     // Ditto

    enum { numArrayOperands = 0, numIndexPlaceholders = 1,
        rank = N+1 };

    // If you have a precondition failure on this routine, it means
    // you are trying to use stack iteration mode on an expression
    // which contains an index placeholder.  You must use index 
    // iteration mode instead.
    int operator*()
    { 
        BZPRECONDITION(0); 
        return 0;
    }

#ifdef BZ_ARRAY_EXPR_PASS_INDEX_BY_VALUE
    template<int N_rank>
    T_numtype operator()(TinyVector<int, N_rank> i)
    { return i[N]; }
#else
    template<int N_rank>
    T_numtype operator()(const TinyVector<int, N_rank>& i)
    { return i[N]; }
#endif

    int lbound(int) const
    { return INT_MIN; }   // tiny(int());

    int ubound(int) const
    { return INT_MAX; }  // huge(int()); 

    // See operator*() note
    void push(int)
    { 
        BZPRECONDITION(0); 
    }

    // See operator*() note
    void pop(int)
    { 
        BZPRECONDITION(0); 
    }

    // See operator*() note
    void advance()
    { 
        BZPRECONDITION(0); 
    }

    // See operator*() note
    void advance(int)
    { 
        BZPRECONDITION(0); 
    }

    // See operator*() note
    void loadStride(int)
    { 
        BZPRECONDITION(0); 
    }

    _bz_bool isUnitStride(int rank) const
    { 
        BZPRECONDITION(0);
        return false;
    }

    void advanceUnitStride()
    { 
        BZPRECONDITION(0);
    }

    _bz_bool canCollapse(int,int) const
    {   
        BZPRECONDITION(0); 
        return _bz_false; 
    }

    T_numtype operator[](int)
    {
        BZPRECONDITION(0);
        return T_numtype();
    }

    T_numtype fastRead(int)
    {
        BZPRECONDITION(0);
        return T_numtype();
    }

    int suggestStride(int) const
    {
        BZPRECONDITION(0);
        return 0;
    }

    _bz_bool isStride(int,int) const
    {
        BZPRECONDITION(0);
        return _bz_true;
    }

    void prettyPrint(string& str, prettyPrintFormat& format) const
    {
        // NEEDS_WORK-- do real formatting for reductions
        str += "index-expr[NEEDS_WORK]";
    }

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

typedef IndexPlaceholder<0> firstIndex;
typedef IndexPlaceholder<1> secondIndex;
typedef IndexPlaceholder<2> thirdIndex;
typedef IndexPlaceholder<3> fourthIndex;
typedef IndexPlaceholder<4> fifthIndex;
typedef IndexPlaceholder<5> sixthIndex;
typedef IndexPlaceholder<6> seventhIndex;
typedef IndexPlaceholder<7> eighthIndex;
typedef IndexPlaceholder<8> ninthIndex;
typedef IndexPlaceholder<9> tenthIndex;
typedef IndexPlaceholder<10> eleventhIndex;

#ifndef BZ_NO_TENSOR_INDEX_OBJECTS

BZ_NAMESPACE(tensor)
    _bz_global IndexPlaceholder<0> i;
    _bz_global IndexPlaceholder<1> j;
    _bz_global IndexPlaceholder<2> k;
    _bz_global IndexPlaceholder<3> l;
    _bz_global IndexPlaceholder<4> m;
    _bz_global IndexPlaceholder<5> n;
    _bz_global IndexPlaceholder<6> o;
    _bz_global IndexPlaceholder<7> p;
    _bz_global IndexPlaceholder<8> q;
    _bz_global IndexPlaceholder<9> r;
    _bz_global IndexPlaceholder<10> s;
    _bz_global IndexPlaceholder<11> t;
BZ_NAMESPACE_END // tensor

#endif

BZ_NAMESPACE_END

#endif // BZ_INDEXEXPR_H