Code-Eli  0.3.6
nls_test_suite.hpp
Go to the documentation of this file.
1 /*********************************************************************************
2 * Copyright (c) 2013 David D. Marshall <ddmarsha@calpoly.edu>
3 *
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
8 *
9 * Contributors:
10 * David D. Marshall - initial code and implementation
11 ********************************************************************************/
12 
13 #ifndef nls_test_suite_hpp
14 #define nls_test_suite_hpp
15 
16 #include <cmath> // cos()
17 #include <functional> // std::ptr_fun()
18 #include <limits> // numeric_limits
19 
20 #include "eli/mutil/nls.hpp"
21 #include "eli/constants/math.hpp"
22 
23 template<typename data__>
24 data__ my_function(const data__ &x)
25 {
26  return std::cos(x);
27 }
28 
29 template<typename data__>
30 data__ my_function_derivative(const data__ &x)
31 {
32  return -std::sin(x);
33 }
34 
35 template<typename data__>
36 struct my_functor
37 {
38  data__ operator()(const data__ &x) const
39  {
40  return my_function(x);
41  }
42 };
43 
44 template<typename data__>
46 {
47  data__ operator()(const data__ &x) const
48  {
49  return my_function_derivative(x);
50  }
51 };
52 
53 template<typename data__>
54 Eigen::Matrix<data__, 3, 1> my_decoupled_system_function(const Eigen::Matrix<data__, 3, 1> &x)
55 {
56  Eigen::Matrix<data__, 3, 1> rtn_vec;
57 
58  rtn_vec(0,0)=std::exp(x(0));
59  rtn_vec(1,0)=std::exp(x(1));
60  rtn_vec(2,0)=std::exp(x(2));
61 
62  return rtn_vec;
63 }
64 
65 template<typename data__>
66 Eigen::Matrix<data__, 3, 3> my_decoupled_system_function_derivative(const Eigen::Matrix<data__, 3, 1> &x)
67 {
68  Eigen::Matrix<data__, 3, 3> rtn_mat;
69 
70  rtn_mat(0,0)=std::exp(x(0));
71  rtn_mat(0,1)=0.0;
72  rtn_mat(0,2)=0.0;
73  rtn_mat(1,0)=0.0;
74  rtn_mat(1,1)=std::exp(x(1));
75  rtn_mat(1,2)=0.0;
76  rtn_mat(2,0)=0.0;
77  rtn_mat(2,1)=0.0;
78  rtn_mat(2,2)=std::exp(x(2));
79 
80  return rtn_mat;
81 }
82 
83 template<typename data__>
85 {
86  Eigen::Matrix<data__, 3, 1> operator()(const Eigen::Matrix<data__, 3, 1> &x) const
87  {
89  }
90 };
91 
92 template<typename data__>
94 {
95  Eigen::Matrix<data__, 3, 3> operator()(const Eigen::Matrix<data__, 3, 1> &x) const
96  {
98  }
99 };
100 
101 template<typename data__>
102 Eigen::Matrix<data__, 3, 1> my_coupled_linear_system_function(const Eigen::Matrix<data__, 3, 1> &x)
103 {
104  Eigen::Matrix<data__, 3, 1> rtn_vec;
105 
106  rtn_vec(0,0)= 3*x(0)+2*x(1)+4*x(2);
107  rtn_vec(1,0)= 1*x(0)-4*x(1)+2*x(2);
108  rtn_vec(2,0)=-2*x(0)+3*x(1)-1*x(2);
109 
110  return rtn_vec;
111 }
112 
113 template<typename data__>
114 Eigen::Matrix<data__, 3, 3> my_coupled_linear_system_function_derivative(const Eigen::Matrix<data__, 3, 1> &)
115 {
116  Eigen::Matrix<data__, 3, 3> rtn_mat;
117 
118  rtn_mat(0,0)= 3.0;
119  rtn_mat(0,1)= 2.0;
120  rtn_mat(0,2)= 4.0;
121  rtn_mat(1,0)= 1.0;
122  rtn_mat(1,1)=-4.0;
123  rtn_mat(1,2)= 2.0;
124  rtn_mat(2,0)=-2.0;
125  rtn_mat(2,1)= 3.0;
126  rtn_mat(2,2)=-1.0;
127 
128  return rtn_mat;
129 }
130 
131 template<typename data__>
133 {
134  Eigen::Matrix<data__, 3, 1> operator()(const Eigen::Matrix<data__, 3, 1> &x) const
135  {
137  }
138 };
139 
140 template<typename data__>
142 {
143  Eigen::Matrix<data__, 3, 3> operator()(const Eigen::Matrix<data__, 3, 1> &x) const
144  {
146  }
147 };
148 
149 template<typename data__>
150 Eigen::Matrix<data__, 3, 1> my_coupled_nonlinear_system_function(const Eigen::Matrix<data__, 3, 1> &x)
151 {
152  Eigen::Matrix<data__, 3, 1> rtn_vec;
153 
154  rtn_vec(0,0)=std::exp(x(0))*cos(x(1));
155  rtn_vec(1,0)=x(0)*x(0)*std::log(x(1));
156  rtn_vec(2,0)=x(2);
157 
158  return rtn_vec;
159 }
160 
161 template<typename data__>
162 Eigen::Matrix<data__, 3, 3> my_coupled_nonlinear_system_function_derivative(const Eigen::Matrix<data__, 3, 1> &x)
163 {
164  Eigen::Matrix<data__, 3, 3> rtn_mat;
165 
166  rtn_mat(0,0)=std::exp(x(0))*std::cos(x(1));
167  rtn_mat(0,1)=-std::exp(x(0))*std::sin(x(1));
168  rtn_mat(0,2)=0.0;
169  rtn_mat(1,0)=2*x(0)*std::log(x(1));
170  rtn_mat(1,1)=x(0)*x(0)/x(1);
171  rtn_mat(1,2)=0.0;
172  rtn_mat(2,0)=0.0;
173  rtn_mat(2,1)=0.0;
174  rtn_mat(2,2)=1.0;
175 
176  return rtn_mat;
177 }
178 
179 template<typename data__>
181 {
182  Eigen::Matrix<data__, 3, 1> operator()(const Eigen::Matrix<data__, 3, 1> &x) const
183  {
185  }
186 };
187 
188 template<typename data__>
190 {
191  Eigen::Matrix<data__, 3, 3> operator()(const Eigen::Matrix<data__, 3, 1> &x) const
192  {
194  }
195 };
196 
197 template<typename data__>
198 class nls_test_suite : public Test::Suite
199 {
200  protected:
201  void AddTests(const float &)
202  {
209  }
210 
211  void AddTests(const double &)
212  {
219  }
220 
221  void AddTests(const long double &)
222  {
229  }
230 
231  public:
233  {
234  // add the tests
235  AddTests(data__());
236  }
238  {
239  }
240 
241  private:
243  {
244  data__ delta(std::sqrt(std::numeric_limits<data__>::epsilon())), rhs(0.5), root(0);
246  int stat;
247 
248  bm.set_absolute_tolerance(delta);
249  bm.set_max_iteration(200);
251 
252  // test using user defined function
253  bm.set_absolute_tolerance(delta);
254  bm.set_max_iteration(200);
256 
257  stat = bm.find_root(root, std::ptr_fun(my_function<data__>), rhs);
259  TEST_ASSERT_DELTA(root, std::acos(rhs), 2*delta);
260 
261  // test using functor
262  bm.set_absolute_tolerance(delta);
263  bm.set_max_iteration(200);
265 
266  stat = bm.find_root(root, my_functor<data__>(), rhs);
268  TEST_ASSERT_DELTA(root, std::acos(rhs), 2*delta);
269  }
270 
272  {
273  data__ delta(std::sqrt(std::numeric_limits<data__>::epsilon())), rhs(0.5), root(0);
275  int stat;
276 
277  nrm.set_absolute_tolerance(delta);
278  nrm.set_max_iteration(200);
279  nrm.set_initial_guess(static_cast<data__>(0.3)*eli::constants::math<data__>::pi_by_four());
280 
281  // test using user defined functions
282  stat = nrm.find_root(root, std::ptr_fun(my_function<data__>), std::ptr_fun(my_function_derivative<data__>), rhs);
284  TEST_ASSERT_DELTA(root, std::acos(rhs), 2*delta);
285 
286  nrm.set_max_iteration(2);
287  stat = nrm.find_root(root, std::ptr_fun(my_function<data__>), std::ptr_fun(my_function_derivative<data__>), rhs);
289 
290  nrm.set_max_iteration(200);
291  nrm.set_initial_guess(0);
292  stat = nrm.find_root(root, std::ptr_fun(my_function<data__>), std::ptr_fun(my_function_derivative<data__>), rhs);
294 
295  // test using functor
296  nrm.set_absolute_tolerance(delta);
297  nrm.set_max_iteration(200);
299 
300  stat = nrm.find_root(root, my_functor<data__>(), my_functor_derivative<data__>(), rhs);
302  TEST_ASSERT_DELTA(root, std::acos(rhs), 2*delta);
303  }
304 
306  {
307  data__ delta(std::sqrt(std::numeric_limits<data__>::epsilon())), rhs(0.5), root(0);
309  int stat;
310 
311  sm.set_absolute_tolerance(delta);
312  sm.set_max_iteration(200);
314 
315  // test using user defined function
316  sm.set_absolute_tolerance(delta);
317  sm.set_max_iteration(200);
319 
320  stat = sm.find_root(root, std::ptr_fun(my_function<data__>), rhs);
322  TEST_ASSERT_DELTA(root, std::acos(rhs), 2*delta);
323 
324  // test using functor
325  sm.set_absolute_tolerance(delta);
326  sm.set_max_iteration(200);
328 
329  stat = sm.find_root(root, my_functor<data__>(), rhs);
331  TEST_ASSERT_DELTA(root, std::acos(rhs), 2*delta);
332  }
333 
335  {
337  data__ delta(std::sqrt(std::numeric_limits<data__>::epsilon())), rhs(0.5), root;
338  nrcm_type nrcm;
339  int stat;
340 
341  nrcm.set_absolute_tolerance(delta);
342  nrcm.set_max_iteration(200);
343  nrcm.set_initial_guess(eli::constants::math<data__>::two_pi()+static_cast<data__>(0.3)*eli::constants::math<data__>::pi_by_four());
344  nrcm.set_lower_condition(eli::constants::math<data__>::two_pi(), nrcm_type::NRC_EXCLUSIVE);
345  nrcm.set_upper_condition(eli::constants::math<data__>::pi()*3, nrcm_type::NRC_EXCLUSIVE);
346 
347  // test using user defined functions
348  stat = nrcm.find_root(root, std::ptr_fun(my_function<data__>), std::ptr_fun(my_function_derivative<data__>), rhs);
349  TEST_ASSERT(stat==nrcm_type::converged);
350  TEST_ASSERT_DELTA(root, eli::constants::math<data__>::two_pi()+std::acos(rhs), 2*delta);
351 
352  nrcm.set_max_iteration(2);
353  stat = nrcm.find_root(root, std::ptr_fun(my_function<data__>), std::ptr_fun(my_function_derivative<data__>), rhs);
354  TEST_ASSERT(stat==nrcm_type::max_iteration);
355 
356  nrcm.set_max_iteration(100);
357  nrcm.set_initial_guess(eli::constants::math<data__>::two_pi()+static_cast<data__>(0.3)*eli::constants::math<data__>::pi_by_four());
358  nrcm.set_upper_condition(static_cast<data__>(0.1)+eli::constants::math<data__>::two_pi(), nrcm_type::NRC_EXCLUSIVE);
359  stat = nrcm.find_root(root, std::ptr_fun(my_function<data__>), std::ptr_fun(my_function_derivative<data__>), rhs);
360  TEST_ASSERT(stat==nrcm_type::hit_constraint);
361 
362  data__ rhs2(cos(eli::constants::math<data__>::pi()+static_cast<data__>(0.001)));
363  nrcm.set_initial_guess(eli::constants::math<data__>::pi());
364  nrcm.set_periodic_condition(eli::constants::math<data__>::pi(), eli::constants::math<data__>::pi()*3);
365  stat = nrcm.find_root(root, std::ptr_fun(my_function<data__>), std::ptr_fun(my_function_derivative<data__>), rhs2);
366  TEST_ASSERT(stat==nrcm_type::converged);
367 
368  // test using functor
369  nrcm.set_absolute_tolerance(delta);
370  nrcm.set_max_iteration(200);
371  nrcm.set_lower_condition(eli::constants::math<data__>::two_pi(), nrcm_type::NRC_EXCLUSIVE);
372  nrcm.set_upper_condition(eli::constants::math<data__>::pi()*3, nrcm_type::NRC_EXCLUSIVE);
373  nrcm.set_initial_guess(eli::constants::math<data__>::two_pi()+static_cast<data__>(0.3)*eli::constants::math<data__>::pi_by_four());
374 
375  stat = nrcm.find_root(root, my_functor<data__>(), my_functor_derivative<data__>(), rhs);
376  TEST_ASSERT(stat==nrcm_type::converged);
377  TEST_ASSERT_DELTA(root, eli::constants::math<data__>::two_pi()+std::acos(rhs), 2*delta);
378  }
379 
381  {
383 
384  data__ delta(std::sqrt(std::numeric_limits<data__>::epsilon()));
385  nr_system nrm;
386  typename nr_system::solution_matrix rhs, root, x0, x_exact;
387  int stat;
388 
389  nrm.set_absolute_tolerance(delta);
390  nrm.set_max_iteration(200);
391  nrm.set_norm_type(nr_system::max_norm);
392 
393  // decoupled system
394  // set right hand side, initial guess & exact answer
395  x_exact << 2, 3, 1;
396  rhs = my_decoupled_system_function<data__>(x_exact);
397  x0 << 1.5, 2.5, 1.5;
398  nrm.set_initial_guess(x0);
399 
400  // test using user defined functions
401  stat = nrm.find_root(root, std::ptr_fun(my_decoupled_system_function<data__>), std::ptr_fun(my_decoupled_system_function_derivative<data__>), rhs);
402  TEST_ASSERT(stat==nr_system::converged);
403  TEST_ASSERT(nrm.get_iteration_count()<nrm.get_max_iteration());
404  TEST_ASSERT((x_exact-root).norm()<=2*delta);
405 
406  nrm.set_max_iteration(2);
407  stat = nrm.find_root(root, std::ptr_fun(my_decoupled_system_function<data__>), std::ptr_fun(my_decoupled_system_function_derivative<data__>), rhs);
408  TEST_ASSERT(stat==nr_system::max_iteration);
409 
410  // test using functor
411  nrm.set_absolute_tolerance(delta);
412  nrm.set_max_iteration(200);
413  nrm.set_initial_guess(x0);
414 
416  TEST_ASSERT(stat==nr_system::converged);
417  TEST_ASSERT(nrm.get_iteration_count()<nrm.get_max_iteration());
418  TEST_ASSERT((x_exact-root).norm()<=2*delta);
419 
420  // linear coupled system
421  // set right hand side, initial guess & exact answer
422  x_exact << 2, 3, 1;
423  rhs = my_coupled_linear_system_function<data__>(x_exact);
424  x0 << 1.5, 2.5, 1.5;
425  nrm.set_initial_guess(x0);
426 
427  // test using user defined functions
428  stat = nrm.find_root(root, std::ptr_fun(my_coupled_linear_system_function<data__>), std::ptr_fun(my_coupled_linear_system_function_derivative<data__>), rhs);
429  TEST_ASSERT(stat==nr_system::converged);
430  TEST_ASSERT(nrm.get_iteration_count()<2);
431  TEST_ASSERT((x_exact-root).norm()<delta);
432 
433  // test using functor
434  nrm.set_absolute_tolerance(delta);
435  nrm.set_max_iteration(200);
436  nrm.set_initial_guess(x0);
437 
439  TEST_ASSERT(stat==nr_system::converged);
440  TEST_ASSERT(nrm.get_iteration_count()<2);
441  TEST_ASSERT((x_exact-root).norm()<delta);
442 
443  // nonlinear coupled system
444  // set right hand side, initial guess & exact answer
445  x_exact << 2, 3, 1;
446  rhs = my_coupled_nonlinear_system_function<data__>(x_exact);
447  x0 << 1.5, 2.5, 1.5;
448  nrm.set_initial_guess(x0);
449 
450  // test using user defined functions
451  stat = nrm.find_root(root, std::ptr_fun(my_coupled_nonlinear_system_function<data__>), std::ptr_fun(my_coupled_nonlinear_system_function_derivative<data__>), rhs);
452  TEST_ASSERT(stat==nr_system::converged);
453  TEST_ASSERT(nrm.get_iteration_count()<nrm.get_max_iteration());
454  TEST_ASSERT((x_exact-root).norm()<delta);
455 
456  // test using functor
457  nrm.set_absolute_tolerance(delta);
458  nrm.set_max_iteration(200);
459  nrm.set_initial_guess(x0);
460 
462  TEST_ASSERT(stat==nr_system::converged);
463  TEST_ASSERT(nrm.get_iteration_count()<nrm.get_max_iteration());
464  TEST_ASSERT((x_exact-root).norm()<delta);
465  }
466 
468  {
470 
471  data__ delta(std::sqrt(std::numeric_limits<data__>::epsilon()));
472  nrcs_type nrcm;
473  typename nrcs_type::solution_matrix rhs, root, x0, x_exact;
474  int stat;
475 
476  nrcm.set_absolute_tolerance(delta);
477  nrcm.set_max_iteration(200);
478  nrcm.set_norm_type(nrcs_type::max_norm);
479  nrcm.set_lower_condition(0, 0, nrcs_type::NRC_EXCLUSIVE);
480  nrcm.set_upper_condition(0, 4, nrcs_type::NRC_EXCLUSIVE);
481 
482  // decoupled system
483  // set right hand side, initial guess & exact answer
484  x_exact << 2, 3, 1;
485  rhs = my_decoupled_system_function<data__>(x_exact);
486  x0 << 1.5, 2.5, 1.5;
487  nrcm.set_initial_guess(x0);
488 
489  // test using user defined functions
490  stat = nrcm.find_root(root, std::ptr_fun(my_decoupled_system_function<data__>), std::ptr_fun(my_decoupled_system_function_derivative<data__>), rhs);
491  TEST_ASSERT(stat==nrcs_type::converged);
492  TEST_ASSERT(nrcm.get_iteration_count()<nrcm.get_max_iteration());
493  TEST_ASSERT((x_exact-root).norm()<=2*delta);
494 
495  nrcm.set_max_iteration(2);
496  stat = nrcm.find_root(root, std::ptr_fun(my_decoupled_system_function<data__>), std::ptr_fun(my_decoupled_system_function_derivative<data__>), rhs);
497  TEST_ASSERT(stat==nrcs_type::max_iteration);
498 
499  // test using functor
500  nrcm.set_absolute_tolerance(delta);
501  nrcm.set_max_iteration(200);
502  nrcm.set_initial_guess(x0);
503 
505  TEST_ASSERT(stat==nrcs_type::converged);
506  TEST_ASSERT(nrcm.get_iteration_count()<nrcm.get_max_iteration());
507  TEST_ASSERT((x_exact-root).norm()<=2*delta);
508 
509  // linear coupled system
510  // set right hand side, initial guess & exact answer
511  x_exact << 2, 3, 1;
512  rhs = my_coupled_linear_system_function<data__>(x_exact);
513  x0 << 1.5, 2.5, 1.5;
514  nrcm.set_initial_guess(x0);
515 
516  // test using user defined functions
517  stat = nrcm.find_root(root, std::ptr_fun(my_coupled_linear_system_function<data__>), std::ptr_fun(my_coupled_linear_system_function_derivative<data__>), rhs);
518  TEST_ASSERT(stat==nrcs_type::converged);
519  TEST_ASSERT(nrcm.get_iteration_count()<2);
520  TEST_ASSERT((x_exact-root).norm()<delta);
521 
522  // test using functor
523  nrcm.set_absolute_tolerance(delta);
524  nrcm.set_max_iteration(200);
525  nrcm.set_initial_guess(x0);
526 
528  TEST_ASSERT(stat==nrcs_type::converged);
529  TEST_ASSERT(nrcm.get_iteration_count()<2);
530  TEST_ASSERT((x_exact-root).norm()<delta);
531 
532  // nonlinear coupled system
533  // set right hand side, initial guess & exact answer
534  x_exact << 2, 3, 1;
535  rhs = my_coupled_nonlinear_system_function<data__>(x_exact);
536  x0 << 1.5, 2.5, 1.5;
537  nrcm.set_initial_guess(x0);
538 
539  // test using user defined functions
540  stat = nrcm.find_root(root, std::ptr_fun(my_coupled_nonlinear_system_function<data__>), std::ptr_fun(my_coupled_nonlinear_system_function_derivative<data__>), rhs);
541  TEST_ASSERT(stat==nrcs_type::converged);
542  TEST_ASSERT(nrcm.get_iteration_count()<nrcm.get_max_iteration());
543  TEST_ASSERT((x_exact-root).norm()<delta);
544 
545  // test using functor
546  nrcm.set_absolute_tolerance(delta);
547  nrcm.set_max_iteration(200);
548  nrcm.set_initial_guess(x0);
549 
551  TEST_ASSERT(stat==nrcs_type::converged);
552  TEST_ASSERT(nrcm.get_iteration_count()<nrcm.get_max_iteration());
553  TEST_ASSERT((x_exact-root).norm()<delta);
554  }
555 };
556 
557 #endif
void set_bounds(const data__ &xl, const data__ &xh)
Definition: bisection_method.hpp:68
Definition: nls_test_suite.hpp:36
Definition: secant_method.hpp:27
nls_test_suite()
Definition: nls_test_suite.hpp:232
int find_root(data__ &root, const f__ &fun, const data__ &f0) const
Definition: secant_method.hpp:59
Eigen::Matrix< data__, 3, 3 > my_coupled_linear_system_function_derivative(const Eigen::Matrix< data__, 3, 1 > &)
Definition: nls_test_suite.hpp:114
void newton_raphson_method_test()
Definition: nls_test_suite.hpp:271
Eigen::Matrix< data__, 3, 3 > my_coupled_nonlinear_system_function_derivative(const Eigen::Matrix< data__, 3, 1 > &x)
Definition: nls_test_suite.hpp:162
Definition: newton_raphson_method.hpp:27
~nls_test_suite()
Definition: nls_test_suite.hpp:237
void secant_method_test()
Definition: nls_test_suite.hpp:305
Eigen::Matrix< data__, 3, 1 > operator()(const Eigen::Matrix< data__, 3, 1 > &x) const
Definition: nls_test_suite.hpp:182
void AddTests(const long double &)
Definition: nls_test_suite.hpp:221
Definition: nls_test_suite.hpp:93
int find_root(data__ &root, const f__ &fun, const data__ &f0) const
Definition: bisection_method.hpp:81
Eigen::Matrix< data__, 3, 1 > my_coupled_nonlinear_system_function(const Eigen::Matrix< data__, 3, 1 > &x)
Definition: nls_test_suite.hpp:150
void newton_raphson_constrained_system_method_test()
Definition: nls_test_suite.hpp:467
void newton_raphson_constrained_method_test()
Definition: nls_test_suite.hpp:334
Definition: newton_raphson_constrained_system_method.hpp:30
Eigen::Matrix< data__, 3, 1 > operator()(const Eigen::Matrix< data__, 3, 1 > &x) const
Definition: nls_test_suite.hpp:86
Definition: nls_test_suite.hpp:141
data__ operator()(const data__ &x) const
Definition: nls_test_suite.hpp:38
Definition: math.hpp:25
Definition: nls_test_suite.hpp:189
Eigen::Matrix< data__, 3, 3 > operator()(const Eigen::Matrix< data__, 3, 1 > &x) const
Definition: nls_test_suite.hpp:95
void AddTests(const double &)
Definition: nls_test_suite.hpp:211
Definition: nls_test_suite.hpp:198
Definition: newton_raphson_constrained_method.hpp:30
void set_max_iteration(const iteration_type &mi)
Definition: iterative_root_base.hpp:207
void newton_raphson_system_method_test()
Definition: nls_test_suite.hpp:380
data__ my_function(const data__ &x)
Definition: nls_test_suite.hpp:24
Definition: nls_test_suite.hpp:45
data__ my_function_derivative(const data__ &x)
Definition: nls_test_suite.hpp:30
Eigen::Matrix< data__, 3, 1 > my_coupled_linear_system_function(const Eigen::Matrix< data__, 3, 1 > &x)
Definition: nls_test_suite.hpp:102
void set_initial_guesses(const data__ &xg1, const data__ &xg2)
Definition: secant_method.hpp:46
void bisection_method_test()
Definition: nls_test_suite.hpp:242
void set_absolute_tolerance(const tolerance_type &abs_tol)
Definition: iterative_root_base.hpp:194
Definition: nls_test_suite.hpp:180
Definition: nls_test_suite.hpp:84
Definition: bisection_method.hpp:29
Eigen::Matrix< data__, 3, 1 > operator()(const Eigen::Matrix< data__, 3, 1 > &x) const
Definition: nls_test_suite.hpp:134
int find_root(data_type &root, const f__ &fun, const g__ &fprime, const data_type &f0) const
Definition: newton_raphson_method.hpp:59
Definition: nls_test_suite.hpp:132
Eigen::Matrix< data__, 3, 3 > operator()(const Eigen::Matrix< data__, 3, 1 > &x) const
Definition: nls_test_suite.hpp:143
Eigen::Matrix< data__, 3, 3 > my_decoupled_system_function_derivative(const Eigen::Matrix< data__, 3, 1 > &x)
Definition: nls_test_suite.hpp:66
data__ operator()(const data__ &x) const
Definition: nls_test_suite.hpp:47
Definition: newton_raphson_system_method.hpp:27
void AddTests(const float &)
Definition: nls_test_suite.hpp:201
void set_initial_guess(const data_type &xg)
Definition: newton_raphson_method.hpp:48
Eigen::Matrix< data__, 3, 1 > my_decoupled_system_function(const Eigen::Matrix< data__, 3, 1 > &x)
Definition: nls_test_suite.hpp:54
Eigen::Matrix< data__, 3, 3 > operator()(const Eigen::Matrix< data__, 3, 1 > &x) const
Definition: nls_test_suite.hpp:191