algorithm.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//bertini2/io/parsing/settings_parsers/algorithm.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//bertini2/io/parsing/settings_parsers/algorithm.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with bertini2/io/parsing/settings_parsers/algorithm.hpp.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING.  Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.
 

 
#pragma once
 
 
#include "bertini2/io/parsing/settings_parsers/base.hpp"
#include "bertini2/nag_algorithms/common/config.hpp"
 
namespace bertini {
    namespace parsing {
        namespace classic {
 
 

            template<typename Iterator, typename Skipper>
            struct ConfigSettingParser<Iterator, algorithm::TolerancesConfig, Skipper> : qi::grammar<Iterator, algorithm::TolerancesConfig(), Skipper>
            {
                using T = double;  
 
                ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "config::TolerancesType")
                {
                    namespace phx = boost::phoenix;
                    using qi::_1;
                    using qi::_2;
                    using qi::_3;
                    using qi::_4;
                    using qi::_val;
                    using qi::eps;
                    using qi::lit;
                    using qi::char_;
                    using qi::omit;
                    using boost::spirit::lexeme;
                    using boost::spirit::as_string;
                    using boost::spirit::ascii::no_case;
 
 
 
                    std::string newton_before_name = "tracktolbeforeeg";
                    std::string newton_during_name = "tracktolduringeg";
 
 
                    root_rule_.name("config::Tolerances");
 
                    root_rule_ = ((newton_before_endgame_[phx::bind( [](algorithm::TolerancesConfig & S, T l)
                                                                    {
                                                                        S.newton_before_endgame = l;
                                                                    }, _val, _1 )]
                                   ^ newton_during_endgame_[phx::bind( [](algorithm::TolerancesConfig & S, T num)
                                                                      {
                                                                          S.newton_during_endgame = num;
                                                                      }, _val, _1 )])
 
                                  >> -no_setting_)
                    | no_setting_;
 
 
                    all_names_ = (no_case[newton_before_name] >> ':') | (no_case[newton_during_name] >> ':');
 
                    newton_before_endgame_.name("newton_before_endgame_");
                    newton_before_endgame_ = *(char_ - all_names_) >> (no_case[newton_before_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( [](T & num, std::string str)
                                                           {
                                                               num = bertini::NumTraits<T>::FromString(str);
                                                           }, _val, _1 )] >> ';';
 
                    newton_during_endgame_.name("newton_during_endgame_");
                    newton_during_endgame_ = *(char_ - all_names_) >> (no_case[newton_during_name] >>':')
                    >> mpfr_rules.number_string_[phx::bind( [](T & num, std::string str)
                                                           {
                                                               num = bertini::NumTraits<T>::FromString(str);
                                                           }, _val, _1 )] >> ';';
 
                    no_setting_.name("no_setting_");
                    no_setting_ = *(char_ - all_names_);
 
                    no_decl_.name("no_decl_");
                    no_decl_ = *(char_);
 
 
 
 
 
                    qi::on_error<qi::fail>(
                        root_rule_,
                        phx::bind(&ReportParseError, _1, _2, _3, _4, std::string("config::Tolerances"))
                    );
 
 
 
                }
 
 
            private:
                qi::rule<Iterator, algorithm::TolerancesConfig(), ascii::space_type > root_rule_;
                qi::rule<Iterator, T(), ascii::space_type > newton_before_endgame_, newton_during_endgame_;
                qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_, all_names_;
                rules::LongNum<Iterator> mpfr_rules;
 
 
 
            }; //re: Tolerances
 
 
 
 
 
 
 
 
 
