1 /* _________________________________________________________________________
2 *
3 * Acro: A Common Repository for Optimizers
4 * Copyright (c) 2008 Sandia Corporation.
5 * This software is distributed under the BSD License.
6 * Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
7 * the U.S. Government retains certain rights in this software.
8 * For more information, see the README.txt file in the top Acro directory.
9 * _________________________________________________________________________
10 */
11
12
13 #include "TestOptSolver.h"
14 #include <colin/AppResponseAnalysis.h>
15 #include <colin/SolverMngr.h>
16
17 using namespace std;
18
19 namespace {
20
21 const bool register_1 = SolverMngr().declare_solver_type<TestOptSolver>
22 ("colin:test", "A simple test minimizer");
23
24 const bool register_2 = SolverMngr().declare_solver_type<AnotherOptSolver>
25 ("colin:test_a", "A simple test minimizer using BasicArray<double> types");
26
27 const bool register_3 = SolverMngr().declare_solver_type<TestOptSolver_g>
28 ("colin:test_g", "A simple test minimizer using gradients");
29
30 } // namespace (local)
31
32
optimize()33 void TestOptSolver::optimize()
34 {
35 if ( problem->num_real_vars != curr.size() )
36 {
37 EXCEPTION_MNGR(std::runtime_error, "TestOptSolver::optimize - "
38 "curr has the wrong number of parameters ("
39 << curr.size() << " != " << problem->num_real_vars
40 << ")");
41 }
42 colin::real tmp;
43 std::vector<colin::real> ctmp;
44 std::vector<colin::real> clower, cupper;
45 std::vector<colin::real> rlower, rupper;
46 colin::real cviol;
47
48 if ( problem->enforcing_domain_bounds )
49 {
50 rlower = problem->real_lower_bounds;
51 rupper = problem->real_upper_bounds;
52 }
53 clower = problem->nonlinear_constraint_lower_bounds;
54 cupper = problem->nonlinear_constraint_upper_bounds;
55 problem->EvalF(eval_mngr(), curr, tmp);
56 if (problem->num_nonlinear_constraints > 0)
57 {
58 problem->EvalCF(eval_mngr(), curr, ctmp);
59 constraint_violation(ctmp, clower, cupper, cviol, 1e-7);
60 }
61 else
62 cviol = 0.0;
63 opt_response.value() = tmp;
64
65 int j = 0;
66 while (!check_convergence())
67 {
68 for (unsigned int i = 0; i < curr.size(); i++)
69 {
70 if ( ! problem->enforcing_domain_bounds
71 || ((curr[i] - 0.1 + 1e-6) >= rlower[i]) )
72 { curr[i] -= 0.1; }
73 }
74 problem->EvalF(eval_mngr(), curr, tmp);
75 if (opt_response.value() > tmp)
76 { opt_response.value() = tmp; }
77 if (problem->num_nonlinear_constraints > 0)
78 {
79 problem->EvalCF(eval_mngr(), curr, ctmp);
80 constraint_violation(ctmp, clower, cupper, cviol, 1e-7);
81 }
82 else cviol = 0.0;
83 ucout << "TestOptSolver: iter " << j << " value " << opt_response.value() << " pt "
84 << curr << " viol " << cviol << endl << utilib::Flush;
85 j++;
86 }
87
88 opt_response.constraint_violation = real::positive_infinity;
89 opt_response.point = curr;
90 final_points.add_point(problem, curr);
91 }
92
93
optimize()94 void TestOptSolver_g::optimize()
95 {
96 if ( problem->num_real_vars != curr.size() )
97 {
98 EXCEPTION_MNGR(std::runtime_error, "TestOptSolver::optimize - "
99 "curr has the wrong number of parameters");
100 }
101 colin::real tmp;
102 std::vector<colin::real> grad;
103 std::vector<colin::real> trial(curr.size());
104 colin::real cviol;
105
106 problem->EvalF(eval_mngr(), curr, tmp);
107 problem->EvalG(eval_mngr(), curr, grad);
108 opt_response.value() = tmp;
109
110 int j = 0;
111 double alpha = 1.0;
112 while (!check_convergence())
113 {
114 problem->EvalG(eval_mngr(), curr, grad);
115 for (unsigned int i = 0; i < curr.size(); i++)
116 { trial[i] = curr[i] - alpha * grad[i]; }
117 //ucout << " TRIAL " << j << " " << trial << " " << grad << endl;
118 problem->EvalF(eval_mngr(), trial, tmp);
119 if (opt_response.value() > tmp)
120 {
121 opt_response.value() = tmp;
122 for (unsigned int i = 0; i < curr.size(); i++)
123 { curr[i] = curr[i] - alpha * grad[i]; }
124 }
125 else
126 { alpha /= 3.0; }
127
128 ucout << "TestOptSolver_g: " << j << " " << opt_response.value()
129 << " " << curr << " " << 0.0 << endl;
130 j++;
131 }
132 opt_response.constraint_violation = real::positive_infinity;
133 opt_response.point = curr;
134 final_points.add_point(problem, curr);
135 }
136
optimize()137 void AnotherOptSolver::optimize()
138 {
139 if ( problem->num_real_vars != curr.size() )
140 {
141 EXCEPTION_MNGR(std::runtime_error, "TestOptSolver::optimize - "
142 "curr has the wrong number of parameters");
143 }
144 colin::real tmp;
145 utilib::BasicArray<colin::real> ctmp;
146 utilib::BasicArray<colin::real> clower, cupper;
147 colin::real cviol;
148
149 clower = problem->nonlinear_constraint_lower_bounds;
150 cupper = problem->nonlinear_constraint_upper_bounds;
151 problem->EvalF(eval_mngr(), curr, tmp);
152 if (problem->num_nonlinear_constraints > 0)
153 {
154 problem->EvalCF(eval_mngr(), curr, ctmp);
155 constraint_violation(ctmp, clower, cupper, cviol, 1e-7);
156 }
157 constraint_violation(ctmp, clower, cupper, cviol, 1e-7);
158 opt_response.value() = tmp;
159
160 int j = 0;
161 while (!check_convergence())
162 {
163 for (unsigned int i = 0; i < curr.size(); i++)
164 { curr[i] -= 0.1; }
165 problem->EvalF(eval_mngr(), curr, tmp);
166 if (problem->num_nonlinear_constraints > 0)
167 {
168 problem->EvalCF(eval_mngr(), curr, ctmp);
169 constraint_violation(ctmp, clower, cupper, cviol, 1e-7);
170 }
171 if (opt_response.value() > tmp)
172 { opt_response.value() = tmp; }
173 constraint_violation(ctmp, clower, cupper, cviol, 1e-7);
174 ucout << "AnotherOptSolver: " << j << " " << opt_response.value()
175 << " " << curr << " " << cviol << endl << utilib::Flush;
176 j++;
177 }
178
179 opt_response.constraint_violation = real::positive_infinity;
180 opt_response.point = curr;
181 final_points.add_point(problem, curr);
182 }
183