MultiObjectiveFunctions.h

Go to the documentation of this file.
00001 //===========================================================================
00037 //===========================================================================
00038 
00039 
00040 #ifndef MULTIOBJECTIVEFUNCTIONS_H_
00041 #define MULTIOBJECTIVEFUNCTIONS_H_
00042 
00043 
00044 #include <EALib/ObjectiveFunction.h>
00045 
00046 
00051 class BhinKornConstraintHandler : public ConstraintHandler<double*>
00052 {
00053 public:
00054     BhinKornConstraintHandler() { }
00055     ~BhinKornConstraintHandler() { }
00056 
00057     bool isFeasible(double* const& point) const;
00058 
00059 protected:
00060     unsigned int m_dimension;
00061     double m_lower;
00062     double m_upper;
00063 };
00064 
00065 
00066 
00088 class BhinKorn : public  ObjectiveFunctionVS<double> {
00089 public:
00091     BhinKorn();
00092 
00094     ~BhinKorn();
00095 
00096     unsigned int objectives() const;
00097     void result(double* const& point, std::vector<double>& value);
00098     bool ProposeStartingPoint(double*& point) const;
00099     bool utopianFitness(std::vector<double>& value) const;
00100     bool nadirFitness(std::vector<double>& value) const;
00101 };
00102 
00103 
00104 
00105 
00125 class Schaffer : public  ObjectiveFunctionVS<double> {
00126 public:
00128     Schaffer();
00129 
00131     ~Schaffer();
00132 
00133     unsigned int objectives() const;
00134     void result(double* const& point, std::vector<double>& value);
00135     bool ProposeStartingPoint(double*& point) const;
00136     bool utopianFitness(std::vector<double>& value) const;
00137     bool nadirFitness(std::vector<double>& value) const;
00138 };
00139 
00140 
00141 
00160 class ZDT1 : public ObjectiveFunctionVS<double> {
00161 public:
00163     ZDT1( unsigned d );
00164 
00166     ~ZDT1();
00167 
00168     unsigned int objectives() const;
00169     void result(double* const& point, std::vector<double>& value);
00170     bool ProposeStartingPoint(double*& point) const;
00171     bool utopianFitness(std::vector<double>& value) const;
00172     bool nadirFitness(std::vector<double>& value) const;
00173 };
00174 
00175 
00193 class ZDT2 : public ObjectiveFunctionVS<double> {
00194 public:
00196     ZDT2( unsigned d );
00197 
00199     ~ZDT2();
00200 
00201     unsigned int objectives() const;
00202     void result(double* const& point, std::vector<double>& value);
00203     bool ProposeStartingPoint(double*& point) const;
00204     bool utopianFitness(std::vector<double>& value) const;
00205     bool nadirFitness(std::vector<double>& value) const;
00206 };
00207 
00208 
00226 class ZDT3 : public ObjectiveFunctionVS<double> {
00227 public:
00229     ZDT3( unsigned d );
00230 
00232     ~ZDT3();
00233 
00234     unsigned int objectives() const;
00235     void result(double* const& point, std::vector<double>& value);
00236     bool ProposeStartingPoint(double*& point) const;
00237     bool utopianFitness(std::vector<double>& value) const;
00238     bool nadirFitness(std::vector<double>& value) const;
00239 };
00240 
00241 
00258 class ZDT4 : public ObjectiveFunctionVS<double> {
00259 public:
00261     ZDT4( unsigned d );
00262 
00264     ~ZDT4();
00265 
00266     unsigned int objectives() const;
00267     void result(double* const& point, std::vector<double>& value);
00268     bool ProposeStartingPoint(double*& point) const;
00269     bool utopianFitness(std::vector<double>& value) const;
00270     bool nadirFitness(std::vector<double>& value) const;
00271 };
00272 
00273 
00274 // /*!
00275 //  * \brief ConstraintHandler for the feasible region being a cuboid.
00276 //  *
00277 //  * The feasible region is an n-dimensional cuboid with the
00278 //  * side length in the first dimension differing from the side
00279 //  * lengths in the other dimensions.
00280 //  */
00281 // class CuboidConstraintHandler : public ConstraintHandler<double*>
00282 // {
00283 // public:
00284 //  CuboidConstraintHandler( unsigned int dimension, double lower1, double upper1, double lower2, double upper2 )
00285 //  : m_dimension( dimension )
00286 //  , m_lower_1( lower1 )
00287 //  , m_upper_1( upper1 )
00288 //  , m_lower_2( lower2 )
00289 //  , m_upper_2( upper2 )
00290 //  { }
00291 // 
00292 //  ~CuboidConstraintHandler() { }
00293 // 
00294 //  bool isFeasible(double* const& point) const;
00295 //  bool closestFeasible(double*& point) const;
00296 // 
00297 // protected:
00298 //  unsigned int m_dimension;
00299 //  double m_lower_1;
00300 //  double m_upper_1;
00301 //  double m_lower_2;
00302 //  double m_upper_2;
00303 // };
00304 
00305 // /*!
00306 //  * \brief ConstraintHandler suitable for LZ07_F6
00307 //  *
00308 //  * The feasible region is an n-dimensional cuboid
00309 //  * with the side length in the first and second dimension
00310 //  * differing from the side lengths in the other dimensions.
00311 //  */
00312 // class CuboidConstraintHandler_2 : public ConstraintHandler<double*>
00313 // {
00314 // public:
00315 //  CuboidConstraintHandler_2( unsigned int dimension, double lower1, double upper1, double lower2, double upper2 )
00316 //  : m_dimension( dimension )
00317 //  , m_lower_1( lower1 )
00318 //  , m_upper_1( upper1 )
00319 //  , m_lower_2( lower2 )
00320 //  , m_upper_2( upper2 )
00321 //  { }
00322 // 
00323 //  ~CuboidConstraintHandler_2() { }
00324 // 
00325 //  bool isFeasible(const double*& point) const;
00326 //  bool closestFeasible(double*& point) const;
00327 // 
00328 // protected:
00329 //  unsigned int m_dimension;
00330 //  double m_lower_1;
00331 //  double m_upper_1;
00332 //  double m_lower_2;
00333 //  double m_upper_2;
00334 // };
00335 
00336 
00358 class ZDT5 : public ObjectiveFunctionVS<long> {
00359 public:
00361     ZDT5( unsigned d = 11);
00362 
00364     ~ZDT5();
00365 
00366     unsigned int objectives() const;
00367     void result( long* const& point, std::vector<double>& value );
00368     bool ProposeStartingPoint( long*& point ) const;
00369 
00370 private:
00371     unsigned u( long x ) const;
00372 };
00373 
00374 
00384 class ZDT5ConstraintHandler : public ConstraintHandler<long*>
00385 {
00386 public:
00387     ZDT5ConstraintHandler( unsigned int dimension, long lower1, long upper1, long lower2, long upper2 )
00388     : m_dimension( dimension )
00389     , m_lower_1( lower1 )
00390     , m_upper_1( upper1 )
00391     , m_lower_2( lower2 )
00392     , m_upper_2( upper2 )
00393     { }
00394 
00395     ~ZDT5ConstraintHandler() { }
00396 
00397     bool isFeasible(long* const& point) const;
00398     bool closestFeasible(long*& point) const;
00399 
00400 protected:
00401     unsigned int m_dimension;
00402     long m_lower_1;
00403     long m_upper_1;
00404     long m_lower_2;
00405     long m_upper_2;
00406 };
00407 
00408 
00426 class ZDT6 : public ObjectiveFunctionVS<double> {
00427 public:
00429     ZDT6( unsigned d );
00430 
00432     ~ZDT6();
00433 
00434     unsigned int objectives() const;
00435     void result(double* const& point, std::vector<double>& value);
00436     bool ProposeStartingPoint(double*& point) const;
00437     bool utopianFitness(std::vector<double>& value) const;
00438     bool nadirFitness(std::vector<double>& value) const;
00439 };
00440 
00441 
00474 class IHR1 : public ObjectiveFunctionVS<double> {
00475 public:
00477     IHR1( unsigned d=10 );
00478 
00480     ~IHR1();
00481 
00482     unsigned int objectives() const;
00483     void result(double* const& point, std::vector<double>& value);
00484     bool ProposeStartingPoint(double*& point) const;
00485     bool utopianFitness(std::vector<double>& value) const;
00486     bool nadirFitness(std::vector<double>& value) const;
00487 
00489     void initRandomRotation();
00490 
00491 protected:
00493     void transform(const double* in, std::vector<double>& out) const;
00494     double h(double x, double n);
00495     double hf(double x, double y0, double ymax);
00496     double hg(double x);
00497 
00499     Matrix m_Transformation;
00500 };
00501 
00502 
00532 class IHR2 : public ObjectiveFunctionVS<double> {
00533 public:
00535     IHR2( unsigned d =10);
00536 
00538     ~IHR2();
00539 
00540     unsigned int objectives() const;
00541     void result(double* const& point, std::vector<double>& value);
00542     bool ProposeStartingPoint(double*& point) const;
00543     bool utopianFitness(std::vector<double>& value) const;
00544     bool nadirFitness(std::vector<double>& value) const;
00545     
00547     void initRandomRotation();
00548 
00549 protected:
00551     void transform(const double* in, std::vector<double>& out) const;
00552     double hf(double x, double y0, double ymax);
00553     double hg(double x);
00554 
00556     Matrix m_Transformation;
00557 };
00558 
00559 
00592 class IHR3 : public ObjectiveFunctionVS<double> {
00593 public:
00595     IHR3( unsigned d =10);
00596 
00598     ~IHR3();
00599 
00600     unsigned int objectives() const;
00601     void result(double* const& point, std::vector<double>& value);
00602     bool ProposeStartingPoint(double*& point) const;
00603     bool utopianFitness(std::vector<double>& value) const;
00604     bool nadirFitness(std::vector<double>& value) const;
00605     
00607     void initRandomRotation();
00608 
00609 protected:
00611     void transform(const double* in, std::vector<double>& out) const;
00612     double h(double x, double n);
00613     double hf(double x, double y0, double ymax);
00614     double hg(double x);
00615 
00617     Matrix m_Transformation;
00618 };
00619 
00620 
00621 
00651 class IHR6 : public ObjectiveFunctionVS<double> {
00652 public:
00654     IHR6( unsigned d =10);
00655 
00657     ~IHR6();
00658 
00659     unsigned int objectives() const;
00660     void result(double* const& point, std::vector<double>& value);
00661     bool ProposeStartingPoint(double*& point) const;
00662     bool utopianFitness(std::vector<double>& value) const;
00663     bool nadirFitness(std::vector<double>& value) const;
00664     
00666     void initRandomRotation();
00667 
00668 protected:
00670     void transform(const double* in, std::vector<double>& out) const;
00671     double h(double x, double n);
00672     double hf(double x, double y0, double ymax);
00673     double hg(double x);
00674 
00676     Matrix m_Transformation;
00677 };
00678 
00679 
00680 //  Problems with prescirbed Pareto Set (PS) :
00681 
00682 //  Problems with linear Ps shapes
00683 
00684 
00706 class ZZJ07_F1 : public ObjectiveFunctionVS<double> {
00707 public:
00709     ZZJ07_F1(unsigned d = 30);
00710 
00712     ~ZZJ07_F1();
00713 
00714     unsigned int objectives() const;
00715     void result(double* const& point, std::vector<double>& value);
00716     bool ProposeStartingPoint(double*& point) const;
00717     bool utopianFitness(std::vector<double>& value) const;
00718     bool nadirFitness(std::vector<double>& value) const;
00719 };
00720 
00742 class ZZJ07_F2 : public ObjectiveFunctionVS<double> {
00743 public:
00745     ZZJ07_F2( unsigned d = 30);
00746 
00748     ~ZZJ07_F2();
00749 
00750     unsigned int objectives() const;
00751     void result(double* const& point, std::vector<double>& value);
00752     bool ProposeStartingPoint(double*& point) const;
00753     bool utopianFitness(std::vector<double>& value) const;
00754     bool nadirFitness(std::vector<double>& value) const;
00755 };
00756 
00757 
00779 class ZZJ07_F3 : public ObjectiveFunctionVS<double> {
00780 public:
00782     ZZJ07_F3(unsigned d = 30);
00783 
00785     ~ZZJ07_F3();
00786 
00787     unsigned int objectives() const;
00788     void result(double* const& point, std::vector<double>& value);
00789     bool ProposeStartingPoint(double*& point) const;
00790     bool utopianFitness(std::vector<double>& value) const;
00791     bool nadirFitness(std::vector<double>& value) const;
00792 };
00793 
00794 
00819 class ZZJ07_F4 : public ObjectiveFunctionVS<double> {
00820 public:
00822     ZZJ07_F4(unsigned d = 30);
00823 
00825     ~ZZJ07_F4();
00826 
00827     unsigned int objectives() const;
00828     void result(double* const& point, std::vector<double>& value);
00829     bool ProposeStartingPoint(double*& point) const;
00830     bool utopianFitness(std::vector<double>& value) const;
00831     bool nadirFitness(std::vector<double>& value) const;
00832 };
00833 
00834 //  Problems with quadratic PS shapes
00835 
00857 class ZZJ07_F5 : public ObjectiveFunctionVS<double> {
00858 public:
00860     ZZJ07_F5(unsigned d = 30);
00861 
00863     ~ZZJ07_F5();
00864 
00865     unsigned int objectives() const;
00866     void result(double* const& point, std::vector<double>& value);
00867     bool ProposeStartingPoint(double*& point) const;
00868     bool utopianFitness(std::vector<double>& value) const;
00869     bool nadirFitness(std::vector<double>& value) const;
00870 };
00871 
00872 
00895 class ZZJ07_F6 : public ObjectiveFunctionVS<double> {
00896 public:
00898     ZZJ07_F6(unsigned d = 30);
00899 
00901     ~ZZJ07_F6();
00902 
00903     unsigned int objectives() const;
00904     void result(double* const& point, std::vector<double>& value);
00905     bool ProposeStartingPoint(double*& point) const;
00906     bool utopianFitness(std::vector<double>& value) const;
00907     bool nadirFitness(std::vector<double>& value) const;
00908 };
00909 
00910 
00933 class ZZJ07_F7 : public ObjectiveFunctionVS<double> {
00934 public:
00936     ZZJ07_F7(unsigned d = 30);
00937 
00939     ~ZZJ07_F7();
00940 
00941     unsigned int objectives() const;
00942     void result(double* const& point, std::vector<double>& value);
00943     bool ProposeStartingPoint(double*& point) const;
00944     bool utopianFitness(std::vector<double>& value) const;
00945     bool nadirFitness(std::vector<double>& value) const;
00946 };
00947 
00948 
00974 class ZZJ07_F8 : public ObjectiveFunctionVS<double> {
00975 public:
00977     ZZJ07_F8(unsigned d = 30);
00978 
00980     ~ZZJ07_F8();
00981 
00982     unsigned int objectives() const;
00983     void result(double* const& point, std::vector<double>& value);
00984     bool ProposeStartingPoint(double*& point) const;
00985     bool utopianFitness(std::vector<double>& value) const;
00986     bool nadirFitness(std::vector<double>& value) const;
00987 };
00988 
00989 
01011 class ZZJ07_F9 : public ObjectiveFunctionVS<double> {
01012 public:
01014     ZZJ07_F9(unsigned d = 10);
01015 
01017     ~ZZJ07_F9();
01018 
01019     unsigned int objectives() const;
01020     void result(double* const& point, std::vector<double>& value);
01021     bool ProposeStartingPoint(double*& point) const;
01022     bool utopianFitness(std::vector<double>& value) const;
01023     bool nadirFitness(std::vector<double>& value) const;
01024 };
01025 
01026 
01049 class ZZJ07_F10 : public ObjectiveFunctionVS<double> {
01050 public:
01052     ZZJ07_F10(unsigned d = 10);
01053 
01055     ~ZZJ07_F10();
01056 
01057     unsigned int objectives() const;
01058     void result(double* const& point, std::vector<double>& value);
01059     bool ProposeStartingPoint(double*& point) const;
01060     bool utopianFitness(std::vector<double>& value) const;
01061     bool nadirFitness(std::vector<double>& value) const;
01062 };
01063 
01064 
01086 class LZ06_F1 : public ObjectiveFunctionVS<double> {
01087 public:
01089     LZ06_F1( unsigned d = 30 );
01090 
01092     ~LZ06_F1();
01093 
01094     unsigned int objectives() const;
01095     void result(double* const& point, std::vector<double>& value);
01096     bool ProposeStartingPoint(double*& point) const;
01097     bool utopianFitness(std::vector<double>& value) const;
01098     bool nadirFitness(std::vector<double>& value) const;
01099 };
01100 
01101 
01123 class LZ06_F2 : public ObjectiveFunctionVS<double> {
01124 public:
01126     LZ06_F2( unsigned d = 30 );
01127 
01129     ~LZ06_F2();
01130 
01131     unsigned int objectives() const;
01132     void result(double* const& point, std::vector<double>& value);
01133     bool ProposeStartingPoint(double*& point) const;
01134     bool utopianFitness(std::vector<double>& value) const;
01135     bool nadirFitness(std::vector<double>& value) const;
01136 };
01137 
01138 
01139 
01164 class LZ07_F1 : public ObjectiveFunctionVS<double> {
01165 public:
01167     LZ07_F1( unsigned d = 30 );
01168 
01170     ~LZ07_F1();
01171 
01172     unsigned int objectives() const;
01173     void result(double* const& point, std::vector<double>& value);
01174     bool ProposeStartingPoint(double*& point) const;
01175     bool utopianFitness(std::vector<double>& value) const;
01176     bool nadirFitness(std::vector<double>& value) const;
01177 };
01178 
01179 
01204 class LZ07_F2 : public ObjectiveFunctionVS<double> {
01205 public:
01207     LZ07_F2( unsigned d = 30 );
01208 
01210     ~LZ07_F2();
01211 
01212     unsigned int objectives() const;
01213     void result(double* const& point, std::vector<double>& value);
01214     bool ProposeStartingPoint(double*& point) const;
01215     bool utopianFitness(std::vector<double>& value) const;
01216     bool nadirFitness(std::vector<double>& value) const;
01217 };
01218 
01219 
01245 class LZ07_F3 : public ObjectiveFunctionVS<double> {
01246 public:
01248     LZ07_F3( unsigned d = 30 );
01249 
01251     ~LZ07_F3();
01252 
01253     unsigned int objectives() const;
01254     void result(double* const& point, std::vector<double>& value);
01255     bool ProposeStartingPoint(double*& point) const;
01256     bool utopianFitness(std::vector<double>& value) const;
01257     bool nadirFitness(std::vector<double>& value) const;
01258 };
01259 
01260 
01285 class LZ07_F4 : public ObjectiveFunctionVS<double> {
01286 public:
01288     LZ07_F4( unsigned d = 30 );
01289 
01291     ~LZ07_F4();
01292 
01293     unsigned int objectives() const;
01294     void result(double* const& point, std::vector<double>& value);
01295     bool ProposeStartingPoint(double*& point) const;
01296     bool utopianFitness(std::vector<double>& value) const;
01297     bool nadirFitness(std::vector<double>& value) const;
01298 };
01299 
01300 
01326 class LZ07_F5 : public ObjectiveFunctionVS<double> {
01327 public:
01329     LZ07_F5( unsigned d = 30 );
01330 
01332     ~LZ07_F5();
01333 
01334     unsigned int objectives() const;
01335     void result(double* const& point, std::vector<double>& value);
01336     bool ProposeStartingPoint(double*& point) const;
01337     bool utopianFitness(std::vector<double>& value) const;
01338     bool nadirFitness(std::vector<double>& value) const;
01339 };
01340 
01341 
01373 class LZ07_F6 : public ObjectiveFunctionVS<double> {
01374 public:
01376     LZ07_F6( unsigned d = 10 );
01377 
01379     ~LZ07_F6();
01380 
01381     unsigned int objectives() const;
01382     void result(double* const& point, std::vector<double>& value);
01383     bool ProposeStartingPoint(double*& point) const;
01384     bool utopianFitness(std::vector<double>& value) const;
01385     bool nadirFitness(std::vector<double>& value) const;
01386 };
01387 
01388 
01417 class LZ07_F7 : public ObjectiveFunctionVS<double> {
01418 public:
01420     LZ07_F7( unsigned d = 30 );
01421 
01423     ~LZ07_F7();
01424 
01425     unsigned int objectives() const;
01426     void result(double* const& point, std::vector<double>& value);
01427     bool ProposeStartingPoint(double*& point) const;
01428     bool utopianFitness(std::vector<double>& value) const;
01429     bool nadirFitness(std::vector<double>& value) const;
01430 };
01431 
01432 
01461 class LZ07_F8 : public ObjectiveFunctionVS<double> {
01462 public:
01464     LZ07_F8( unsigned d = 30 );
01465 
01467     ~LZ07_F8();
01468 
01469     unsigned int objectives() const;
01470     void result(double* const& point, std::vector<double>& value);
01471     bool ProposeStartingPoint(double*& point) const;
01472     bool utopianFitness(std::vector<double>& value) const;
01473     bool nadirFitness(std::vector<double>& value) const;
01474 };    
01475  
01476 
01502 class LZ07_F9 : public ObjectiveFunctionVS<double> {
01503 public:
01505     LZ07_F9( unsigned d = 30 );
01506 
01508     ~LZ07_F9();
01509 
01510     unsigned int objectives() const;
01511     void result(double* const& point, std::vector<double>& value);
01512     bool ProposeStartingPoint(double*& point) const;
01513     bool utopianFitness(std::vector<double>& value) const;
01514     bool nadirFitness(std::vector<double>& value) const;
01515 };
01516 
01517 
01531 class ELLIBase : public ObjectiveFunctionVS<double> {
01532 public:
01534     ELLIBase( unsigned d = 10, double a =1000);
01535 
01537     ~ELLIBase();
01538 
01539     unsigned int objectives() const;
01540     void result(double* const& point, std::vector<double>& value);
01541     bool ProposeStartingPoint(double*& point) const;
01542     bool utopianFitness(std::vector<double>& value) const;
01543 
01544 protected:
01545     double m_a;
01546 };
01547 
01548 
01565 class ELLI1 : public TransformedObjectiveFunction {
01566 public:
01568     ELLI1( unsigned d = 10, double a=1000 );
01569 
01571     ~ELLI1();
01572 
01573     unsigned int objectives() const;
01574     bool ProposeStartingPoint(double*& point) const;
01575 
01576 protected:
01578     ELLIBase base;
01579 };
01580 
01581 
01582 
01602 class ELLI2 : public ObjectiveFunctionVS<double> {
01603 public:
01605     ELLI2( unsigned d = 10, double a =1000);
01606 
01608     ~ELLI2();
01609 
01610     unsigned int objectives() const;
01611     void result(double* const& point, std::vector<double>& value);
01612     bool ProposeStartingPoint(double*& point) const;
01613 
01615     void initRandomRotation();
01616 
01617     protected:
01619     void transform_1 (const double* in, std::vector<double>& out) const;
01620 
01622     void transform_2 (const double* in, std::vector<double>& out) const;
01623 
01624     double m_a;
01626     Matrix m_Transformation_1;
01628     Matrix m_Transformation_2;
01629     
01630 };
01631 
01632 
01633 
01647 class CIGTABBase : public ObjectiveFunctionVS<double> {
01648 public:
01650     CIGTABBase( unsigned d = 10, double a =1000);
01651 
01653     ~CIGTABBase();
01654 
01655     unsigned int objectives() const;
01656     void result(double* const& point, std::vector<double>& value);
01657     bool ProposeStartingPoint(double*& point) const;
01658     bool utopianFitness(std::vector<double>& value) const;
01659 
01660     protected:
01661     double m_a;
01662 };
01663 
01664 
01665 
01682 class CIGTAB1 : public TransformedObjectiveFunction {
01683 public:
01685     CIGTAB1( unsigned d = 10, double a=1000 );
01686 
01688     ~CIGTAB1();
01689 
01690     unsigned int objectives() const;
01691     bool ProposeStartingPoint(double*& point) const;
01692 
01693 protected:
01695     CIGTABBase base;
01696 };
01697 
01698 
01718 class CIGTAB2 : public ObjectiveFunctionVS<double> {
01719 public:
01721     CIGTAB2( unsigned d = 10, double a =1000);
01722 
01724     ~CIGTAB2();
01725 
01726     unsigned int objectives() const;
01727     void result(double* const& point, std::vector<double>& value);
01728     bool ProposeStartingPoint(double*& point) const;
01729 
01731     void initRandomRotation();
01732 
01733     protected:
01735     void transform_1 (const double* in, std::vector<double>& out) const;
01736 
01738     void transform_2 (const double* in, std::vector<double>& out) const;
01739 
01740     double m_a;
01742     Matrix m_Transformation_1;
01744     Matrix m_Transformation_2;
01745     
01746 };
01747 
01748 
01749 
01775 class DTLZ1 : public ObjectiveFunctionVS<double> {
01776 public:
01778     DTLZ1( unsigned d = 30, unsigned m=3);
01779 
01781     ~DTLZ1();
01782 
01783     unsigned int objectives() const;
01784     void result(double* const& point, std::vector<double>& value);
01785     bool ProposeStartingPoint(double*& point) const;
01786     bool utopianFitness(std::vector<double>& value) const;
01787     bool nadirFitness(std::vector<double>& value) const;
01788 
01789 protected:
01790     unsigned m_objectives; 
01791 };
01792 
01793 
01816 class DTLZ2 : public ObjectiveFunctionVS<double> {
01817 public:
01819     DTLZ2( unsigned d = 30, unsigned m=3);
01820 
01822     ~DTLZ2();
01823 
01824     unsigned int objectives() const;
01825     void result(double* const& point, std::vector<double>& value);
01826     bool ProposeStartingPoint(double*& point) const;
01827     bool utopianFitness(std::vector<double>& value) const;
01828     bool nadirFitness(std::vector<double>& value) const;
01829 
01830 protected:
01831     unsigned m_objectives; 
01832 };
01833 
01834 
01857 class DTLZ3 : public ObjectiveFunctionVS<double> {
01858 public:
01860     DTLZ3( unsigned d = 30, unsigned m=3);
01861 
01863     ~DTLZ3();
01864 
01865     unsigned int objectives() const;
01866     void result(double* const& point, std::vector<double>& value);
01867     bool ProposeStartingPoint(double*& point) const;
01868     bool utopianFitness(std::vector<double>& value) const;
01869     bool nadirFitness(std::vector<double>& value) const;
01870 
01871 protected:
01872     unsigned m_objectives; 
01873 };
01874 
01875 
01899 class DTLZ4 : public ObjectiveFunctionVS<double> {
01900 public:
01902     DTLZ4( unsigned d = 30, unsigned m=3);
01903 
01905     ~DTLZ4();
01906 
01907     unsigned int objectives() const;
01908     void result(double* const& point, std::vector<double>& value);
01909     bool ProposeStartingPoint(double*& point) const;
01910     bool utopianFitness(std::vector<double>& value) const;
01911     bool nadirFitness(std::vector<double>& value) const;
01912 
01913 protected:
01914     unsigned m_objectives; 
01915 };
01916 
01917 
01941 class DTLZ5 : public ObjectiveFunctionVS<double> {
01942 public:
01944     DTLZ5( unsigned d = 30, unsigned m=3);
01945 
01947     ~DTLZ5();
01948 
01949     unsigned int objectives() const;
01950     void result(double* const& point, std::vector<double>& value);
01951     bool ProposeStartingPoint(double*& point) const;
01952     bool utopianFitness(std::vector<double>& value) const;
01953     bool nadirFitness(std::vector<double>& value) const;
01954 
01955 protected:
01956     unsigned m_objectives; 
01957 };
01958 
01982 class DTLZ6 : public ObjectiveFunctionVS<double> {
01983 public:
01985     DTLZ6( unsigned d = 30, unsigned m=3);
01986 
01988     ~DTLZ6();
01989 
01990     unsigned int objectives() const;
01991     void result(double* const& point, std::vector<double>& value);
01992     bool ProposeStartingPoint(double*& point) const;
01993     bool utopianFitness(std::vector<double>& value) const;
01994     bool nadirFitness(std::vector<double>& value) const;
01995 
01996     protected:
01997     unsigned m_objectives; 
01998 };
01999 
02000 
02027 class DTLZ7 : public ObjectiveFunctionVS<double> {
02028 public:
02030     DTLZ7( unsigned d = 30, unsigned m=3);
02031 
02033     ~DTLZ7();
02034 
02035     unsigned int objectives() const;
02036     void result(double* const& point, std::vector<double>& value);
02037     bool ProposeStartingPoint(double*& point) const;
02038     bool utopianFitness(std::vector<double>& value) const;
02039     bool nadirFitness(std::vector<double>& value) const;
02040 
02041 protected:
02042     unsigned m_objectives; 
02043 };
02044 
02045 
02054 class Superspheres : public ObjectiveFunctionVS<double>
02055 {
02056 public:
02058     Superspheres(unsigned int dim);
02059 
02061     ~Superspheres();
02062 
02063 
02064     unsigned int objectives() const;
02065     void result(double* const& point, std::vector<double>& value);
02066     bool ProposeStartingPoint(double*& point) const;
02067     bool utopianFitness(std::vector<double>& value) const;
02068     bool nadirFitness(std::vector<double>& value) const;
02069 };
02070 
02071 
02072 #endif