Debian Codegraph @

unittests/integration/test_MultiObjectiveOptimization.cpp

raw
1 #include <fstream>
2 #include <dart/common/Console.hpp>
3 #include <dart/common/Memory.hpp>
4 #include <dart/config.hpp>
5 #include <dart/optimizer/Function.hpp>
6 #include <dart/optimizer/GenericMultiObjectiveProblem.hpp>
7 #include <dart/optimizer/MultiObjectiveSolver.hpp>
8 #include <gtest/gtest.h>
9 #if HAVE_PAGMO
10 # include <dart/optimizer/pagmo/pagmo.hpp>
11 #endif
12
13 using namespace dart;
14 using namespace dart::optimizer;
15 using dart::optimizer::Function;
16 using dart::optimizer::FunctionPtr;
17 using dart::optimizer::UniqueFunctionPtr;
18
19 //==============================================================================
20 static int dimension = 10;
21 static Eigen::VectorXd lowerLimits = Eigen::VectorXd::Zero(dimension);
22 static Eigen::VectorXd upperLimits = Eigen::VectorXd::Constant(dimension, 1.0);
23
24 class ZDT1 : public MultiObjectiveProblem
25 {
26 public:
27 ZDT1() : MultiObjectiveProblem(dimension)
28 {
29 // Do nothing
30 }
31
32 std::size_t getObjectiveDimension() const override
33 {
34 return 2u;
35 }
36
37 Eigen::VectorXd evaluateObjectives(const Eigen::VectorXd& x) const override
38 {
39 Eigen::VectorXd ret(getObjectiveDimension());
40
41 ret[0] = x[0];
42
43 const double g = 1.0 + 9 * (x.sum() - x[0]) / double(dimension - 1);
44 ret[1] = g * (1.0 - std::sqrt(x[0] / g));
45
46 return ret;
47 }
48
49 protected:
50 };
51
52 //==============================================================================
53 class Func1 : public Function
54 {
55 public:
56 Func1() = default;
57
58 double eval(const Eigen::VectorXd& x) override
59 {
60 return x[0];
61 }
62
63 UniqueFunctionPtr clone() const
64 {
65 return std::make_unique<Func1>(*this);
66 }
67
68 std::size_t getParameterDimension() const
69 {
70 return 1u;
71 }
72 };
73
74 //==============================================================================
75 class Func2 : public Function
76 {
77 public:
78 Func2() = default;
79
80 double eval(const Eigen::VectorXd& x) override
81 {
82 double g = 1.0 + 9 * (x.sum() - x[0]) / double(dimension - 1);
83 return g * (1.0 - std::sqrt(x[0] / g));
84 }
85
86 UniqueFunctionPtr clone() const
87 {
88 return std::make_unique<Func2>(*this);
89 }
90
91 std::size_t getParameterDimension() const
92 {
93 return 1u;
94 }
95 };
96
97 //==============================================================================
98 void testZDT1(MultiObjectiveSolver& solver)
99 {
100 #ifdef NDEBUG // release mode
101 std::size_t numSolutions = 50;
102 #else
103 std::size_t numSolutions = 10;
104 #endif
105 #ifdef NDEBUG // release mode
106 std::size_t iterationNum = 1000;
107 #else
108 std::size_t iterationNum = 200;
109 #endif
110
111 auto problem = std::make_shared<ZDT1>();
112 problem->setLowerBounds(lowerLimits);
113 problem->setUpperBounds(upperLimits);
114
115 solver.setProblem(problem);
116 solver.setPopulationSize(numSolutions);
117 solver.setNumPopulations(100);
118 solver.setNumIterationsPerEvolution(iterationNum);
119 solver.solve(100);
120
121 EXPECT_TRUE(solver.getPopulation(0).getSize() == numSolutions);
122 EXPECT_TRUE(solver.getPopulation(1).getSize() == numSolutions);
123 EXPECT_TRUE(solver.getNumPopulations() == 100);
124 }
125
126 //==============================================================================
127 void testZDT1Generic(MultiObjectiveSolver& solver)
128 {
129 auto pFunc1 = std::make_shared<Func1>();
130 auto pFunc2 = std::make_shared<Func2>();
131
132 std::vector<FunctionPtr> pFuncs;
133 pFuncs.push_back(pFunc1);
134 pFuncs.push_back(pFunc2);
135
136 #ifdef NDEBUG // release mode
137 std::size_t numSolutions = 50;
138 #else
139 std::size_t numSolutions = 10;
140 #endif
141 #ifdef NDEBUG // release mode
142 std::size_t iterationNum = 1000;
143 #else
144 std::size_t iterationNum = 200;
145 #endif
146
147 auto problem
148 = std::make_shared<optimizer::GenericMultiObjectiveProblem>(dimension);
149 problem->setObjectiveFunctions(pFuncs);
150 problem->setLowerBounds(lowerLimits);
151 problem->setUpperBounds(upperLimits);
152
153 solver.setProblem(problem);
154 solver.setPopulationSize(numSolutions);
155 solver.setNumPopulations(100);
156 solver.setNumIterationsPerEvolution(iterationNum);
157 solver.solve(100);
158
159 EXPECT_TRUE(solver.getPopulation(0).getSize() == numSolutions);
160 EXPECT_TRUE(solver.getPopulation(1).getSize() == numSolutions);
161 EXPECT_TRUE(solver.getNumPopulations() == 100);
162 }
163
164 //==============================================================================
165 TEST(ZDT1, Basic)
166 {
167 #if HAVE_PAGMO
168 PagmoMultiObjectiveSolver pagmoSolver;
169 testZDT1(pagmoSolver);
170 testZDT1Generic(pagmoSolver);
171 #endif
172 }