blitz Version 0.9
blitz/tinyvec.h
Go to the documentation of this file.
00001 // -*- C++ -*-
00002 /***************************************************************************
00003  * blitz/tinyvec.h      Declaration of the TinyVector<T, N> class
00004  *
00005  * $Id: tinyvec.h,v 1.9 2005/10/06 23:23:40 julianc Exp $
00006  *
00007  * Copyright (C) 1997-2001 Todd Veldhuizen <tveldhui@oonumerics.org>
00008  *
00009  * This program is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU General Public License
00011  * as published by the Free Software Foundation; either version 2
00012  * of the License, or (at your option) any later version.
00013  *
00014  * This program is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017  * GNU General Public License for more details.
00018  *
00019  * Suggestions:          blitz-dev@oonumerics.org
00020  * Bugs:                 blitz-bugs@oonumerics.org
00021  *
00022  * For more information, please see the Blitz++ Home Page:
00023  *    http://oonumerics.org/blitz/
00024  *
00025  ***************************************************************************/
00026 
00027 #ifndef BZ_TINYVEC_H
00028 #define BZ_TINYVEC_H
00029 
00030 #include <blitz/blitz.h>
00031 #include <blitz/range.h>
00032 #include <blitz/listinit.h>
00033 #include <blitz/tiny.h>
00034 
00035 BZ_NAMESPACE(blitz)
00036 
00037 /*****************************************************************************
00038  * Forward declarations
00039  */
00040 
00041 template<typename P_numtype, int N_length, int N_stride BZ_TEMPLATE_DEFAULT(1) >
00042 class TinyVectorIter;
00043 
00044 template<typename P_numtype, int N_length, int N_stride BZ_TEMPLATE_DEFAULT(1) >
00045 class TinyVectorIterConst;
00046 
00047 template<typename P_numtype>
00048 class Vector;
00049 
00050 template<typename P_expr>
00051 class _bz_VecExpr;
00052 
00053 template<typename P_distribution>
00054 class Random;
00055 
00056 template<typename P_numtype>
00057 class VectorPick;
00058 
00059 template<typename T_numtype1, typename T_numtype2, int N_rows, int N_columns,
00060     int N_vecStride>
00061 class _bz_matrixVectorProduct;
00062 
00063 
00064 
00065 /*****************************************************************************
00066  * Declaration of class TinyVector
00067  */
00068 
00069 template<typename P_numtype, int N_length>
00070 class TinyVector {
00071 public:
00072 
00074     // Public Types
00076 
00077     typedef P_numtype                                    T_numtype;
00078     typedef TinyVector<T_numtype,N_length>               T_vector;
00079     typedef TinyVectorIter<T_numtype,N_length,1>         T_iterator;
00080     typedef TinyVectorIterConst<T_numtype,N_length,1>    T_constIterator;
00081     typedef T_numtype*                                   iterator;
00082     typedef const T_numtype*                             const_iterator;
00083     enum { numElements = N_length };
00084 
00085     TinyVector()  { }
00086     ~TinyVector() { }
00087 
00088     inline TinyVector(const TinyVector<T_numtype,N_length>& x);
00089 
00090     template <typename T_numtype2>
00091     inline TinyVector(const TinyVector<T_numtype2,N_length>& x);
00092 
00093     inline TinyVector(const T_numtype initValue);
00094 
00095     inline TinyVector(const T_numtype x[]) {
00096         memcpy(data_,x,N_length*sizeof(T_numtype));
00097     }
00098 
00099     TinyVector(T_numtype x0, T_numtype x1)
00100     {
00101         data_[0] = x0;
00102         data_[1] = x1;
00103     }
00104 
00105     TinyVector(T_numtype x0, T_numtype x1, T_numtype x2)
00106     {
00107         data_[0] = x0;
00108         data_[1] = x1;
00109         data_[2] = x2;
00110     }
00111 
00112     TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
00113         T_numtype x3)
00114     {
00115         data_[0] = x0;
00116         data_[1] = x1;
00117         data_[2] = x2;
00118         data_[3] = x3;
00119     }
00120 
00121     TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
00122         T_numtype x3, T_numtype x4)
00123     {
00124         data_[0] = x0;
00125         data_[1] = x1;
00126         data_[2] = x2;
00127         data_[3] = x3;
00128         data_[4] = x4;
00129     }
00130 
00131     TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
00132         T_numtype x3, T_numtype x4, T_numtype x5)
00133     {
00134         data_[0] = x0;
00135         data_[1] = x1;
00136         data_[2] = x2;
00137         data_[3] = x3;
00138         data_[4] = x4;
00139         data_[5] = x5;
00140     }
00141 
00142     TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
00143         T_numtype x3, T_numtype x4, T_numtype x5, T_numtype x6)
00144     {
00145         data_[0] = x0;
00146         data_[1] = x1;
00147         data_[2] = x2;
00148         data_[3] = x3;
00149         data_[4] = x4;
00150         data_[5] = x5;
00151         data_[6] = x6;
00152     }
00153 
00154     TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
00155         T_numtype x3, T_numtype x4, T_numtype x5, T_numtype x6,
00156         T_numtype x7)
00157     {
00158         data_[0] = x0;
00159         data_[1] = x1;
00160         data_[2] = x2;
00161         data_[3] = x3;
00162         data_[4] = x4;
00163         data_[5] = x5;
00164         data_[6] = x6;
00165         data_[7] = x7;
00166     }
00167 
00168     TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
00169         T_numtype x3, T_numtype x4, T_numtype x5, T_numtype x6,
00170         T_numtype x7, T_numtype x8)
00171     {
00172         data_[0] = x0;
00173         data_[1] = x1;
00174         data_[2] = x2;
00175         data_[3] = x3;
00176         data_[4] = x4;
00177         data_[5] = x5;
00178         data_[6] = x6;
00179         data_[7] = x7;
00180         data_[8] = x8;
00181     }
00182 
00183     TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
00184         T_numtype x3, T_numtype x4, T_numtype x5, T_numtype x6,
00185         T_numtype x7, T_numtype x8, T_numtype x9)
00186     {
00187         data_[0] = x0;
00188         data_[1] = x1;
00189         data_[2] = x2;
00190         data_[3] = x3;
00191         data_[4] = x4;
00192         data_[5] = x5;
00193         data_[6] = x6;
00194         data_[7] = x7;
00195         data_[8] = x8;
00196         data_[9] = x9;
00197     }
00198 
00199     TinyVector(T_numtype x0, T_numtype x1, T_numtype x2,
00200         T_numtype x3, T_numtype x4, T_numtype x5, T_numtype x6,
00201         T_numtype x7, T_numtype x8, T_numtype x9, T_numtype x10)
00202     {
00203         data_[0] = x0;
00204         data_[1] = x1;
00205         data_[2] = x2;
00206         data_[3] = x3;
00207         data_[4] = x4;
00208         data_[5] = x5;
00209         data_[6] = x6;
00210         data_[7] = x7;
00211         data_[8] = x8;
00212         data_[9] = x9;
00213         data_[10] = x10;
00214     }
00215 
00216     // Constructor added by Peter Nordlund
00217     template<typename P_expr>
00218     inline TinyVector(_bz_VecExpr<P_expr> expr);
00219 
00220     T_iterator      beginFast()       { return T_iterator(*this);      }
00221     T_constIterator beginFast() const { return T_constIterator(*this); }
00222 
00223     iterator       begin()       { return data_; }
00224     const_iterator begin() const { return data_; }
00225 
00226     iterator       end()       { return data_ + N_length; }
00227     const_iterator end() const { return data_ + N_length; }
00228 
00229     T_numtype * restrict data()
00230     { return data_; }
00231 
00232     const T_numtype * restrict data() const
00233     { return data_; }
00234 
00235     T_numtype * restrict dataFirst()
00236     { return data_; }
00237 
00238     const T_numtype * restrict dataFirst() const
00239     { return data_; }
00240 
00241     unsigned length() const
00242     { return N_length; }
00243 
00245     // Library-internal member functions
00246     // These are undocumented and may change or
00247     // disappear in future releases.
00249 
00250     unsigned _bz_suggestLength() const
00251     { return N_length; }
00252 
00253     bool _bz_hasFastAccess() const
00254     { return true; }
00255 
00256     T_numtype& restrict _bz_fastAccess(unsigned i)
00257     { return data_[i]; }
00258 
00259     T_numtype _bz_fastAccess(unsigned i) const
00260     { return data_[i]; }
00261 
00262     template<typename P_expr, typename P_updater>
00263     void _bz_assign(P_expr, P_updater);
00264 
00265     _bz_VecExpr<T_constIterator> _bz_asVecExpr() const
00266     { return _bz_VecExpr<T_constIterator>(beginFast()); }
00267    
00269     // Subscripting operators
00271 
00272     bool lengthCheck(unsigned i) const
00273     {
00274         BZPRECHECK(i < N_length, 
00275             "TinyVector<" << BZ_DEBUG_TEMPLATE_AS_STRING_LITERAL(T_numtype) 
00276             << "," << N_length << "> index out of bounds: " << i);
00277         return true;
00278     }
00279 
00280     const T_numtype& operator()(unsigned i) const
00281     {
00282         BZPRECONDITION(lengthCheck(i));
00283         return data_[i];
00284     }
00285 
00286     T_numtype& restrict operator()(unsigned i)
00287     { 
00288         BZPRECONDITION(lengthCheck(i));
00289         return data_[i];
00290     }
00291 
00292     const T_numtype& operator[](unsigned i) const
00293     {
00294         BZPRECONDITION(lengthCheck(i));
00295         return data_[i];
00296     }
00297 
00298     T_numtype& restrict operator[](unsigned i)
00299     {
00300         BZPRECONDITION(lengthCheck(i));
00301         return data_[i];
00302     }
00303 
00305     // Assignment operators
00307 
00308     // Scalar operand
00309     ListInitializationSwitch<T_vector,T_numtype*> operator=(T_numtype x)
00310     {
00311         return ListInitializationSwitch<T_vector,T_numtype*>(*this, x);
00312     }
00313 
00314     T_vector& initialize(const T_numtype);
00315     T_vector& operator+=(const T_numtype);
00316     T_vector& operator-=(const T_numtype);
00317     T_vector& operator*=(const T_numtype);
00318     T_vector& operator/=(const T_numtype);
00319     T_vector& operator%=(const T_numtype);
00320     T_vector& operator^=(const T_numtype);
00321     T_vector& operator&=(const T_numtype);
00322     T_vector& operator|=(const T_numtype);
00323     T_vector& operator>>=(const int);
00324     T_vector& operator<<=(const int);
00325 
00326     template<typename P_numtype2> 
00327     T_vector& operator=(const TinyVector<P_numtype2, N_length> &);
00328     template<typename P_numtype2>
00329     T_vector& operator+=(const TinyVector<P_numtype2, N_length> &);
00330     template<typename P_numtype2>
00331     T_vector& operator-=(const TinyVector<P_numtype2, N_length> &);
00332     template<typename P_numtype2>
00333     T_vector& operator*=(const TinyVector<P_numtype2, N_length> &);
00334     template<typename P_numtype2>
00335     T_vector& operator/=(const TinyVector<P_numtype2, N_length> &);
00336     template<typename P_numtype2>
00337     T_vector& operator%=(const TinyVector<P_numtype2, N_length> &);
00338     template<typename P_numtype2>
00339     T_vector& operator^=(const TinyVector<P_numtype2, N_length> &);
00340     template<typename P_numtype2>
00341     T_vector& operator&=(const TinyVector<P_numtype2, N_length> &);
00342     template<typename P_numtype2>
00343     T_vector& operator|=(const TinyVector<P_numtype2, N_length> &);
00344     template<typename P_numtype2>
00345     T_vector& operator>>=(const TinyVector<P_numtype2, N_length> &);
00346     template<typename P_numtype2>
00347     T_vector& operator<<=(const TinyVector<P_numtype2, N_length> &);
00348 
00349     template<typename P_numtype2> T_vector& operator=(const Vector<P_numtype2> &);
00350     template<typename P_numtype2> T_vector& operator+=(const Vector<P_numtype2> &);
00351     template<typename P_numtype2> T_vector& operator-=(const Vector<P_numtype2> &);
00352     template<typename P_numtype2> T_vector& operator*=(const Vector<P_numtype2> &);
00353     template<typename P_numtype2> T_vector& operator/=(const Vector<P_numtype2> &);
00354     template<typename P_numtype2> T_vector& operator%=(const Vector<P_numtype2> &);
00355     template<typename P_numtype2> T_vector& operator^=(const Vector<P_numtype2> &);
00356     template<typename P_numtype2> T_vector& operator&=(const Vector<P_numtype2> &);
00357     template<typename P_numtype2> T_vector& operator|=(const Vector<P_numtype2> &);
00358     template<typename P_numtype2> T_vector& operator>>=(const Vector<P_numtype2> &);
00359     template<typename P_numtype2> T_vector& operator<<=(const Vector<P_numtype2> &);
00360 
00361     // Vector expression operand
00362     template<typename P_expr> T_vector& operator=(_bz_VecExpr<P_expr>);
00363     template<typename P_expr> T_vector& operator+=(_bz_VecExpr<P_expr>);
00364     template<typename P_expr> T_vector& operator-=(_bz_VecExpr<P_expr>);
00365     template<typename P_expr> T_vector& operator*=(_bz_VecExpr<P_expr>);
00366     template<typename P_expr> T_vector& operator/=(_bz_VecExpr<P_expr>);
00367     template<typename P_expr> T_vector& operator%=(_bz_VecExpr<P_expr>);
00368     template<typename P_expr> T_vector& operator^=(_bz_VecExpr<P_expr>);
00369     template<typename P_expr> T_vector& operator&=(_bz_VecExpr<P_expr>);
00370     template<typename P_expr> T_vector& operator|=(_bz_VecExpr<P_expr>);
00371     template<typename P_expr> T_vector& operator>>=(_bz_VecExpr<P_expr>);
00372     template<typename P_expr> T_vector& operator<<=(_bz_VecExpr<P_expr>);
00373 
00374     // VectorPick operand
00375     template<typename P_numtype2>
00376     T_vector& operator=(const VectorPick<P_numtype2> &);
00377     template<typename P_numtype2>
00378     T_vector& operator+=(const VectorPick<P_numtype2> &);
00379     template<typename P_numtype2>
00380     T_vector& operator-=(const VectorPick<P_numtype2> &);
00381     template<typename P_numtype2>
00382     T_vector& operator*=(const VectorPick<P_numtype2> &);
00383     template<typename P_numtype2>
00384     T_vector& operator/=(const VectorPick<P_numtype2> &);
00385     template<typename P_numtype2>
00386     T_vector& operator%=(const VectorPick<P_numtype2> &);
00387     template<typename P_numtype2>
00388     T_vector& operator^=(const VectorPick<P_numtype2> &);
00389     template<typename P_numtype2>
00390     T_vector& operator&=(const VectorPick<P_numtype2> &);
00391     template<typename P_numtype2>
00392     T_vector& operator|=(const VectorPick<P_numtype2> &);
00393     template<typename P_numtype2>
00394     T_vector& operator>>=(const VectorPick<P_numtype2> &);
00395     template<typename P_numtype2>
00396     T_vector& operator<<=(const VectorPick<P_numtype2> &);
00397 
00398     // Range operand
00399     T_vector& operator=(const Range&);
00400     T_vector& operator+=(const Range&);
00401     T_vector& operator-=(const Range&);
00402     T_vector& operator*=(const Range&);
00403     T_vector& operator/=(const Range&);
00404     T_vector& operator%=(const Range&);
00405     T_vector& operator^=(const Range&);
00406     T_vector& operator&=(const Range&);
00407     T_vector& operator|=(const Range&);
00408     T_vector& operator>>=(const Range&);
00409     T_vector& operator<<=(const Range&);
00410 
00411     T_numtype* restrict getInitializationIterator()
00412     { return dataFirst(); }
00413 
00414 private:
00415     T_numtype data_[N_length];
00416 };
00417 
00418 
00419 // Specialization for N = 0: KCC is giving some
00420 // peculiar errors, perhaps this will fix.
00421 
00422 template<typename T>
00423 class TinyVector<T,0> {
00424 };
00425 
00426 BZ_NAMESPACE_END
00427 
00428 #include <blitz/tinyveciter.h>  // Iterators
00429 #include <blitz/tvecglobs.h>    // Global functions
00430 #include <blitz/vector.h>       // Expression templates
00431 #include <blitz/tinyvec.cc>     // Member functions
00432 #include <blitz/tinyvecio.cc>   // I/O functions
00433 
00434 #endif // BZ_TINYVEC_H
00435 
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Defines