Bertini 2 - C++ Core
Software for Numerical Algebraic Geometry
Loading...
Searching...
No Matches
io/parsing/settings_parsers/tracking.hpp
Go to the documentation of this file.
1//This file is part of Bertini 2.
2//
3//bertini2/io/parsing/settings_parsers/tracking.hpp is free software: you can redistribute it and/or modify
4//it under the terms of the GNU General Public License as published by
5//the Free Software Foundation, either version 3 of the License, or
6//(at your option) any later version.
7//
8//bertini2/io/parsing/settings_parsers/tracking.hpp is distributed in the hope that it will be useful,
9//but WITHOUT ANY WARRANTY; without even the implied warranty of
10//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11//GNU General Public License for more details.
12//
13//You should have received a copy of the GNU General Public License
14//along with bertini2/io/parsing/settings_parsers/tracking.hpp. If not, see <http://www.gnu.org/licenses/>.
15//
16// Copyright(C) 2015 - 2017 by Bertini2 Development Team
17//
18// See <http://www.gnu.org/licenses/> for a copy of the license,
19// as well as COPYING. Bertini2 is provided with permitted
20// additional terms in the b2/licenses/ directory.
21
22
28
29#pragma once
30
31
32#include "bertini2/io/parsing/settings_parsers/base.hpp"
33#include "bertini2/trackers/config.hpp"
34
35
36namespace bertini {
37 namespace parsing {
38 namespace classic {
39
40
41 namespace {
42 using namespace bertini::tracking;
43 }
67 template<typename Iterator, typename Skipper> //boost::spirit::unused_type
68 struct ConfigSettingParser<Iterator, PrecisionType, Skipper> : qi::grammar<Iterator, PrecisionType(), Skipper>
69 {
70
71 ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "PrecisionType")
72 {
73 namespace phx = boost::phoenix;
74 using qi::_1;
75 using qi::_2;
76 using qi::_3;
77 using qi::_4;
78 using qi::_val;
79 using qi::eps;
80 using qi::lit;
81 using qi::char_;
82 using qi::omit;
83 using boost::spirit::lexeme;
84 using boost::spirit::as_string;
85 using boost::spirit::ascii::no_case;
86
87 precisiontype_.add("0", PrecisionType::Fixed);
88 precisiontype_.add("1", PrecisionType::Adaptive);
89 precisiontype_.add("2", PrecisionType::Adaptive);
90
91
92
93
94 root_rule_.name("config::PrecisionType");
95
96 root_rule_ = (config_name_[_val = _1] >> -no_setting_) | no_setting_[_val = PrecisionType::Adaptive];
97
98 config_name_.name("precisiontype_");
99 config_name_ = *(char_ - (no_case["mptype"]>>':')) >> (no_case["mptype"] >> ':') >> precisiontype_[_val = _1] >> ';';
100
101 no_setting_.name("no_setting_");
102 no_setting_ = *(char_ - no_case["mptype:"]);
103
104 no_decl_.name("no_decl_");
105 no_decl_ = *(char_);
106
107
108
109
110 using phx::val;
111 using phx::construct;
112 using namespace qi::labels;
113 qi::on_error<qi::fail>
114 ( root_rule_ ,
115 std::cout<<
116 val("config parser could not complete parsing. Expecting ")<<
117 _4<<
118 val(" here: ")<<
119 construct<std::string>(_3,_2)<<
120 std::endl
121 );
122
123
124
125 }
126
127
128 private:
129 qi::rule<Iterator, PrecisionType(), ascii::space_type > root_rule_, config_name_;
130 qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_;
131
132 qi::symbols<char,PrecisionType> precisiontype_;
133
134
135 }; //re: PrecisionTypeParser
136
137
138
139
140
141
142
143
147 template<typename Iterator, typename Skipper> //boost::spirit::unused_type
148 struct ConfigSettingParser<Iterator, Predictor, Skipper> : qi::grammar<Iterator, Predictor(), Skipper>
149 {
150
151 ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "config::PredictorType")
152 {
153 namespace phx = boost::phoenix;
154 using qi::_1;
155 using qi::_2;
156 using qi::_3;
157 using qi::_4;
158 using qi::_val;
159 using qi::eps;
160 using qi::lit;
161 using qi::char_;
162 using qi::omit;
163 using boost::spirit::lexeme;
164 using boost::spirit::as_string;
165 using boost::spirit::ascii::no_case;
166
167 predictor_.add("-1", Predictor::Constant);
168 predictor_.add("0", Predictor::Euler);
169 predictor_.add("1", Predictor::Heun);
170 predictor_.add("2", Predictor::RK4);
171 predictor_.add("3", Predictor::Heun);
172 predictor_.add("4", Predictor::RKNorsett34);
173 predictor_.add("5", Predictor::RKF45);
174 predictor_.add("6", Predictor::RKCashKarp45);
175 predictor_.add("7", Predictor::RKDormandPrince56);
176 predictor_.add("8", Predictor::RKVerner67);
177
178
179 std::string setting_name = "odepredictor";
180
181
182 root_rule_.name("Predictor");
183
184 root_rule_ = (config_name_[_val = _1] >> -no_setting_) | no_setting_[_val = Predictor::RKF45];
185
186 config_name_.name("predictor_");
187 config_name_ = *(char_ - (no_case[setting_name] >> ':')) >> (no_case[setting_name] >> ':') >> predictor_[_val = _1] >> ';';
188
189 no_setting_.name("no_setting_");
190 no_setting_ = *(char_ - no_case[setting_name]);
191
192 no_decl_.name("no_decl_");
193 no_decl_ = *(char_);
194
195
196
197
198 using phx::val;
199 using phx::construct;
200 using namespace qi::labels;
201 qi::on_error<qi::fail>
202 ( root_rule_ ,
203 std::cout<<
204 val("config parser could not complete parsing. Expecting ")<<
205 _4<<
206 val(" here: ")<<
207 construct<std::string>(_3,_2)<<
208 std::endl
209 );
210
211
212
213 }
214
215
216 private:
217 qi::rule<Iterator, Predictor(), ascii::space_type > root_rule_, config_name_;
218 qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_;
219
220 qi::symbols<char,Predictor> predictor_;
221
222
223 }; //re: PredictorTypeParser
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
245 template<typename Iterator, typename Skipper> //boost::spirit::unused_type
246 struct ConfigSettingParser<Iterator, SteppingConfig, Skipper> : qi::grammar<Iterator, SteppingConfig(), Skipper>
247 {
248
249 private:
250 using T = double;
251 using R = mpq_rational;
252
253 public:
254
255 ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "config::SteppingType")
256 {
257
258 namespace phx = boost::phoenix;
259 using qi::_1;
260 using qi::_2;
261 using qi::_3;
262 using qi::_4;
263 using qi::_val;
264 using qi::eps;
265 using qi::lit;
266 using qi::char_;
267 using qi::omit;
268 using boost::spirit::lexeme;
269 using boost::spirit::as_string;
270 using boost::spirit::ascii::no_case;
271
272
273
274 std::string maxstep_name = "maxstepsize";
275 std::string stepsuccess_name = "stepsuccessfactor";
276 std::string stepfail_name = "stepfailfactor";
277 std::string stepsincrease_name = "stepsforincrease";
278 std::string maxnumsteps_name = "maxnumbersteps";
279
280
281 root_rule_.name("SteppingConfig");
282
283 root_rule_ = ((max_step_size_[phx::bind( [this](SteppingConfig & S, T num)
284 {
285 S.max_step_size = num;
286 }, _val, _1 )]
287 ^ stepsize_success_[phx::bind( [this](SteppingConfig & S, R num)
288 {
289 S.step_size_success_factor = num;
290 }, _val, _1 )]
291 ^ stepsize_fail_[phx::bind( [this](SteppingConfig & S, R num)
292 {
293 S.step_size_fail_factor = num;
294 }, _val, _1 )]
295 ^ steps_increase_[phx::bind( [this](SteppingConfig & S, unsigned num)
296 {
297 S.consecutive_successful_steps_before_stepsize_increase = num;
298 }, _val, _1 )]
299 ^ max_num_steps_[phx::bind( [this](SteppingConfig & S, unsigned num)
300 {
301 S.max_num_steps = num;
302 }, _val, _1 )])
303
304 >> -no_setting_)
305 | no_setting_;
306
307
308 all_names_ = (no_case[maxstep_name] >> ':') | (no_case[stepsuccess_name] >> ':')|
309 (no_case[stepfail_name] >> ':')| (no_case[stepsincrease_name] >> ':') | (no_case[maxnumsteps_name] >> ':');
310
311 max_step_size_.name("max_step_size_");
312 max_step_size_ = *(char_ - all_names_) >> (no_case[maxstep_name] >> ':')
313 >> mpfr_rules.rational[phx::bind( [this](T & num, std::string const& str)
314 {
315 num = bertini::NumTraits<T>::FromString(str);
316 }, _val, _1 )] >> ';';
317
318 stepsize_success_.name("stepsize_success_");
319 stepsize_success_ = *(char_ - all_names_) >> (no_case[stepsuccess_name] >> ':')
320 >> mpfr_rules.rational[phx::bind( [this](R & num, std::string const& str)
321 {
322 num = bertini::NumTraits<double>::FromString(str);
323 }, _val, _1 )] >> ';';
324
325 stepsize_fail_.name("stepsize_fail_");
326 stepsize_fail_ = *(char_ - all_names_) >> (no_case[stepfail_name] >> ':')
327 >> mpfr_rules.rational[phx::bind( [this](R & num, std::string const& str)
328 {
329 num = bertini::NumTraits<double>::FromString(str);
330 }, _val, _1 )] >> ';';
331
332 steps_increase_.name("steps_increase_");
333 steps_increase_ = *(char_ - all_names_) >> (no_case[stepsincrease_name] >> ':') >> qi::uint_[_val=_1] >> ';';
334
335 max_num_steps_.name("max_num_steps_");
336 max_num_steps_ = *(char_ - all_names_) >> (no_case[maxnumsteps_name] >> ':') >> qi::uint_[_val=_1] >> ';';
337
338 no_setting_.name("no_setting_");
339 no_setting_ = *(char_ - all_names_);
340
341 no_decl_.name("no_decl_");
342 no_decl_ = *(char_);
343
344
345
346
347
348 using phx::val;
349 using phx::construct;
350 using namespace qi::labels;
351 qi::on_error<qi::fail>
352 ( root_rule_ ,
353 std::cout<<
354 val("config parser could not complete parsing. Expecting ")<<
355 _4<<
356 val(" here: ")<<
357 construct<std::string>(_3,_2)<<
358 std::endl
359 );
360
361
362
363 }
364
365
366 private:
367 qi::rule<Iterator, SteppingConfig(), ascii::space_type > root_rule_;
368 qi::rule<Iterator, T(), ascii::space_type > max_step_size_;
369 qi::rule<Iterator, R(), ascii::space_type > stepsize_success_, stepsize_fail_;
370 qi::rule<Iterator, unsigned int(), ascii::space_type > steps_increase_, max_num_steps_;
371 qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_, all_names_;
372 rules::LongNum<Iterator> mpfr_rules;
373
374
375
376 }; //re: SteppingParser
377
378
379
380
381
385 template<typename Iterator, typename Skipper> //boost::spirit::unused_type
386 struct ConfigSettingParser<Iterator, NewtonConfig, Skipper> : qi::grammar<Iterator, NewtonConfig(), Skipper>
387 {
388
389 ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "config::NewtonType")
390 {
391 namespace phx = boost::phoenix;
392 using qi::_1;
393 using qi::_2;
394 using qi::_3;
395 using qi::_4;
396 using qi::_val;
397 using qi::eps;
398 using qi::lit;
399 using qi::char_;
400 using qi::omit;
401 using boost::spirit::lexeme;
402 using boost::spirit::as_string;
403 using boost::spirit::ascii::no_case;
404
405
406
407 std::string maxits_name = "maxnewtonits";
408
409
410 root_rule_.name("NewtonConfig");
411
412 root_rule_ = (max_its_[phx::bind( [this](NewtonConfig & S, unsigned num)
413 {
414 S.max_num_newton_iterations = num;
415 }, _val, _1 )]
416
417 >> -no_setting_)
418 | no_setting_;
419
420
421
422 all_names_ = eps >> (no_case[maxits_name] >> ':');
423
424 max_its_.name("max_its_");
425 max_its_ = *(char_ - no_case[maxits_name]) >> (no_case[maxits_name] >> ':') >> qi::uint_[_val=_1] >> ';';
426
427 no_setting_.name("no_setting_");
428 no_setting_ = *(char_ - all_names_);
429
430 no_decl_.name("no_decl_");
431 no_decl_ = *(char_);
432
433
434
435
436
437 using phx::val;
438 using phx::construct;
439 using namespace qi::labels;
440 qi::on_error<qi::fail>
441 ( root_rule_ ,
442 std::cout<<
443 val("config parser could not complete parsing. Expecting ")<<
444 _4<<
445 val(" here: ")<<
446 construct<std::string>(_3,_2)<<
447 std::endl
448 );
449
450
451
452 }
453
454
455 private:
456 qi::rule<Iterator, NewtonConfig(), Skipper> root_rule_;
457 qi::rule<Iterator, unsigned int(), ascii::space_type > max_its_;
458 qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_, all_names_;
459 }; //re: NewtonParser
460
461
462
463
468 template<typename Iterator, typename Skipper>
469 struct ConfigSettingParser<Iterator, FixedPrecisionConfig, Skipper> : qi::grammar<Iterator, FixedPrecisionConfig(), Skipper>
470 {
471
472 ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "config::FixedPrecision")
473 {
474 namespace phx = boost::phoenix;
475 using qi::_1;
476 using qi::_2;
477 using qi::_3;
478 using qi::_4;
479 using qi::_val;
480 using qi::eps;
481 using qi::lit;
482 using qi::char_;
483 using qi::omit;
484 using boost::spirit::lexeme;
485 using boost::spirit::as_string;
486 using boost::spirit::ascii::no_case;
487
488
489
490 root_rule_.name("config::FixedPrecision");
491 root_rule_ = eps[_val = FixedPrecisionConfig()] >> omit[*(char_)];
492
493
494
495 using phx::val;
496 using phx::construct;
497 using namespace qi::labels;
498 qi::on_error<qi::fail>
499 ( root_rule_ ,
500 std::cout<<
501 val("config parser could not complete parsing. Expecting ")<<
502 _4<<
503 val(" here: ")<<
504 construct<std::string>(_3,_2)<<
505 std::endl
506 );
507 }
508
509
510 private:
511 qi::rule<Iterator, FixedPrecisionConfig(), ascii::space_type > root_rule_;
512 }; //re: FixedPrecisionConfig Parser
513
514
515
516
517
518
519
520 using AdaptiveMultiplePrecisionConfig = AdaptiveMultiplePrecisionConfig;
521 template<typename Iterator, typename Skipper>
522 struct ConfigSettingParser<Iterator, AdaptiveMultiplePrecisionConfig, Skipper> : qi::grammar<Iterator, AdaptiveMultiplePrecisionConfig(), Skipper>
523 {
524
525 ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "AdaptiveMultiplePrecisionConfig")
526 {
527 using T = double;
528
529 namespace phx = boost::phoenix;
530 using qi::_1;
531 using qi::_2;
532 using qi::_3;
533 using qi::_4;
534 using qi::_val;
535 using qi::eps;
536 using qi::lit;
537 using qi::char_;
538 using qi::omit;
539 using boost::spirit::lexeme;
540 using boost::spirit::as_string;
541 using boost::spirit::ascii::no_case;
542
543
544
545 std::string coefficient_bound_name = "coefficientbound";
546 std::string degree_bound_name = "degreebound";
547 std::string lin_solve_error_bnd_name = "epsilon";
548 std::string jac_eval_err_bnd_name = "phi";
549 std::string func_eval_err_bnd_name = "psi";
550 std::string safety_one_name = "ampsafetydigits1";
551 std::string safety_two_name = "ampsafetydigits2";
552 std::string max_prec_name = "ampmaxprec";
553 std::string consec_steps_prec_dec_name = "maxstepsprecisiondecrease";
554 std::string max_num_prec_decs_name = "maxnumprecdecreases";
555
556 root_rule_.name("config::AMP");
557
558 root_rule_ = ((coefficient_bound_[phx::bind( [this](AdaptiveMultiplePrecisionConfig & S, T num)
559 {
560 S.coefficient_bound = num;
561 }, _val, _1 )]
562 ^ degree_bound_[phx::bind( [this](AdaptiveMultiplePrecisionConfig & S, T num)
563 {
564 S.degree_bound = num;
565 }, _val, _1 )]
566 ^ lin_solve_error_bnd_[phx::bind( [this](AdaptiveMultiplePrecisionConfig & S, T num)
567 {
568 S.epsilon = num;
569 }, _val, _1 )]
570 ^ jac_eval_err_bnd_[phx::bind( [this](AdaptiveMultiplePrecisionConfig & S, T num)
571 {
572 S.Phi = num;
573 }, _val, _1 )]
574 ^ func_eval_err_bnd_[phx::bind( [this](AdaptiveMultiplePrecisionConfig & S, T num)
575 {
576 S.Psi = num;
577 }, _val, _1 )]
578 ^ safety_one_[phx::bind( [this](AdaptiveMultiplePrecisionConfig & S, int num)
579 {
580 S.safety_digits_1 = num;
581 }, _val, _1 )]
582 ^ safety_two_[phx::bind( [this](AdaptiveMultiplePrecisionConfig & S, int num)
583 {
584 S.safety_digits_2 = num;
585 }, _val, _1 )]
586 ^ max_prec_[phx::bind( [this](AdaptiveMultiplePrecisionConfig & S, unsigned num)
587 {
588 S.maximum_precision = num;
589 }, _val, _1 )]
590 ^ consec_steps_prec_dec_[phx::bind( [this](AdaptiveMultiplePrecisionConfig & S, unsigned num)
591 {
592 S.consecutive_successful_steps_before_precision_decrease = num;
593 }, _val, _1 )]
594 ^ max_num_prec_decs_[phx::bind( [this](AdaptiveMultiplePrecisionConfig & S, unsigned num)
595 {
596 S.max_num_precision_decreases = num;
597 }, _val, _1 )]
598 )
599 >> -no_setting_) | no_setting_;
600
601 all_names_ = (no_case[coefficient_bound_name] >> ':') |
602 (no_case[degree_bound_name] >> ':') |
603 (no_case[lin_solve_error_bnd_name] >> ':') |
604 (no_case[jac_eval_err_bnd_name] >> ':') |
605 (no_case[func_eval_err_bnd_name] >> ':') |
606 (no_case[safety_one_name] >> ':') |
607 (no_case[safety_two_name] >> ':') |
608 (no_case[max_prec_name] >> ':') |
609 (no_case[consec_steps_prec_dec_name] >> ':') |
610 (no_case[max_num_prec_decs_name] >> ':')
611 ;
612
613
614 auto str_to_T = [this](T & num, std::string const& str)
615 {
616 // std::cout << str << std::endl;
617 num = bertini::NumTraits<T>::FromString(str);
618 };
619
620
621 degree_bound_.name("degree_bound_");
622 degree_bound_ = *(char_ - all_names_) >> (no_case[degree_bound_name] >> ':')
623 >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
624
625 coefficient_bound_.name("coefficient_bound_");
626 coefficient_bound_ = *(char_ - all_names_) >> (no_case[coefficient_bound_name] >> ':')
627 >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
628
629 lin_solve_error_bnd_.name("lin_solve_error_bnd_");
630 lin_solve_error_bnd_ = *(char_ - all_names_) >> (no_case[lin_solve_error_bnd_name] >> ':')
631 >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
632
633 jac_eval_err_bnd_.name("jac_eval_err_bnd_");
634 jac_eval_err_bnd_ = *(char_ - all_names_) >> (no_case[jac_eval_err_bnd_name] >> ':')
635 >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
636
637 func_eval_err_bnd_.name("func_eval_err_bnd_");
638 func_eval_err_bnd_ = *(char_ - all_names_) >> (no_case[func_eval_err_bnd_name] >> ':')
639 >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
640
641 safety_one_.name("safety_one_");
642 safety_one_ = *(char_ - all_names_) >> (no_case[safety_one_name] >> ':') >> qi::int_[_val=_1] >> ';';
643
644 safety_two_.name("safety_two_");
645 safety_two_ = *(char_ - all_names_) >> (no_case[safety_two_name] >> ':') >> qi::int_[_val=_1] >> ';';
646
647 max_prec_.name("max_prec_");
648 max_prec_ = *(char_ - all_names_) >> (no_case[max_prec_name] >> ':') >> qi::uint_[_val=_1] >> ';';
649
650 consec_steps_prec_dec_.name("consec_steps_prec_dec_");
651 consec_steps_prec_dec_ = *(char_ - all_names_) >> (no_case[consec_steps_prec_dec_name] >> ':') >> qi::uint_[_val=_1] >> ';';
652
653 max_num_prec_decs_.name("max_num_prec_decs_");
654 max_num_prec_decs_ = *(char_ - all_names_) >> (no_case[max_num_prec_decs_name] >> ':') >> qi::uint_[_val=_1] >> ';';
655
656
657 no_setting_.name("no_setting_");
658 no_setting_ = *(char_ - all_names_);
659
660 no_decl_.name("no_decl_");
661 no_decl_ = *(char_);
662
663
664
665
666 using phx::val;
667 using phx::construct;
668 using namespace qi::labels;
669 qi::on_error<qi::fail>
670 ( root_rule_ ,
671 std::cout<<
672 val("config parser could not complete parsing. Expecting ")<<
673 _4<<
674 val(" here: ")<<
675 construct<std::string>(_3,_2)<<
676 std::endl
677 );
678
679
680
681 }
682
683
684 private:
685 qi::rule<Iterator, AdaptiveMultiplePrecisionConfig(), ascii::space_type > root_rule_;
686
687 qi::rule<Iterator, double(), ascii::space_type > degree_bound_, coefficient_bound_, lin_solve_error_bnd_, jac_eval_err_bnd_, func_eval_err_bnd_;
688 qi::rule<Iterator, int(), ascii::space_type > safety_one_, safety_two_;
689 qi::rule<Iterator, unsigned int(), ascii::space_type > max_prec_, consec_steps_prec_dec_, max_num_prec_decs_;
690
691 qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_, all_names_;
692 rules::LongNum<Iterator> mpfr_rules;
693
694
695
696 }; //re: AMPParser
697
698
699
700
701
702 } // re: namespace classic
703
704 }// re: namespace parsing
705}// re: namespace bertini
base.hpp
Provides the base type for config settings parsers.
bertini::tracking::AdaptiveMultiplePrecisionConfig
Definition trackers/config.hpp:154
bertini::tracking::AdaptiveMultiplePrecisionConfig::coefficient_bound
NumErrorT coefficient_bound
User-defined bound on the sum of the abs vals of the coeffs for any polynomial in the system (for ada...
Definition trackers/config.hpp:155
bertini::tracking::AdaptiveMultiplePrecisionConfig::maximum_precision
unsigned int maximum_precision
User-chosed setting for the maximum allowable precision. Paths will die if their precision is request...
Definition trackers/config.hpp:171
bertini::tracking::AdaptiveMultiplePrecisionConfig::safety_digits_2
int safety_digits_2
User-chosen setting for the number of safety digits used during Criterion C.
Definition trackers/config.hpp:170
bertini::tracking::AdaptiveMultiplePrecisionConfig::safety_digits_1
int safety_digits_1
User-chosen setting for the number of safety digits used during Criteria A & B.
Definition trackers/config.hpp:169
bertini::tracking::AdaptiveMultiplePrecisionConfig::Phi
NumErrorT Phi
Bound on (an error bound). Used for AMP criteria A, B.
Definition trackers/config.hpp:161
bertini::tracking::AdaptiveMultiplePrecisionConfig::Psi
NumErrorT Psi
Bound on (an error bound). Used for AMP criterion C.
Definition trackers/config.hpp:165
bertini::tracking::AdaptiveMultiplePrecisionConfig::max_num_precision_decreases
unsigned max_num_precision_decreases
The maximum number of times precision can be lowered during tracking of a segment of path.
Definition trackers/config.hpp:175
bertini::tracking::AdaptiveMultiplePrecisionConfig::epsilon
NumErrorT epsilon
Bound on growth in error from linear solves. This is in amp1, amp2, and is used for AMP criteria A a...
Definition trackers/config.hpp:158
bertini::tracking::AdaptiveMultiplePrecisionConfig::degree_bound
NumErrorT degree_bound
User-set bound on degrees of polynomials in the system - tricky to compute for factored polys,...
Definition trackers/config.hpp:156
config.hpp
Configs and settings for tracking.