Expresso: iterator.h Source File

00001 /* -*- c++ -*- */
00002 /*
00003  * Expresso, a C++ Array template class library
00004  * Copyright (C) 1998,2004 Oskar Enoksson (enok@lysator.liu.se)
00005  * 
00006  * This library is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Library General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2 of the License, or (at your option) any later version.
00010  *
00011  * This library is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Library General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Library General Public
00017  * License along with this library; if not, write to the
00018  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00019  * Boston, MA  02111-1307, USA.
00020  */
00021 #ifndef EXPRESSO_ITERATOR_HDR
00022 #define EXPRESSO_ITERATOR_HDR
00023 
00024 #include "promote.h"
00025 
00026 namespace esso {
00027 
00028   template<class Type>
00029   struct Iterator;
00030 
00031   // The general iterator type
00032   template<int N, class Type>
00033   class Array<N,Iterator<Type> > {
00034   public:
00035     typedef typename Array<N,Type>::T T;
00036     typedef Array<N,Iterator<Type> > IteratorType;
00037     enum { hasdata=0 };
00038 
00039     inline IXTYPE L(DIMT i) const { return src.L(i); }
00040     inline IXTYPE U(DIMT i) const { return src.U(i); }
00041     inline IXTYPE Len(DIMT i) const { return U(i)-L(i); }
00042     inline void Step(DIMT n) { origo+=src.Stride(n); }
00043     inline void Step(DIMT n, IXTYPE i) { origo+=src.Stride(n)*i; }
00044     inline T CGet() const { return *origo; }
00045     inline T CGet(IXTYPE i) const { return origo[i*src.Stride(0)]; }
00046     inline T & Get() const { return *origo; }
00047     inline T & Get(IXTYPE i) const { return origo[i*src.Stride(0)]; }
00048 
00049     inline Array(const Array<N,Type> &src0): src(src0), origo(src0.Origo()) {}
00050   private:
00051     const Array<N,Type> & src;
00052     T * origo;
00053   };
00054 
00055   template<class T00>
00056   struct Fix;
00057 
00058   // Specialization of iterator for Fix arrays
00059   template<int N, class T0>
00060   class Array<N,Iterator<Fix<T0> > > {
00061     typedef Fix<T0> Type;
00062   public:
00063     typedef typename Array<N,Type>::T T;
00064     typedef Array<N,Iterator<Type> > IteratorType;
00065     enum { hasdata=0 };
00066 
00067     inline IXTYPE L(int i) const { return src.L(i); }
00068     inline IXTYPE U(int i) const { return src.U(i); }
00069     inline IXTYPE Len(int i) const { return U(i)-L(i); }
00070     inline void Step(int n) { origo+=src.Stride(n); }
00071     inline void Step(int n, IXTYPE i) { origo+=src.Stride(n)*i; }
00072     inline T CGet() const { return *origo; }
00073     inline T CGet(IXTYPE i) const { return origo[i]; }
00074     inline T & Get() const { return *origo; }
00075     inline T & Get(IXTYPE i) const { return origo[i]; }
00076 
00077     inline Array(const Array<N,Type> &src0): src(src0), origo(src0.Origo()) {}
00078   private:
00079     const Array<N,Type> & src;
00080     T * origo;
00081   };
00082 
00083   template<class T00>
00084   class Scalar;
00085 
00086   template<int N, class T0>
00087   class Array<N,Scalar<T0> > {
00088   public:
00089     typedef typename TmplTools::ArrayInfo<T0>::T T;
00090     typedef Array<N,Scalar<T0> > IteratorType;
00091     enum { hasdata=0 };
00092 
00093     inline IXTYPE L(DIMT i) const { return IXTYPE_MIN; }
00094     inline IXTYPE U(DIMT i) const { return IXTYPE_MAX; }
00095     inline IXTYPE Len(DIMT i) const { return U(i)-L(i); }
00096     inline void Step(DIMT n) {}
00097     inline void Step(DIMT n, IXTYPE i) {}
00098     inline T CGet() const { return src; }
00099     inline T CGet(IXTYPE i) const { return src; }
00100 
00101     inline Array(const T &src0): src(src0) {}
00102   private:
00103     const T src;
00104   };
00105 
00106   // Unary operator Type definition
00107   template<class Op, class TypeS>
00108   class Uop;
00109 
00110   template<int N, class Op, class TypeS>
00111   class Array<N,Uop<Op,TypeS> > {
00112   public:
00113     typedef typename UPromote<Op, typename Array<N,TypeS>::T>::T T;
00114     typedef Array<N,Uop<Op,TypeS> > IteratorType;
00115     enum { hasdata=0 };
00116 
00117     inline IXTYPE L(DIMT i) const { return src.L(i); }
00118     inline IXTYPE U(DIMT i) const { return src.U(i); }
00119     inline IXTYPE Len(DIMT i) const { return U(i)-L(i); }
00120     inline void Step(DIMT n) { src.Step(n); }
00121     inline void Step(DIMT n, IXTYPE i) { src.Step(n,i); }
00122     inline T CGet() const { 
00123       return UPromote<Op,typename Array<N,TypeS>::T>::Do(src.CGet()); }
00124     inline T CGet(IXTYPE i) const { 
00125       return UPromote<Op,typename Array<N,TypeS>::T>::Do(src.CGet(i)); }
00126       
00127     inline Array(const Array<N,TypeS> &src0): src(src0) {}
00128   private:
00129     typename Array<N,TypeS>::IteratorType src;
00130   };
00131 
00132   // Binary operator Type definition
00133   template<class Op, class TypeL, class TypeR>
00134   class Bop;
00135 
00136   template<int N, class Op, class TypeL, class TypeR>
00137   class Array<N,Bop<Op,TypeL,TypeR> > {
00138   public:
00139     typedef typename BPromote<Op,typename Array<N,TypeL>::T,
00140                               typename Array<N,TypeR>::T>::T T;
00141     typedef Array<N,Bop<Op,TypeL,TypeR> > IteratorType;
00142     enum { hasdata=0 };
00143 
00144     inline IXTYPE L(DIMT i) const { return std::max(srcl.L(i),srcr.L(i)); }
00145     inline IXTYPE U(DIMT i) const { return std::min(srcl.U(i),srcr.U(i)); }
00146     inline IXTYPE Len(DIMT i) const { return U(i)-L(i); }
00147     inline void Step(DIMT n) { srcl.Step(n); srcr.Step(n); }
00148     inline void Step(DIMT n, IXTYPE i) { srcl.Step(n,i); srcr.Step(n,i); }
00149     inline T CGet() const { 
00150       return BCalculate<Op,
00151         typename Array<N,TypeL>::T,
00152         typename Array<N,TypeR>::T>::Do(srcl.CGet(),srcr.CGet()); 
00153     }
00154     inline T CGet(IXTYPE i) const {
00155       return BCalculate<Op,
00156         typename Array<N,TypeL>::T,
00157         typename Array<N,TypeR>::T>::Do(srcl.CGet(i),srcr.CGet(i));
00158     }
00159 
00160     inline Array(const Array<N,TypeL> &srcl0, const Array<N,TypeR> &srcr0):
00161       srcl(srcl0), srcr(srcr0) {}
00162   private:
00163     typename Array<N,TypeL>::IteratorType srcl;
00164     typename Array<N,TypeR>::IteratorType srcr;
00165   };
00166 
00167   // Reducing operator Type definition  
00168   template<class Op, class TypeS>
00169   class Rop;
00170 
00171   template<int N, class Op, class TypeS>
00172   class Array<N,Rop<Op, TypeS> > {
00173   public:
00174     typedef typename RPromote<Op, typename Array<N+1,TypeS>::T>::T T;
00175     typedef Array<N,Rop<Op,TypeS> > IteratorType;
00176     enum { hasdata=0 };
00177 
00178     inline IXTYPE L(DIMT i) const { return src.L(i+1); }
00179     inline IXTYPE U(DIMT i) const { return src.U(i+1); }
00180     inline IXTYPE Len(DIMT i) const { return src.U(i+1)-src.L(i+1); }
00181     inline void Step(DIMT n) { src.Step(n+1); }
00182     inline void Step(DIMT n, IXTYPE i) { src.Step(n+1,i); }
00183 
00184     inline T CGet() const {
00185       return RPromote<Op,typename Array<N+1,TypeS>::T>::Do(src); }
00186     inline T CGet(IXTYPE i) const {
00187       src.Step(1,i);
00188       T ret=RPromote<Op,typename Array<N+1,TypeS>::T>::Do(src);
00189       src.Step(1,-i);
00190       return ret;
00191     }
00192 
00193     inline Array(const Array<N+1,TypeS> &src0): src(src0) {}
00194   private:
00195     mutable typename Array<N+1,TypeS>::IteratorType src;
00196   };
00197 }
00198 
00199 #endif