[2b666a]: blitz / indexexpr.h Maximize Restore History

Download this file

indexexpr.h    176 lines (145 with data), 5.0 kB

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
// -*- C++ -*-
/***************************************************************************
* blitz/indexexpr.h Declaration of the IndexPlaceholder<N> class
*
* $Id$
*
* 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:
* p://seurat.uhttwaterloo.ca/blitz/
*
***************************************************************************/
#ifndef BZ_INDEXEXPR_H
#define BZ_INDEXEXPR_H
#include <blitz/tinyvec.h>
#include <blitz/prettyprint.h>
#include <blitz/etbase.h>
BZ_NAMESPACE(blitz)
template<int N>
class IndexPlaceholder
#ifdef BZ_NEW_EXPRESSION_TEMPLATES
: public ETBase<IndexPlaceholder<N> >
#endif
{
public:
IndexPlaceholder()
{ }
#ifdef BZ_NEW_EXPRESSION_TEMPLATES
IndexPlaceholder(const IndexPlaceholder<N>& x)
: ETBase< IndexPlaceholder<N> >(x)
{ }
#else
IndexPlaceholder(const IndexPlaceholder<N>&)
{ }
#endif
~IndexPlaceholder()
{ }
void operator=(const IndexPlaceholder<N>&)
{ }
typedef int T_numtype;
typedef int T_ctorArg1; // Dummy; not used
typedef int T_ctorArg2; // Ditto
static const int
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 ascending(int) const { return INT_MIN; }
int ordering(int) const { return INT_MIN; }
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); }
void pop(int) { BZPRECONDITION(0); }
void advance() { BZPRECONDITION(0); }
void advance(int) { BZPRECONDITION(0); }
void loadStride(int) { BZPRECONDITION(0); }
bool isUnitStride(int) const {
BZPRECONDITION(0);
return false;
}
void advanceUnitStride() { BZPRECONDITION(0); }
bool canCollapse(int,int) const {
BZPRECONDITION(0);
return false;
}
T_numtype operator[](int) {
BZPRECONDITION(0);
return T_numtype();
}
T_numtype fastRead(int) {
BZPRECONDITION(0);
return T_numtype();
}
diffType suggestStride(int) const {
BZPRECONDITION(0);
return 0;
}
bool isStride(int,diffType) const {
BZPRECONDITION(0);
return true;
}
void prettyPrint(BZ_STD_SCOPE(string) &str, prettyPrintFormat&) const {
// NEEDS_WORK-- do real formatting for reductions
str += "index-expr[NEEDS_WORK]";
}
template<typename T_shape>
bool shapeCheck(const T_shape&) const { return 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 blitz::IndexPlaceholder<0> i;
_bz_global blitz::IndexPlaceholder<1> j;
_bz_global blitz::IndexPlaceholder<2> k;
_bz_global blitz::IndexPlaceholder<3> l;
_bz_global blitz::IndexPlaceholder<4> m;
_bz_global blitz::IndexPlaceholder<5> n;
_bz_global blitz::IndexPlaceholder<6> o;
_bz_global blitz::IndexPlaceholder<7> p;
_bz_global blitz::IndexPlaceholder<8> q;
_bz_global blitz::IndexPlaceholder<9> r;
_bz_global blitz::IndexPlaceholder<10> s;
_bz_global blitz::IndexPlaceholder<11> t;
BZ_NAMESPACE_END // tensor
#endif
BZ_NAMESPACE_END
#endif // BZ_INDEXEXPR_H