            template<typename Iterator, typename Skipper>
            struct ConfigSettingParser<Iterator, algorithm::ZeroDimConfig, Skipper> : qi::grammar<Iterator, algorithm::ZeroDimConfig(), Skipper>
            {
 
                ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "algorithm::ZeroDimConfig")
                {
                    namespace phx = boost::phoenix;
                    using qi::_1;
                    using qi::_2;
                    using qi::_3;
                    using qi::_4;
                    using qi::_val;
                    using qi::eps;
                    using qi::lit;
                    using qi::char_;
                    using qi::omit;
                    using boost::spirit::lexeme;
                    using boost::spirit::as_string;
                    using boost::spirit::ascii::no_case;
 
 
 
                    std::string init_prec_name = "initialprec";
                    std::string max_cross_resolve_name = "maxcrossedpathresolves";
                    std::string start_time_name = "starttime";
                    std::string endgame_boundary_name = "endgamebdry";
                    std::string target_time_name = "targettime";
                    std::string path_variable_name_name = "pathvarname";
 
 
                    root_rule_.name("config::ZeroDim");
 
                    root_rule_ = ((init_prec_[phx::bind( [](algorithm::ZeroDimConfig & S, int num)
                                                           {
                                                               S.initial_ambient_precision = static_cast<unsigned int>(num);
                                                           }, _val, _1 )]
                                   ^ path_variable_name_[phx::bind( [](algorithm::ZeroDimConfig & S, std::string omnom)
                                                             {
                                                                 S.path_variable_name = omnom;
                                                             }, _val, _1 )]
                                   ^ max_cross_resolve_[phx::bind( [](algorithm::ZeroDimConfig & S, int num)
                                                             {
                                                                 S.max_num_crossed_path_resolve_attempts = static_cast<unsigned int>(num);
                                                             }, _val, _1 )]
                                   ^ start_time_[phx::bind( [](algorithm::ZeroDimConfig & S, mpq_rational num)
                                                             {
                                                                 S.start_time = num;
                                                             }, _val, _1 )]
                                   ^ endgame_boundary_[phx::bind( [](algorithm::ZeroDimConfig & S, mpq_rational num)
                                                             {
                                                                 S.endgame_boundary = num;
                                                             }, _val, _1 )]
                                   ^ target_time_[phx::bind( [](algorithm::ZeroDimConfig & S, mpq_rational num)
                                                             {
                                                                 S.target_time = num;
                                                             }, _val, _1 )]
                                   )
                                  >> -no_setting_) | no_setting_;
 
                    all_names_ = (no_case[init_prec_name] >> ':') |
                                 (no_case[target_time_name] >> ':') |
                                 (no_case[path_variable_name_name] >> ':') |
                                 (no_case[max_cross_resolve_name] >> ':') |
                                 (no_case[start_time_name] >> ':') |
                                 (no_case[endgame_boundary_name] >> ':')
                                 ;
 
 
                    // The times are stored as exact, precision-free mpq_rational.  Parse the number
                    // string to a multiprecision real, then to a rational (the homotopy times are real).
                    auto str_to_rational = [](mpq_rational & num, std::string str)
                                       {
                                           num = mpq_rational(real_mp(str));
                                       };
 
 
 
                    // UTF-8 identifier (same policy as the system parser): a Unicode
                    // letter start, then Unicode alphanumerics or [ ] _ .  The parser
                    // is self-contained (never sub-skips inside the identifier), so no
                    // lexeme is needed even on this skippered rule.  See
                    // io/parsing/unicode_ident.hpp.
                    valid_variable_name_.name("valid_variable_name_");
                    valid_variable_name_ = utf8_identifier_parser();
 
 
                    path_variable_name_.name("path_variable_name_");
                    path_variable_name_ = *(char_ - all_names_) >> (no_case[path_variable_name_name] >> ':') >> valid_variable_name_ >> ';';
 
                    init_prec_.name("init_prec_");
                    init_prec_ = *(char_ - all_names_) >> (no_case[init_prec_name] >> ':') >> qi::int_[_val=_1] >> ';';
 
                    max_cross_resolve_.name("max_cross_resolve_");
                    max_cross_resolve_ = *(char_ - all_names_) >> (no_case[max_cross_resolve_name] >> ':') >> qi::int_[_val=_1] >> ';';
 
                    start_time_.name("start_time_");
                    start_time_ = *(char_ - all_names_) >> (no_case[start_time_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_rational, _val, _1 )] >> ';';
 
                    endgame_boundary_.name("endgame_boundary_");
                    endgame_boundary_ = *(char_ - all_names_) >> (no_case[endgame_boundary_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_rational, _val, _1 )] >> ';';
 
                    target_time_.name("target_time_");
                    target_time_ = *(char_ - all_names_) >> (no_case[target_time_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_rational, _val, _1 )] >> ';';
 
 
 
                    no_setting_.name("no_setting_");
                    no_setting_ = *(char_ - all_names_);
 
                    no_decl_.name("no_decl_");
                    no_decl_ = *(char_);
 
 
 
 
                    qi::on_error<qi::fail>(
                        root_rule_,
                        phx::bind(&ReportParseError, _1, _2, _3, _4, std::string("config::ZeroDim"))
                    );
 
 
 
                }
 
 
            private:
                qi::rule<Iterator, algorithm::ZeroDimConfig(), ascii::space_type > root_rule_;
 
