00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef __loaded__coordinates_h__
00021 #define __loaded__coordinates_h__
00022 using namespace std;
00023 #line 1 "coordinates.h++"
00024 #include <cstdio>
00025
00026
00027
00028 template <int D> class Select;
00029 template <int D> class Size;
00030 template <int D> class From;
00031 template <int D> class To;
00032
00033
00034
00035
00036 #define iterate_dimensions(VAR,LIMIT,BLOCK) \
00037 for(int VAR = LIMIT -1 ; VAR>=0 ; VAR--) {BLOCK;}
00038
00039 #ifdef WINDOWS
00040
00044 # define NO_EMPTY_ARRAYS
00045 #endif
00046
00047 template <int D> class _Coordinate
00048 {
00049 protected:
00050 #ifdef NO_EMPTY_ARRAYS
00051 int coordinate[D+1];
00052 #else
00053 int coordinate[D];
00054 #endif
00055 public:
00056 _Coordinate() {for(int d = 0 ; d < D; d++) coordinate[d]=-1;};
00057 _Coordinate(int x)
00058 {
00059 iterate_dimensions(d,D,coordinate[d]=x);
00060 };
00061 _Coordinate(int x, int y)
00062 {
00063 assert(D==2);
00064 coordinate[0]=x;
00065 coordinate[1]=y;
00066 };
00067 _Coordinate(int x, int y, int z)
00068 {
00069 assert(D==3);
00070 coordinate[0]=x;
00071 coordinate[1]=y;
00072 coordinate[2]=z;
00073 };
00074 _Coordinate(int x, int y, int z, int a)
00075 {
00076 assert(D==4);
00077 coordinate[0]=x;
00078 coordinate[1]=y;
00079 coordinate[2]=z;
00080 coordinate[3]=a;
00081 };
00082 _Coordinate(int x, int y, int z, int a, int b)
00083 {
00084 assert(D==5);
00085 coordinate[0]=x;
00086 coordinate[1]=y;
00087 coordinate[2]=z;
00088 coordinate[3]=a;
00089 coordinate[4]=b;
00090 };
00091 _Coordinate(int x, int y, int z, int a, int b, int c)
00092 {
00093 assert(D==6);
00094 coordinate[0]=x;
00095 coordinate[1]=y;
00096 coordinate[2]=z;
00097 coordinate[3]=a;
00098 coordinate[4]=b;
00099 coordinate[5]=c;
00100 };
00101 bool has(int val) const
00102 {
00103 iterate_dimensions(i,D,
00104 if (coordinate[i]==val) return true;);
00105 return false;
00106 }
00107 void operator =(int val)
00108 {
00109 iterate_dimensions(d,D,coordinate[d]=val);
00110 };
00111 void operator =(const _Coordinate<D>& val)
00112 {
00113 iterate_dimensions(d,D,coordinate[d]=val.coordinate[d]);
00114 };
00115 _Coordinate<D> operator +(const _Coordinate<D>& other) const
00116 {
00117 _Coordinate<D> result; iterate_dimensions(d,D,
00118 result.coordinate[d]=coordinate[d]+other.coordinate[d]);
00119 return result;
00120 };
00121 _Coordinate<D>& operator +=(const _Coordinate<D>& other)
00122 {
00123 iterate_dimensions(d,D,coordinate[d]+=other.coordinate[d]);
00124 return *this;
00125 };
00126 _Coordinate<D> operator -(const _Coordinate<D>& other) const
00127 {
00128 _Coordinate<D> result; iterate_dimensions(d,D,
00129 result.coordinate[d]=coordinate[d]-other.coordinate[d]);
00130 return result;
00131 };
00132 _Coordinate<D>& operator -=(const _Coordinate<D>& other)
00133 {
00134 iterate_dimensions(d,D,coordinate[d]-=other.coordinate[d]);
00135 return *this;
00136 };
00137 bool operator ==(const _Coordinate<D>& other) const
00138 {
00139 iterate_dimensions(d,D,
00140 if (coordinate[d]!=other.coordinate[d]) return false);
00141 return true;
00142 };
00143 bool operator !=(const _Coordinate<D>& other) const
00144 {
00145 iterate_dimensions(d,D,
00146 if (coordinate[d]!=other.coordinate[d]) return true);
00147 return false;
00148 };
00149 int& operator[](int idx)
00150 {
00151 return coordinate[idx];
00152 };
00153 int operator[](int idx) const
00154 {
00155 return coordinate[idx];
00156 };
00157 void print()
00158 {
00159 for(int i = 0 ; i < D ; i ++)
00160 printf("%d ",coordinate[i]);
00161 }
00162 template <int SEL> _Coordinate<SEL> select(const Select<SEL>& sel);
00163 void set(const _Coordinate<D>& s)
00164 {
00165 _Coordinate<D>::operator=(s);
00166 };
00167 template <int BROL>
00168 void set(const _Coordinate<BROL>&)
00169 {
00170 assert(0);
00171 };
00172 };
00173
00174 template <int D>
00175 template <int SEL>
00176 _Coordinate<SEL> _Coordinate<D>::select(const Select<SEL>& sel)
00177 {
00178 _Coordinate<SEL> result;
00179 for(int i = 0 ; i < SEL ; i ++)
00180 result[i]=coordinate[sel[i]];
00181 return result;
00182 }
00183
00184 template <int D> class Select: public _Coordinate<D>
00185 {
00186 public:
00187 Select() : _Coordinate<D>()
00188 {
00189 for(int i = 0 ; i < D ; i++) _Coordinate<D>::coordinate[i]=i;
00190 };
00191 Select(int x) : _Coordinate<D>(x) {assert(D==1);};
00192 Select(int x, int y) : _Coordinate<D>(x,y) {assert(D==2);};
00193 Select(int x, int y, int z) : _Coordinate<D>(x,y,z) {assert(D==3);};
00194 Select(int x, int y, int z, int a) : _Coordinate<D>(x,y,z,a) {assert(D==4);};
00195 };
00196
00197 template <int D> class Delta: public _Coordinate<D>
00198 {
00199 public:
00200 Delta() : _Coordinate<D>(0) {};
00201 };
00202
00203 template <int D> class To: public _Coordinate<D>
00204 {
00205 public:
00206 To(int x) : _Coordinate<D>(x) {};
00207 To(int x, int y) : _Coordinate<D>(x,y) {};
00208 To(int x, int y, int z) : _Coordinate<D>(x,y,z) {};
00209 To(int x, int y, int z, int a) : _Coordinate<D>(x,y,z,a) {};
00210 };
00211
00212 template <int D> class Position: public _Coordinate<D>
00213 {
00214 public:
00215 Position() : _Coordinate<D>(0) {};
00216 Position(int x) : _Coordinate<D>(x) {};
00217 Position(int x, int y) : _Coordinate<D>(x,y) {};
00218 Position(int x, int y, int z) : _Coordinate<D>(x,y,z) {};
00219 Position(int x, int y, int z, int a) : _Coordinate<D>(x,y,z,a) {};
00220 Position<D> operator /(const int div) const
00221 {
00222 Position<D> result; iterate_dimensions(d,D,
00223 result.coordinate[d]=_Coordinate<D>::coordinate[d]/div);
00224 return result;
00225 };
00226 };
00227
00228 template <class T>
00229 T min(T a, T b)
00230 {
00231 if (a<b) return a;
00232 return b;
00233 }
00234
00235 template <int D> class Size: public _Coordinate<D>
00236 {
00237 public:
00238 Size() : _Coordinate<D>(0) {};
00239 Size(int x) : _Coordinate<D>(x) {};
00240 Size(int x, int y) : _Coordinate<D>(x,y) {};
00241 Size(int x, int y, int z) : _Coordinate<D>(x,y,z) {};
00242 Size(int x, int y, int z, int a) : _Coordinate<D>(x,y,z,a) {};
00243 Size(int x, int y, int z, int a, int b) : _Coordinate<D>(x,y,z,a,b) {};
00244 Size(int x, int y, int z, int a, int b, int c) : _Coordinate<D>(x,y,z,a,b,c)
00245 {
00246 };
00247
00252 void operator()(const From<D>& pos)
00253 {
00254 for(int i = 0 ; i < D ; i++)
00255 {
00256 int ws = _Coordinate<D>::coordinate[i];
00257 ws -= pos[i];
00258 if(ws<0) ws=0;
00259 _Coordinate<D>::coordinate[i]=ws;
00260 }
00261 }
00262
00266 void min(const Size<D> & o)
00267 {
00268 for(int i = 0 ; i < D ; i++)
00269 _Coordinate<D>::coordinate[i]=::min(_Coordinate<D>::coordinate[i],o[i]);
00270 }
00271
00272 template<int R> void takeFrom(const Size<R> &from)
00273 {
00274 if(R<D)
00275 for(int i = 0 ; i < R ; i++) _Coordinate<D>::coordinate[i]=from[i];
00276 else
00277 for(int i = 0 ; i < D ; i++) _Coordinate<D>::coordinate[i]=from[i];
00278 }
00279 };
00280
00281 typedef Position<2> XY;
00282
00283 template <int D> class From: public _Coordinate<D>
00284 {
00285 public:
00286 From(const Position<D> &pos) : _Coordinate<D>(pos) {};
00287 From(int x) : _Coordinate<D>(x) {};
00288 From(int x, int y) : _Coordinate<D>(x,y) {};
00289 From(int x, int y, int z) : _Coordinate<D>(x,y,z) {};
00290 From(int x, int y, int z, int a) : _Coordinate<D>(x,y,z,a) {};
00291 };
00292 #endif // __loaded__coordinates_h__
