00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #ifndef util_SimpleArrayOps_hpp
00025 #define util_SimpleArrayOps_hpp
00026
00027 namespace PHX {
00028
00040 template< unsigned N , typename T > void Copy( T * , const T & );
00041 template< unsigned N , typename T > void Copy( T * , const T * );
00042 template< unsigned N , typename T > void Sum( T * , const T * );
00043 template< unsigned N , typename T > void Sum( T * , const T & , const T * );
00044 template< unsigned N , typename T > void Prod( T * , const T * );
00045 template< unsigned N , typename T > void Min( T * , const T * );
00046 template< unsigned N , typename T > void Max( T * , const T * );
00047
00048 template< unsigned N , typename T > void BitOr( T * , const T * );
00049 template< unsigned N , typename T > void BitAnd( T * , const T * );
00050
00051 template< unsigned N , typename T > T InnerProduct( const T * , const T * );
00052
00053 template< unsigned N , typename T > bool Equal( const T * , const T * );
00054 template< unsigned N , typename T > bool NotEqual( const T * , const T * );
00055 template< unsigned N , typename T > bool Less( const T * , const T * );
00056 template< unsigned N , typename T > bool LessEqual( const T * , const T * );
00057 template< unsigned N , typename T > bool Greater( const T * , const T * );
00058 template< unsigned N , typename T > bool GreaterEqual( const T * , const T * );
00059
00060 }
00061
00062
00063
00064
00065 namespace PHX {
00066 namespace Op {
00067
00068 template< typename T, unsigned n , unsigned i = 0 > struct Copy ;
00069 template< typename T, unsigned n , unsigned i = 0 > struct Sum ;
00070 template< typename T, unsigned n , unsigned i = 0 > struct Prod ;
00071 template< typename T, unsigned n , unsigned i = 0 > struct Max ;
00072 template< typename T, unsigned n , unsigned i = 0 > struct Min ;
00073 template< typename T, unsigned n , unsigned i = 0 > struct BitOr ;
00074 template< typename T, unsigned n , unsigned i = 0 > struct BitAnd ;
00075
00076 template< typename T, unsigned n, unsigned i = 0 > struct InnerProduct ;
00077 template< typename T, unsigned n, unsigned i = 0 > struct Equal ;
00078 template< typename T, unsigned n, unsigned i = 0 > struct NotEqual ;
00079 template< typename T, unsigned n, unsigned i = 0 > struct Less ;
00080 template< typename T, unsigned n, unsigned i = 0 > struct LessEqual ;
00081 template< typename T, unsigned n, unsigned i = 0 > struct Greater ;
00082 template< typename T, unsigned n, unsigned i = 0 > struct GreaterEqual ;
00083
00084
00085
00086
00087 template< typename T , unsigned n >
00088 struct Copy<T,n,n> {
00089 typedef T type ;
00090 enum { N = 0 };
00091 static void op( T * , const T * ) {}
00092 static void op( T * , const T & ) {}
00093
00094 Copy() : ptr(0) {}
00095 Copy( T * p ) : ptr(p) {}
00096 Copy( const Copy & rhs ) : ptr( rhs.ptr ) {}
00097 Copy & operator = ( const Copy & rhs ) { ptr = rhs.ptr ; return *this ; }
00098
00099 T * ptr ;
00100 };
00101
00102 template< typename T , unsigned n >
00103 struct Sum<T,n,n> {
00104 typedef T type ;
00105 enum { N = 0 };
00106 static void op( T * , const T * ) {}
00107 static void op( T * , const T & , const T * ) {}
00108
00109 Sum() : ptr(0) {}
00110 Sum( T * p ) : ptr(p) {}
00111 Sum( const Sum & rhs ) : ptr( rhs.ptr ) {}
00112 Sum & operator = ( const Sum & rhs ) { ptr = rhs.ptr ; return *this ; }
00113
00114 T * ptr ;
00115 };
00116
00117 template< typename T , unsigned n >
00118 struct Prod<T,n,n> {
00119 typedef T type ;
00120 enum { N = 0 };
00121 static void op( T * , const T * ) {}
00122
00123 Prod() : ptr(0) {}
00124 Prod( T * p ) : ptr(p) {}
00125 Prod( const Prod & rhs ) : ptr( rhs.ptr ) {}
00126 Prod & operator = ( const Prod & rhs ) { ptr = rhs.ptr ; return *this ; }
00127
00128 T * ptr ;
00129 };
00130
00131 template< typename T , unsigned n >
00132 struct Max<T,n,n> {
00133 typedef T type ;
00134 enum { N = 0 };
00135 static void op( T * , const T * ) {}
00136
00137 Max() : ptr(0) {}
00138 Max( T * p ) : ptr(p) {}
00139 Max( const Max & rhs ) : ptr( rhs.ptr ) {}
00140 Max & operator = ( const Max & rhs ) { ptr = rhs.ptr ; return *this ; }
00141
00142 T * ptr ;
00143 };
00144
00145 template< typename T , unsigned n >
00146 struct Min<T,n,n> {
00147 typedef T type ;
00148 enum { N = 0 };
00149 static void op( T * , const T * ) {}
00150
00151 Min() : ptr(0) {}
00152 Min( T * p ) : ptr(p) {}
00153 Min( const Min & rhs ) : ptr( rhs.ptr ) {}
00154 Min & operator = ( const Min & rhs ) { ptr = rhs.ptr ; return *this ; }
00155
00156 T * ptr ;
00157 };
00158
00159 template< typename T , unsigned n >
00160 struct BitOr<T,n,n> {
00161 typedef T type ;
00162 enum { N = 0 };
00163 static void op( T * , const T * ) {}
00164
00165 BitOr() : ptr(0) {}
00166 BitOr( T * p ) : ptr(p) {}
00167 BitOr( const BitOr & rhs ) : ptr( rhs.ptr ) {}
00168 BitOr & operator = ( const BitOr & rhs ) { ptr = rhs.ptr ; return *this ; }
00169
00170 T * ptr ;
00171 };
00172
00173 template< typename T , unsigned n >
00174 struct BitAnd<T,n,n> {
00175 typedef T type ;
00176 enum { N = 0 };
00177 static void op( T * , const T * ) {}
00178
00179 BitAnd() : ptr(0) {}
00180 BitAnd( T * p ) : ptr(p) {}
00181 BitAnd( const BitAnd & rhs ) : ptr( rhs.ptr ) {}
00182 BitAnd & operator = ( const BitAnd & rhs ) { ptr = rhs.ptr ; return *this ; }
00183
00184 T * ptr ;
00185 };
00186
00187 template< typename T , unsigned n >
00188 struct Equal<T,n,n> {
00189 static bool op( const T * , const T * ) { return true ; }
00190 };
00191
00192 template< typename T , unsigned n >
00193 struct NotEqual<T,n,n> {
00194 static bool op( const T * , const T * ) { return false ; }
00195 };
00196
00197 template< typename T , unsigned n >
00198 struct InnerProduct<T,n,n> {
00199 static T op( const T * , const T * ) { return 0 ; }
00200 };
00201
00202 template< typename T , unsigned n >
00203 struct Less<T,n,n> {
00204 static bool op( const T * , const T * ) { return false ; }
00205 };
00206
00207 template< typename T , unsigned n >
00208 struct LessEqual<T,n,n> {
00209 static bool op( const T * , const T * ) { return true ; }
00210 };
00211
00212 template< typename T , unsigned n >
00213 struct Greater<T,n,n> {
00214 static bool op( const T * , const T * ) { return false ; }
00215 };
00216
00217 template< typename T , unsigned n >
00218 struct GreaterEqual<T,n,n> {
00219 static bool op( const T * , const T * ) { return true ; }
00220 };
00221
00222
00223
00224 template< typename T , unsigned n , unsigned i >
00225 struct Copy {
00226 typedef T type ;
00227 enum { N = n };
00228
00229 static void op( T * dst , const T * src )
00230 { dst[i] = src[i] ; Op::Copy<T,N,i+1>::op(dst,src); }
00231
00232 static void op( T * dst , const T & src )
00233 { dst[i] = src ; Op::Copy<T,N,i+1>::op(dst,src); }
00234
00235 Copy() : ptr(0) {}
00236 Copy( T * p ) : ptr(p) {}
00237 Copy( const Copy & rhs ) : ptr( rhs.ptr ) {}
00238 Copy & operator = ( const Copy & rhs ) { ptr = rhs.ptr ; return *this ; }
00239
00240 T * ptr ;
00241 };
00242
00243 template< typename T , unsigned n , unsigned i >
00244 struct Sum {
00245 typedef T type ;
00246 enum { N = n };
00247
00248 static void op( T * dst , const T * src )
00249 { dst[i] += src[i] ; Op::Sum<T,N,i+1>::op(dst,src); }
00250
00251 static void op( T * dst , const T & a , const T * src )
00252 { dst[i] += a * src[i] ; Op::Sum<T,N,i+1>::op(dst,a,src); }
00253
00254 Sum() : ptr(0) {}
00255 Sum( T * p ) : ptr(p) {}
00256 Sum( const Sum & rhs ) : ptr( rhs.ptr ) {}
00257 Sum & operator = ( const Sum & rhs ) { ptr = rhs.ptr ; return *this ; }
00258
00259 T * ptr ;
00260 };
00261
00262 template< typename T , unsigned n , unsigned i >
00263 struct Prod {
00264 typedef T type ;
00265 enum { N = n };
00266
00267 static void op( T * dst , const T * src )
00268 { dst[i] *= src[i] ; Op::Prod<T,N,i+1>::op(dst,src); }
00269
00270 Prod() : ptr(0) {}
00271 Prod( T * p ) : ptr(p) {}
00272 Prod( const Prod & rhs ) : ptr( rhs.ptr ) {}
00273 Prod & operator = ( const Prod & rhs ) { ptr = rhs.ptr ; return *this ; }
00274
00275 T * ptr ;
00276 };
00277
00278 template< typename T , unsigned n , unsigned i >
00279 struct BitOr {
00280 typedef T type ;
00281 enum { N = n };
00282
00283 static void op( T * dst , const T * src )
00284 { dst[i] |= src[i] ; Op::BitOr<T,N,i+1>::op(dst,src); }
00285
00286 BitOr() : ptr(0) {}
00287 BitOr( T * p ) : ptr(p) {}
00288 BitOr( const BitOr & rhs ) : ptr( rhs.ptr ) {}
00289 BitOr & operator = ( const BitOr & rhs ) { ptr = rhs.ptr ; return *this ; }
00290
00291 T * ptr ;
00292 };
00293
00294 template< typename T , unsigned n , unsigned i >
00295 struct BitAnd {
00296 typedef T type ;
00297 enum { N = n };
00298
00299 static void op( T * dst , const T * src )
00300 { dst[i] |= src[i] ; Op::BitAnd<T,N,i+1>::op(dst,src); }
00301
00302 BitAnd() : ptr(0) {}
00303 BitAnd( T * p ) : ptr(p) {}
00304 BitAnd( const BitAnd & rhs ) : ptr( rhs.ptr ) {}
00305 BitAnd & operator = ( const BitAnd & rhs ) { ptr = rhs.ptr ; return *this ; }
00306
00307 T * ptr ;
00308 };
00309
00310 template< typename T , unsigned n , unsigned i >
00311 struct Max {
00312 typedef T type ;
00313 enum { N = n };
00314
00315 static void op( T * dst , const T * src )
00316 { if ( dst[i] < src[i] ) { dst[i] = src[i] ; }
00317 Op::Max<T,N,i+1>::op(dst,src); }
00318
00319 Max() : ptr(0) {}
00320 Max( T * p ) : ptr(p) {}
00321 Max( const Max & rhs ) : ptr( rhs.ptr ) {}
00322 Max & operator = ( const Max & rhs ) { ptr = rhs.ptr ; return *this ; }
00323
00324 T * ptr ;
00325 };
00326
00327 template< typename T , unsigned n , unsigned i >
00328 struct Min {
00329 typedef T type ;
00330 enum { N = n };
00331
00332 static void op( T * dst , const T * src )
00333 { if ( src[i] < dst[i] ) { dst[i] = src[i] ; }
00334 Op::Min<T,N,i+1>::op(dst,src); }
00335
00336 Min() : ptr(0) {}
00337 Min( T * p ) : ptr(p) {}
00338 Min( const Min & rhs ) : ptr( rhs.ptr ) {}
00339 Min & operator = ( const Min & rhs ) { ptr = rhs.ptr ; return *this ; }
00340
00341 T * ptr ;
00342 };
00343
00344
00345 template< typename T , unsigned n , unsigned i >
00346 struct InnerProduct {
00347 static T op( const T * x , const T * y )
00348 { return x[i] * y[i] + Op::InnerProduct<T,n,i+1>::op( x , y ); }
00349 };
00350
00351 template< typename T , unsigned n , unsigned i >
00352 struct Equal {
00353 static bool op( const T * x , const T * y )
00354 { return x[i] == y[i] && Op::Equal<T,n,i+1>::op(x,y); }
00355 };
00356
00357 template< typename T , unsigned n , unsigned i >
00358 struct NotEqual {
00359 static bool op( const T * x , const T * y )
00360 { return x[i] != y[i] || Op::NotEqual<T,n,i+1>::op(x,y); }
00361 };
00362
00363 template< typename T , unsigned n , unsigned i >
00364 struct Less {
00365 static bool op( const T * const lhs , const T * const rhs )
00366 { return lhs[i] != rhs[i] ? lhs[i] < rhs[i]
00367 : Op::Less<T,n,i+1>::op(lhs,rhs); }
00368 };
00369
00370 template< typename T , unsigned n , unsigned i >
00371 struct LessEqual {
00372 static bool op( const T * const lhs , const T * const rhs )
00373 { return lhs[i] != rhs[i] ? lhs[i] < rhs[i]
00374 : Op::LessEqual<T,n,i+1>::op(lhs,rhs); }
00375 };
00376
00377 template< typename T , unsigned n , unsigned i >
00378 struct Greater {
00379 static bool op( const T * const lhs , const T * const rhs )
00380 { return lhs[i] != rhs[i] ? lhs[i] > rhs[i]
00381 : Op::Greater<T,n,i+1>::op(lhs,rhs); }
00382 };
00383
00384 template< typename T , unsigned n , unsigned i >
00385 struct GreaterEqual {
00386 static bool op( const T * const lhs , const T * const rhs )
00387 { return lhs[i] != rhs[i] ? lhs[i] > rhs[i]
00388 : Op::GreaterEqual<T,n,i+1>::op(lhs,rhs); }
00389 };
00390
00391 }
00392 }
00393
00394
00395
00396 namespace PHX {
00397
00398 template< unsigned N , typename T >
00399 void Copy( T * dst , const T * src )
00400 { Op::Copy<T,N,0>::op( dst , src ); }
00401
00402 template< unsigned N , typename T >
00403 void Copy( T * dst , const T & src )
00404 { Op::Copy<T,N,0>::op( dst , src ); }
00405
00406 template< unsigned N , typename T >
00407 void Sum( T * dst , const T * src )
00408 { Op::Sum<T,N,0>::op( dst , src ); }
00409
00410 template< unsigned N , typename T >
00411 void Sum( T * dst , const T & a , const T * src )
00412 { Op::Sum<T,N,0>::op( dst , a , src ); }
00413
00414 template< unsigned N , typename T >
00415 void Prod( T * dst , const T * src )
00416 { Op::Prod<T,N,0>::op( dst , src ); }
00417
00418 template< unsigned N , typename T >
00419 void Max( T * dst , const T * src )
00420 { Op::Max<T,N,0>::op( dst , src ); }
00421
00422 template< unsigned N , typename T >
00423 void Min( T * dst , const T * src )
00424 { Op::Min<T,N,0>::op( dst , src ); }
00425
00426 template< unsigned N , typename T >
00427 void BitOr( T * dst , const T * src )
00428 { Op::BitOr<T,N,0>::op( dst , src ); }
00429
00430 template< unsigned N , typename T >
00431 void BitAnd( T * dst , const T * src )
00432 { Op::BitAnd<T,N,0>::op( dst , src ); }
00433
00434
00435
00436 template< unsigned N , typename T >
00437 Op::Copy<T,N> Copy( T * dst )
00438 { return Op::Copy<T,N,0>( dst ); }
00439
00440 template< unsigned N , typename T >
00441 Op::Sum<T,N> Sum( T * dst )
00442 { return Op::Sum<T,N,0>( dst ); }
00443
00444 template< unsigned N , typename T >
00445 Op::Prod<T,N> Prod( T * dst )
00446 { return Op::Prod<T,N,0>( dst ); }
00447
00448 template< unsigned N , typename T >
00449 Op::Max<T,N> Max( T * dst )
00450 { return Op::Max<T,N,0>( dst ); }
00451
00452 template< unsigned N , typename T >
00453 Op::Min<T,N> Min( T * dst )
00454 { return Op::Min<T,N,0>( dst ); }
00455
00456 template< unsigned N , typename T >
00457 Op::BitOr<T,N> BitOr( T * dst )
00458 { return Op::BitOr<T,N,0>( dst ); }
00459
00460 template< unsigned N , typename T >
00461 Op::BitAnd<T,N> BitAnd( T * dst )
00462 { return Op::BitAnd<T,N,0>( dst ); }
00463
00464
00465
00466 template< unsigned N , typename T >
00467 T InnerProduct( const T * x , const T * y )
00468 { return Op::InnerProduct<T,N,0>::op( x , y ); }
00469
00470 template< unsigned N , typename T >
00471 bool Equal( const T * x , const T * y )
00472 { return Op::Equal<T,N,0>::op( x , y ); }
00473
00474 template< unsigned N , typename T >
00475 bool NotEqual( const T * x , const T * y )
00476 { return Op::NotEqual<T,N,0>::op( x , y ); }
00477
00478 template< unsigned N , typename T >
00479 bool Less( const T * x , const T * y )
00480 { return Op::Less<T,N,0>::op( x , y ); }
00481
00482 template< unsigned N , typename T >
00483 bool LessEqual( const T * x , const T * y )
00484 { return Op::LessEqual<T,N,0>::op( x , y ); }
00485
00486 template< unsigned N , typename T >
00487 bool Greater( const T * x , const T * y )
00488 { return Op::Greater<T,N,0>::op( x , y ); }
00489
00490 template< unsigned N , typename T >
00491 bool GreaterEqual( const T * x , const T * y )
00492 { return Op::GreaterEqual<T,N,0>::op( x , y ); }
00493
00494 }
00495
00496
00497
00500 #endif
00501