                qi::rule<Iterator, mpq_rational(), ascii::space_type > start_time_, target_time_, endgame_boundary_;
                qi::rule<Iterator, int(), ascii::space_type > init_prec_, max_cross_resolve_;
                qi::rule<Iterator, std::string(), ascii::space_type > valid_variable_name_, path_variable_name_;
 
 
                qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_, all_names_;
                rules::LongNum<Iterator> mpfr_rules;
 
 
 
            }; //re: ZeroDim
 
            template<typename Iterator, typename Skipper>
            struct ConfigSettingParser<Iterator, algorithm::MidPathConfig, Skipper> : qi::grammar<Iterator, algorithm::MidPathConfig(), Skipper>
            {
                using T = double;  
 
                ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "config::MidPath")
                {
                    namespace phx = boost::phoenix;
                    using qi::_1;
                    using qi::_2;
                    using qi::_3;
                    using qi::_4;
                    using qi::_val;
                    using qi::eps;
                    using qi::lit;
                    using qi::char_;
                    using qi::omit;
                    using boost::spirit::lexeme;
                    using boost::spirit::as_string;
                    using boost::spirit::ascii::no_case;
 
 
 
                    std::string same_point_tol_name = "midpathtol";
 
 
                    root_rule_.name("config::MidPath");
 
                    root_rule_ = ((same_point_tol_[phx::bind( [](algorithm::MidPathConfig & S, T num)
                                                           {
                                                               S.same_point_tolerance = num;
                                                           }, _val, _1 )]
                                  )
                                  >> -no_setting_) | no_setting_;
 
                    all_names_ = (no_case[same_point_tol_name] >> ':');
 
                    auto str_to_T = [](T & num, std::string str)
                                       {
                                           num = bertini::NumTraits<T>::FromString(str);
                                       };
 
 
                    same_point_tol_.name("same_point_tol_");
                    same_point_tol_ = *(char_ - all_names_) >> (no_case[same_point_tol_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
 
                    no_setting_.name("no_setting_");
                    no_setting_ = *(char_ - all_names_);
 
                    no_decl_.name("no_decl_");
                    no_decl_ = *(char_);
 
 
 
 
                    qi::on_error<qi::fail>(
                        root_rule_,
                        phx::bind(&ReportParseError, _1, _2, _3, _4, std::string("config::MidPath"))
                    );
 
 
 
                }
 
 
            private:
                qi::rule<Iterator, algorithm::MidPathConfig(), ascii::space_type > root_rule_;
                qi::rule<Iterator, T(), ascii::space_type > same_point_tol_;
                qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_, all_names_;
                rules::LongNum<Iterator> mpfr_rules;
 
            }; //re: MidPath
 
 
            template<typename Iterator, typename Skipper>
            struct ConfigSettingParser<Iterator, algorithm::RecordsConfig, Skipper> : qi::grammar<Iterator, algorithm::RecordsConfig(), Skipper>
            {
                ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "config::Records")
                {
                    namespace phx = boost::phoenix;
                    using qi::_1;
                    using qi::_val;
                    using qi::char_;
                    root_rule_.name("config::Records");
                    // swallow the text; the semantic action keeps Spirit from trying to fill the
                    // struct with it, and leaves _val at its defaults
                    root_rule_ = (*char_)[phx::bind([](algorithm::RecordsConfig&, std::vector<char> const&){}, _val, _1)];
                }
 
            private:
                qi::rule<Iterator, algorithm::RecordsConfig(), ascii::space_type > root_rule_;
            };
 
 
            template<typename Iterator, typename Skipper>
            struct ConfigSettingParser<Iterator, algorithm::AutoRetrackConfig, Skipper> : qi::grammar<Iterator, algorithm::AutoRetrackConfig(), Skipper>
            {
                using T = double;  
 
                ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "config::AutoRetrack")
                {
                    namespace phx = boost::phoenix;
                    using qi::_1;
                    using qi::_2;
                    using qi::_3;
                    using qi::_4;
                    using qi::_val;
                    using qi::eps;
                    using qi::lit;
                    using qi::char_;
                    using qi::omit;
                    using boost::spirit::lexeme;
                    using boost::spirit::as_string;
                    using boost::spirit::ascii::no_case;
 
 
 
                    std::string decrease_factor_name = "retracktolfactor";
 
 
                    root_rule_.name("config::AutoRetrack");
 
                    root_rule_ = ((decrease_factor[phx::bind( [](algorithm::AutoRetrackConfig & S, T num)
                                                           {
                                                               S.midpath_decrease_tolerance_factor = num;
                                                           }, _val, _1 )]
                                  )
                                  >> -no_setting_) | no_setting_;
 
                    all_names_ = (no_case[decrease_factor_name] >> ':');
 
                    auto str_to_T = [](T & num, std::string str)
                                       {
                                           num = bertini::NumTraits<T>::FromString(str);
                                       };
 
 
                    decrease_factor.name("decrease_factor");
                    decrease_factor = *(char_ - all_names_) >> (no_case[decrease_factor_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
 
                    no_setting_.name("no_setting_");
                    no_setting_ = *(char_ - all_names_);
 
                    no_decl_.name("no_decl_");
                    no_decl_ = *(char_);
 
 
 
 
                    qi::on_error<qi::fail>(
                        root_rule_,
                        phx::bind(&ReportParseError, _1, _2, _3, _4, std::string("config::AutoRetrack"))
                    );
 
 
 
                }
 
 
            private:
                qi::rule<Iterator, algorithm::AutoRetrackConfig(), ascii::space_type > root_rule_;
                qi::rule<Iterator, T(), ascii::space_type > decrease_factor;
                qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_, all_names_;
                rules::LongNum<Iterator> mpfr_rules;
 
            }; //re: AutoRetrack
 
 
            template<typename Iterator, typename Skipper>
            struct ConfigSettingParser<Iterator, algorithm::SharpeningConfig, Skipper> : qi::grammar<Iterator, algorithm::SharpeningConfig(), Skipper>
            {
                using T = double;  
 
                ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "algorithm::config::Sharpening")
                {
                    namespace phx = boost::phoenix;
                    using qi::_1;
                    using qi::_2;
                    using qi::_3;
                    using qi::_4;
                    using qi::_val;
                    using qi::eps;
                    using qi::lit;
                    using qi::char_;
                    using qi::omit;
                    using boost::spirit::lexeme;
                    using boost::spirit::as_string;
                    using boost::spirit::ascii::no_case;
 
 
 
                    std::string sharpen_digits_name = "sharpendigits";
                    std::string func_res_tol_name = "functiontolerance";
                    std::string ratio_tol_name = "ratiotolerance";
 
 
                    root_rule_.name("config::Sharpening");
 
                    root_rule_ = ((sharpen_digits_[phx::bind( [](algorithm::SharpeningConfig & S, unsigned num)
                                                           {
                                                               S.sharpendigits = num;
                                                           }, _val, _1 )]
                                   ^ func_res_tol_[phx::bind( [](algorithm::SharpeningConfig & S, T num)
                                                             {
                                                                 S.function_residual_tolerance = num;
                                                             }, _val, _1 )]
                                   ^ ratio_tol_[phx::bind( [](algorithm::SharpeningConfig & S, T num)
                                                             {
                                                                 S.ratio_tolerance = num;
                                                             }, _val, _1 )]
                                   )
                                  >> -no_setting_) | no_setting_;
 
                    all_names_ = (no_case[sharpen_digits_name] >> ':') |
                                 (no_case[func_res_tol_name] >> ':') |
                                 (no_case[ratio_tol_name] >> ':')
                                 ;
 
 
                    auto str_to_T = [](T & num, std::string str)
                                       {
                                           num = bertini::NumTraits<T>::FromString(str);
                                       };
 
 
                    func_res_tol_.name("func_res_tol_");
                    func_res_tol_ = *(char_ - all_names_) >> (no_case[func_res_tol_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
                    ratio_tol_.name("ratio_tol_");
                    ratio_tol_ = *(char_ - all_names_) >> (no_case[ratio_tol_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
                    sharpen_digits_.name("sharpen_digits_");
                    sharpen_digits_ = *(char_ - all_names_) >> (no_case[sharpen_digits_name] >> ':') >> qi::uint_[_val=_1] >> ';';
 
 
 
                    no_setting_.name("no_setting_");
                    no_setting_ = *(char_ - all_names_);
 
                    no_decl_.name("no_decl_");
                    no_decl_ = *(char_);
 
 
 
 
                    qi::on_error<qi::fail>(
                        root_rule_,
                        phx::bind(&ReportParseError, _1, _2, _3, _4, std::string("config::Sharpening"))
                    );
 
 
 
                }
 
 
            private:
                qi::rule<Iterator, algorithm::SharpeningConfig(), ascii::space_type > root_rule_;
 
                qi::rule<Iterator, T(), ascii::space_type > func_res_tol_, ratio_tol_;
                qi::rule<Iterator, unsigned int(), ascii::space_type > sharpen_digits_;
 
                qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_, all_names_;
                rules::LongNum<Iterator> mpfr_rules;
 
 
 
            }; //re: Sharpening
 
            template<typename Iterator, typename Skipper>
            struct ConfigSettingParser<Iterator, algorithm::RegenerationConfig, Skipper> : qi::grammar<Iterator, algorithm::RegenerationConfig(), Skipper>
            {
                using T = double;  
 
                ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "algorithm::config::Regeneration")
                {
                    namespace phx = boost::phoenix;
                    using qi::_1;
                    using qi::_2;
                    using qi::_3;
                    using qi::_4;
                    using qi::_val;
                    using qi::eps;
                    using qi::lit;
                    using qi::char_;
                    using qi::omit;
                    using boost::spirit::lexeme;
                    using boost::spirit::as_string;
                    using boost::spirit::ascii::no_case;
 
 
 
                    std::string regen_remove_inf_name = "regenremoveinf";
                    std::string slice_before_name = "slicetolbeforeeg";
                    std::string slice_during_name = "slicetolduringeg";
                    std::string slice_final_name = "slicefinaltol";
                    std::string higher_dim_check_name = "regenhigherdimtest";
                    std::string start_level_name = "regenstartlevel";
 
 
                    root_rule_.name("config::Regeneration");
 
                    root_rule_ = ((regen_remove_inf_[phx::bind( [](algorithm::RegenerationConfig & S, int num)
                                                           {
                                                               S.remove_infinite_endpoints = static_cast<bool>(num);
                                                           }, _val, _1 )]
                                   ^ higher_dim_check_[phx::bind( [](algorithm::RegenerationConfig & S, int num)
                                                             {
                                                                 S.higher_dimension_check = static_cast<bool>(num);
                                                             }, _val, _1 )]
                                   ^ start_level_[phx::bind( [](algorithm::RegenerationConfig & S, int num)
                                                             {
                                                                 S.start_level = static_cast<unsigned int>(num);
                                                             }, _val, _1 )]
                                   ^ slice_before_[phx::bind( [](algorithm::RegenerationConfig & S, T num)
                                                             {
                                                                 S.slice_newton_before_endgame = num;
                                                             }, _val, _1 )]
                                   ^ slice_during_[phx::bind( [](algorithm::RegenerationConfig & S, T num)
                                                             {
                                                                 S.slice_newton_during_endgame = num;
                                                             }, _val, _1 )]
                                   ^ slice_final_[phx::bind( [](algorithm::RegenerationConfig & S, T num)
                                                             {
                                                                 S.slice_final_tolerance = num;
                                                             }, _val, _1 )]
                                   )
                                  >> -no_setting_) | no_setting_;
 
                    all_names_ = (no_case[regen_remove_inf_name] >> ':') |
                                 (no_case[higher_dim_check_name] >> ':') |
                                 (no_case[start_level_name] >> ':') |
                                 (no_case[slice_before_name] >> ':') |
                                 (no_case[slice_during_name] >> ':') |
                                 (no_case[slice_final_name] >> ':')
                                 ;
 
 
                    auto str_to_T = [](T & num, std::string str)
                                       {
                                           num = bertini::NumTraits<T>::FromString(str);
                                       };
 
 
                    higher_dim_check_.name("higher_dim_check_");
                    higher_dim_check_ = *(char_ - all_names_) >> (no_case[higher_dim_check_name] >> ':') >> qi::int_[_val=_1] >> ';';
 
                    start_level_.name("start_level_");
                    start_level_ = *(char_ - all_names_) >> (no_case[start_level_name] >> ':') >> qi::int_[_val=_1] >> ';';
 
                    regen_remove_inf_.name("regen_remove_inf_");
                    regen_remove_inf_ = *(char_ - all_names_) >> (no_case[regen_remove_inf_name] >> ':') >> qi::int_[_val=_1] >> ';';
 
 
 
                    slice_before_.name("slice_before_");
                    slice_before_ = *(char_ - all_names_) >> (no_case[slice_before_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
                    slice_during_.name("slice_during_");
                    slice_during_ = *(char_ - all_names_) >> (no_case[slice_during_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
                    slice_final_.name("slice_final_");
                    slice_final_ = *(char_ - all_names_) >> (no_case[slice_final_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
 
 
                    no_setting_.name("no_setting_");
                    no_setting_ = *(char_ - all_names_);
 
                    no_decl_.name("no_decl_");
                    no_decl_ = *(char_);
 
 
 
 
                    qi::on_error<qi::fail>(
                        root_rule_,
                        phx::bind(&ReportParseError, _1, _2, _3, _4, std::string("config::Regeneration"))
                    );
 
 
 
                }
 
 
            private:
                qi::rule<Iterator, algorithm::RegenerationConfig(), ascii::space_type > root_rule_;
 
                qi::rule<Iterator, T(), ascii::space_type > slice_before_, slice_during_, slice_final_;
                qi::rule<Iterator, int(), ascii::space_type > regen_remove_inf_, start_level_, higher_dim_check_;
 
                qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_, all_names_;
                rules::LongNum<Iterator> mpfr_rules;
 
 
 
            }; //re: Regeneration
 
 
            template<typename Iterator, typename Skipper>
            struct ConfigSettingParser<Iterator, algorithm::PostProcessingConfig, Skipper> : qi::grammar<Iterator, algorithm::PostProcessingConfig(), Skipper>
            {
                using T = double;  
 
                ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "algorithm::PostProcessingConfig")
                {
                    namespace phx = boost::phoenix;
                    using qi::_1;
                    using qi::_2;
                    using qi::_3;
                    using qi::_4;
                    using qi::_val;
                    using qi::eps;
                    using qi::lit;
                    using qi::char_;
                    using qi::omit;
                    using boost::spirit::lexeme;
                    using boost::spirit::as_string;
                    using boost::spirit::ascii::no_case;
 
 
 
                    std::string real_thresh_name = "imagthreshold";
                    std::string endpoint_finite_name = "endpointfinitethreshold";
                    std::string same_point_name = "endpointsamethreshold";
                    std::string cond_num_name = "condnumthreshold";
 
 
 
                    root_rule_.name("config::PostProcessing");
 
                    root_rule_ = ((real_threshold_[phx::bind( [](algorithm::PostProcessingConfig & S, T num)
                                                             {
                                                                 S.real_threshold = num;
                                                             }, _val, _1 )]
                                   ^ endpoint_finite_[phx::bind( [](algorithm::PostProcessingConfig & S, T num)
                                                             {
                                                                 S.endpoint_finite_threshold = num;
                                                             }, _val, _1 )]
                                   ^ same_point_[phx::bind( [](algorithm::PostProcessingConfig & S, T num)
                                                             {
                                                                 S.same_point_tolerance_multiplier = num;
                                                             }, _val, _1 )]
                                   ^ cond_num_[phx::bind( [](algorithm::PostProcessingConfig & S, T num)
                                                             {
                                                                 S.condition_number_threshold = num;
                                                             }, _val, _1 )]
                                   )
                                  >> -no_setting_) | no_setting_;
 
                    all_names_ = (no_case[real_thresh_name] >> ':') |
                                 (no_case[endpoint_finite_name] >> ':') |
                                 (no_case[same_point_name] >> ':') |
                                 (no_case[cond_num_name] >> ':')
                                 ;
 
 
                    auto str_to_T = [](T & num, std::string str)
                                       {
                                           num = bertini::NumTraits<T>::FromString(str);
                                       };
 
                    real_threshold_.name("real_thresh_");
                    real_threshold_ = *(char_ - all_names_) >> (no_case[real_thresh_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
                    endpoint_finite_.name("endpoint_finite_");
                    endpoint_finite_ = *(char_ - all_names_) >> (no_case[endpoint_finite_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
                    same_point_.name("same_point_");
                    same_point_ = *(char_ - all_names_) >> (no_case[same_point_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
                    cond_num_.name("cond_num_");
                    cond_num_ = *(char_ - all_names_) >> (no_case[cond_num_name] >> ':')
                    >> mpfr_rules.number_string_[phx::bind( str_to_T, _val, _1 )] >> ';';
 
 
 
                    no_setting_.name("no_setting_");
                    no_setting_ = *(char_ - all_names_);
 
                    no_decl_.name("no_decl_");
                    no_decl_ = *(char_);
 
 
 
 
                    qi::on_error<qi::fail>(
                        root_rule_,
                        phx::bind(&ReportParseError, _1, _2, _3, _4, std::string("config::PostProcessing"))
                    );
 
 
 
                }
 
 
            private:
                qi::rule<Iterator, algorithm::PostProcessingConfig(), ascii::space_type > root_rule_;
 
                qi::rule<Iterator, T(), ascii::space_type > real_threshold_, endpoint_finite_, same_point_, cond_num_;
 
                qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_, all_names_;
                rules::LongNum<Iterator> mpfr_rules;
 
 
 
            }; //re: PostProcessing
 
 
 
            template<typename Iterator, typename Skipper> //boost::spirit::unused_type
            struct ConfigSettingParser<Iterator, algorithm::classic::AlgoChoice, Skipper> : qi::grammar<Iterator, algorithm::classic::AlgoChoice(), Skipper>
            {
                using T = double;  
 
                ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "config::classic::AlgoChoice")
                {
                    namespace phx = boost::phoenix;
                    using qi::_1;
                    using qi::_2;
                    using qi::_3;
                    using qi::_4;
                    using qi::_val;
                    using qi::eps;
                    using qi::lit;
                    using qi::char_;
                    using qi::omit;
                    using boost::spirit::lexeme;
                    using boost::spirit::as_string;
                    using boost::spirit::ascii::no_case;
 
                    tracktype_.add("-4", algorithm::classic::AlgoChoice::EvalFunctions);
                    tracktype_.add("-3", algorithm::classic::AlgoChoice::EvalFunctionJacobian);
                    tracktype_.add("-2", algorithm::classic::AlgoChoice::NewtonIteration);
                    tracktype_.add("-1", algorithm::classic::AlgoChoice::NewtonIterationCondNum);
                    tracktype_.add("0", algorithm::classic::AlgoChoice::ZeroDim);
                    tracktype_.add("1", algorithm::classic::AlgoChoice::NID);
                    tracktype_.add("2", algorithm::classic::AlgoChoice::SampleComponent);
                    tracktype_.add("3", algorithm::classic::AlgoChoice::MembershipTest);
                    tracktype_.add("4", algorithm::classic::AlgoChoice::ExtractWitnessSet);
                    tracktype_.add("5", algorithm::classic::AlgoChoice::WitnessSetProjection);
                    tracktype_.add("6", algorithm::classic::AlgoChoice::IsosingularStab);
 
                    std::string setting_name = "tracktype";
 
 
                    root_rule_.name("config::classic::AlgoChoice");
 
                    root_rule_ = config_name_[_val = _1] >> -no_setting_
                                | no_setting_[_val = algorithm::classic::AlgoChoice::ZeroDim];
 
                    config_name_.name("tracktype_");
                    config_name_ = *(char_ - (no_case[setting_name] >> ':')) >> (no_case[setting_name] >> ':') >> tracktype_[_val = _1] >> ';';
 
                    no_setting_.name("no_setting_");
                    no_setting_ = *(char_ - no_case[setting_name]);
 
                    no_decl_.name("no_decl_");
                    no_decl_ = *(char_);
 
 
 
 
                    qi::on_error<qi::fail>(
                        root_rule_,
                        phx::bind(&ReportParseError, _1, _2, _3, _4, std::string("config::classic::AlgoChoice"))
                    );
 
 
 
                }
 
 
            private:
                qi::rule<Iterator, algorithm::classic::AlgoChoice(), ascii::space_type > root_rule_, config_name_;
                qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_;
 
                qi::symbols<char,algorithm::classic::AlgoChoice> tracktype_;
 
 
            }; //re: Meta
 
 
 
        template<typename Iterator, typename Skipper>
            struct ConfigSettingParser<Iterator, algorithm::classic::EndgameChoiceConfig, Skipper> : qi::grammar<Iterator, algorithm::classic::EndgameChoiceConfig(), Skipper>
            {
                ConfigSettingParser() : ConfigSettingParser::base_type(root_rule_, "config::classic::EndgameChoiceConfig")
                {
                    namespace phx = boost::phoenix;
                    using qi::_1;
                    using qi::_2;
                    using qi::_3;
                    using qi::_4;
                    using qi::_val;
                    using qi::char_;
                    using boost::spirit::ascii::no_case;
 
                    // Bertini1: endgamenum: 1=PSEG (the DEFAULT, per the Bertini 1 manual; ADR-0058), 2=Cauchy
                    endgamechoice_.add("1", algorithm::classic::EndgameChoice::PowerSeries);
                    endgamechoice_.add("2", algorithm::classic::EndgameChoice::Cauchy);
 
                    std::string setting_name = "endgamenum";
 
                    // enum_rule_ parses the setting and returns the EndgameChoice enum value
                    enum_rule_.name("endgamechoice_");
                    enum_rule_ = *(char_ - (no_case[setting_name] >> ':')) >> (no_case[setting_name] >> ':') >> endgamechoice_[_val = _1] >> ';';
 
                    root_rule_.name("config::classic::EndgameChoiceConfig");
 
                    root_rule_ = enum_rule_[phx::bind([](algorithm::classic::EndgameChoiceConfig& cfg,
                                                         algorithm::classic::EndgameChoice c){
                                                           cfg.endgame = c;
                                                      }, _val, _1)]
                               >> -no_setting_
                               | no_setting_; // no endgamenum → default (PowerSeries, matching Bertini 1)
 
                    no_setting_.name("no_setting_");
                    no_setting_ = *(char_ - no_case[setting_name]);
 
                    no_decl_.name("no_decl_");
                    no_decl_ = *(char_);
 
                    qi::on_error<qi::fail>(
                        root_rule_,
                        phx::bind(&ReportParseError, _1, _2, _3, _4, std::string("config::classic::EndgameChoiceConfig"))
                    );
                }
 
            private:
                qi::rule<Iterator, algorithm::classic::EndgameChoiceConfig(), ascii::space_type > root_rule_;
                qi::rule<Iterator, algorithm::classic::EndgameChoice(), ascii::space_type > enum_rule_;
                qi::rule<Iterator, ascii::space_type, std::string()> no_decl_, no_setting_;
 
                qi::symbols<char, algorithm::classic::EndgameChoice> endgamechoice_;
 
            }; //re: EndgameChoiceConfig
 
 
        } // re: namespace classic
 
    }// re: namespace parsing
}// re: namespace bertini