00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifndef _eoRealVectorBounds_h
00028 #define _eoRealVectorBounds_h
00029
00030 #include <stdexcept>
00031 #include <utils/eoRNG.h>
00032 #include <utils/eoRealBounds.h>
00033
00058 class eoRealBaseVectorBounds : public std::vector<eoRealBounds *>
00059 {
00060 public:
00061
00062 virtual ~eoRealBaseVectorBounds(){}
00063
00066 eoRealBaseVectorBounds() : std::vector<eoRealBounds *>(0) {}
00067
00070 eoRealBaseVectorBounds(unsigned _dim, eoRealBounds & _bounds) :
00071 std::vector<eoRealBounds *>(_dim, &_bounds)
00072 {}
00073
00076 eoRealBaseVectorBounds(eoRealBounds & _xbounds, eoRealBounds & _ybounds) :
00077 std::vector<eoRealBounds *>(0)
00078 {
00079 push_back( &_xbounds);
00080 push_back( &_ybounds);
00081 }
00082
00085 virtual bool isBounded(unsigned _i)
00086 {
00087 return (*this)[_i]->isBounded();
00088 }
00089
00092 virtual bool isBounded(void)
00093 {
00094 for (unsigned i=0; i<size(); i++)
00095 if (! (*this)[i]->isBounded())
00096 return false;
00097 return true;
00098 }
00099
00102 virtual bool hasNoBoundAtAll(unsigned _i)
00103 {
00104 return (*this)[_i]->hasNoBoundAtAll();
00105 }
00106
00109 virtual bool hasNoBoundAtAll(void)
00110 {
00111 for (unsigned i=0; i<size(); i++)
00112 if (! (*this)[i]->hasNoBoundAtAll())
00113 return false;
00114 return true;
00115 }
00116
00117 virtual bool isMinBounded(unsigned _i)
00118 { return (*this)[_i]->isMinBounded();} ;
00119
00120 virtual bool isMaxBounded(unsigned _i)
00121 { return (*this)[_i]->isMaxBounded();} ;
00122
00125 virtual void foldsInBounds(unsigned _i, double & _r)
00126 {
00127 (*this)[_i]->foldsInBounds(_r);
00128 }
00129
00132 virtual void foldsInBounds(std::vector<double> & _v)
00133 {
00134 for (unsigned i=0; i<size(); i++)
00135 {
00136 (*this)[i]->foldsInBounds(_v[i]);
00137 }
00138 }
00139
00142 virtual void truncate(unsigned _i, double & _r)
00143 {
00144 (*this)[_i]->truncate(_r);
00145 }
00146
00149 virtual void truncate(std::vector<double> & _v)
00150 {
00151 for (unsigned i=0; i<size(); i++)
00152 {
00153 (*this)[i]->truncate(_v[i]);
00154 }
00155 }
00156
00159 virtual bool isInBounds(unsigned _i, double _r)
00160 { return (*this)[_i]->isInBounds(_r); }
00161
00164 virtual bool isInBounds(std::vector<double> _v)
00165 {
00166 for (unsigned i=0; i<size(); i++)
00167 if (! isInBounds(i, _v[i]))
00168 return false;
00169 return true;
00170 }
00171
00174 virtual double minimum(unsigned _i) {return (*this)[_i]->minimum();}
00175 virtual double maximum(unsigned _i) {return (*this)[_i]->maximum();}
00176 virtual double range(unsigned _i) {return (*this)[_i]->range();}
00177
00181 virtual double averageRange()
00182 {
00183 double r=0.0;
00184 for (unsigned i=0; i<size(); i++)
00185 r += range(i);
00186 return r/size();
00187 }
00188
00192 virtual double uniform(unsigned _i, eoRng & _rng = eo::rng)
00193 {
00194 double r= (*this)[_i]->uniform();
00195 return r;
00196 }
00197
00201 void uniform(std::vector<double> & _v, eoRng & _rng = eo::rng)
00202 {
00203 _v.resize(size());
00204 for (unsigned i=0; i<size(); i++)
00205 {
00206 _v[i] = uniform(i, _rng);
00207 }
00208 }
00209
00214 virtual void printOn(std::ostream& _os) const
00215 {
00216 for (unsigned i=0; i<size(); i++)
00217 {
00218 operator[](i)->printOn(_os);
00219 _os << ";";
00220 }
00221 }
00222 };
00223
00225
00228 class eoRealVectorBounds : public eoRealBaseVectorBounds, public eoPersistent
00229 {
00230 public:
00233 eoRealVectorBounds():eoRealBaseVectorBounds() {}
00234
00237 eoRealVectorBounds(unsigned _dim, eoRealBounds & _bounds) :
00238 eoRealBaseVectorBounds(_dim, _bounds), factor(1,_dim), ownedBounds(0)
00239 {}
00240
00243 eoRealVectorBounds(eoRealBounds & _xbounds, eoRealBounds & _ybounds) :
00244 eoRealBaseVectorBounds(_xbounds, _ybounds), factor(2,1), ownedBounds(0)
00245 {}
00246
00249 eoRealVectorBounds(unsigned _dim, double _min, double _max) :
00250 eoRealBaseVectorBounds(), factor(1, _dim), ownedBounds(0)
00251 {
00252 if (_max-_min<=0)
00253 throw std::logic_error("Void range in eoRealVectorBounds");
00254 eoRealBounds *ptBounds = new eoRealInterval(_min, _max);
00255
00256 ownedBounds.push_back(ptBounds);
00257
00258 for (unsigned int i=0; i<_dim; i++)
00259 push_back(ptBounds);
00260 }
00261
00264 eoRealVectorBounds(std::vector<double> _min, std::vector<double> _max) :
00265 factor(_min.size(), 1), ownedBounds(0)
00266 {
00267 if (_max.size() != _min.size())
00268 throw std::logic_error("Dimensions don't match in eoRealVectorBounds");
00269
00270 eoRealBounds *ptBounds;
00271 for (unsigned i=0; i<_min.size(); i++)
00272 {
00273 ptBounds = new eoRealInterval(_min[i], _max[i]);
00274 ownedBounds.push_back(ptBounds);
00275 push_back(ptBounds);
00276 }
00277 }
00278
00282 eoRealVectorBounds(std::string _s) : eoRealBaseVectorBounds()
00283 {
00284 readFrom(_s);
00285 }
00286
00288 virtual ~eoRealVectorBounds()
00289 {
00290
00291
00292
00293
00294
00295 }
00296
00297
00298
00304 virtual void readFrom(std::istream& _is) ;
00305
00310 virtual void readFrom(std::string _s) ;
00311
00313 virtual void printOn(std::ostream& _os) const
00314 {
00315 if (factor[0]>1)
00316 _os << factor[0] ;
00317 operator[](0)->printOn(_os);
00318
00319
00320 unsigned int index=factor[0];
00321 if (factor.size()>1)
00322 for (unsigned i=1; i<factor.size(); i++)
00323 {
00324 _os << ";";
00325 if (factor[i] > 1)
00326 _os << factor[i];
00327 operator[](index)->printOn(_os);
00328 index += factor[i];
00329 }
00330 }
00331
00333 void adjust_size(unsigned _dim);
00334
00337 eoRealVectorBounds(const eoRealVectorBounds &);
00338
00339 private:
00340
00341 std::vector<unsigned int> factor;
00342 std::vector<eoRealBounds *> ownedBounds;
00343
00344 eoRealVectorBounds& operator=(const eoRealVectorBounds&);
00345 };
00346
00348
00352 class eoRealVectorNoBounds: public eoRealVectorBounds
00353 {
00354 public:
00355
00356 virtual ~eoRealVectorNoBounds(){}
00357
00361 eoRealVectorNoBounds(unsigned _dim) :
00362 eoRealVectorBounds( (_dim?_dim:1), eoDummyRealNoBounds)
00363 {}
00364
00365
00366 virtual bool isBounded(unsigned) {return false;}
00367 virtual bool isBounded(void) {return false;}
00368
00369 virtual bool hasNoBoundAtAll(unsigned) {return true;}
00370 virtual bool hasNoBoundAtAll(void) {return true;}
00371
00372 virtual bool isMinBounded(unsigned) {return false;}
00373 virtual bool isMaxBounded(unsigned) {return false;}
00374
00375 virtual void foldsInBounds(unsigned, double &) {return;}
00376 virtual void foldsInBounds(std::vector<double> &) {return;}
00377
00378 virtual void truncate(unsigned, double &) {return;}
00379 virtual void truncate(std::vector<double> &) {return;}
00380
00381 virtual bool isInBounds(unsigned, double) {return true;}
00382 virtual bool isInBounds(std::vector<double>) {return true;}
00383
00384
00385 virtual double minimum(unsigned)
00386 {
00387 throw std::logic_error("Trying to get minimum of eoRealVectorNoBounds");
00388 }
00389 virtual double maximum(unsigned)
00390 {
00391 throw std::logic_error("Trying to get maximum of eoRealVectorNoBounds");
00392 }
00393 virtual double range(unsigned)
00394 {
00395 throw std::logic_error("Trying to get range of eoRealVectorNoBounds");
00396 }
00397
00398 virtual double averageRange()
00399 {
00400 throw std::logic_error("Trying to get average range of eoRealVectorNoBounds");
00401 }
00402
00403
00404 virtual double uniform(unsigned, eoRng & _rng = eo::rng)
00405 {
00406 throw std::logic_error("No uniform distribution on eoRealVectorNoBounds");
00407 }
00408
00409
00410 void uniform(std::vector<double> &, eoRng & _rng = eo::rng)
00411 {
00412 throw std::logic_error("No uniform distribution on eoRealVectorNoBounds");
00413 }
00414
00415 };
00416
00417
00418
00419
00420 extern eoRealVectorNoBounds eoDummyVectorNoBounds;
00421 #endif