trackers/config.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//trackers/include/bertini2/trackers/config.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.
//
//trackers/include/bertini2/trackers/config.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 tracking/include/bertini2/trackers/config.hpp.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) 2015 - 2021 by 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.
 
// individual authors of this file include:
// silviana amethyst, university of wisconsin eau claire
// Tim Hodges, Colorado State University
 
#ifndef BERTINI_TRACKING_CONFIG_HPP
#define BERTINI_TRACKING_CONFIG_HPP

#include "bertini2/mpfr_extensions.hpp"
#include "bertini2/eigen_extensions.hpp"
#include "bertini2/system/system.hpp"
#include "bertini2/detail/typelist.hpp"
 
#include "bertini2/common/config.hpp"
 
 
namespace bertini
{
 
namespace tracking{
 
    
    enum class PrecisionType //E.2.1
    {
        Fixed,
        Adaptive
    };
    
 
    enum class Predictor //E.4.3
    {
        Constant,
        Euler,
        Heun,
        RK4,
        HeunEuler,
        RKNorsett34,
        RKF45,
        RKCashKarp45,
        RKDormandPrince56,
        RKVerner67
    };
 
    
 
 
    
 
 
    struct SteppingConfig
    {
        using T = mpq_rational;
 
        T initial_step_size = T(1)/T(10); 
        T max_step_size = T(1)/T(10); 
        T min_step_size = T(1)/T(1e100); 
 
        T step_size_success_factor = T(2); 
        T step_size_fail_factor = T(1)/T(2); 
 
        unsigned consecutive_successful_steps_before_stepsize_increase = 5; 
 
        unsigned min_num_steps = 1; 
        unsigned max_num_steps = 1e5; 
 
        unsigned frequency_of_CN_estimation = 1; 
    };
 
 
    
    struct NewtonConfig
    {
        unsigned max_num_newton_iterations = 2; //MaxNewtonIts
        unsigned min_num_newton_iterations = 1;
    };
 
 
    
    
 
    
 
 
    struct FixedPrecisionConfig
    {
        using RealType = double;

        explicit
        FixedPrecisionConfig(System const& sys) 
        { }
 
        FixedPrecisionConfig() = default;
    };
 
 
    inline
    std::ostream& operator<<(std::ostream & out, FixedPrecisionConfig const& fpc)
    {
        return out;
    }
 

    struct AdaptiveMultiplePrecisionConfig
    {
        NumErrorT coefficient_bound;  
        NumErrorT degree_bound; 
 
        NumErrorT epsilon;  
        // rename to linear_solve_error_bound.
 
        NumErrorT Phi;  
        // \f$\Phi\f$ is error in Jacobian evaluation divided by the unit roundoff error, \f$10^{-P}\f$
        // rename to jacobian_eval_error_bound
 
        NumErrorT Psi;  
        // Error in function evaluation, divided by the precision-dependent unit roundoff error.
        // rename to function_eval_error_bound
 
        int safety_digits_1 = 1; 
        int safety_digits_2 = 1; 
        unsigned int maximum_precision = 300; 
        
        unsigned consecutive_successful_steps_before_precision_decrease = 10;
 
        unsigned max_num_precision_decreases = 10; 
        

        void SetBoundsAndEpsilonFrom(System const& sys)
        {
            using std::pow;
 
            epsilon = pow(NumErrorT(sys.NumVariables()),2);
            degree_bound = sys.DegreeBound();
            coefficient_bound = sys.CoefficientBound<dbl>();
        }
        

        void SetPhiPsiFromBounds()
        {   
            Phi = degree_bound*(degree_bound-NumErrorT(1))*coefficient_bound;
            Psi = degree_bound*coefficient_bound;  //Psi from the AMP paper.
        }
 
        void SetAMPConfigFrom(System const& sys)
        {
            SetBoundsAndEpsilonFrom(sys);
            SetPhiPsiFromBounds();
        }
 
        AdaptiveMultiplePrecisionConfig() : coefficient_bound(1000), degree_bound(5), safety_digits_1(1), safety_digits_2(1), maximum_precision(300) 
        {}
 
        explicit
        AdaptiveMultiplePrecisionConfig(System const& sys) : AdaptiveMultiplePrecisionConfig()
        {
            SetAMPConfigFrom(sys);
        }
    }; // re: AdaptiveMultiplePrecisionConfig
 
    inline
    std::ostream& operator<<(std::ostream & out, AdaptiveMultiplePrecisionConfig const& AMP)
    {
        out << "coefficient_bound: " << AMP.coefficient_bound << "\n";
        out << "degree_bound: " << AMP.degree_bound << "\n";
        out << "epsilon: " << AMP.epsilon << "\n";
        out << "Phi: " << AMP.Phi << "\n";
        out << "Psi: " << AMP.Psi << "\n";
        out << "safety_digits_1: " << AMP.safety_digits_1 << "\n";
        out << "safety_digits_2: " << AMP.safety_digits_2 << "\n";
        out << "consecutive_successful_steps_before_precision_decrease" << AMP.consecutive_successful_steps_before_precision_decrease << "\n";
        return out;
    }
 
    
    inline
    static
    AdaptiveMultiplePrecisionConfig AMPConfigFrom(System const& sys) 
    {
        AdaptiveMultiplePrecisionConfig AMP;             
        AMP.SetAMPConfigFrom(sys);
        return AMP;
    }
 
    // forward declarations
    template<class D>
    class Tracker;
    template<class D>
    class FixedPrecisionTracker;
    class MultiplePrecisionTracker;
    class DoublePrecisionTracker;
    
 
// now for the TrackerTraits structs, which enable lookup of correct settings objects and types, etc.
    template<class T>
    struct TrackerTraits
    {};
 
 
    
 
    template<>
    struct TrackerTraits<DoublePrecisionTracker>
    {
        using BaseComplexType = dbl;
        using BaseRealType = double;
        using EventEmitterType = FixedPrecisionTracker<DoublePrecisionTracker>;
        using PrecisionConfig = FixedPrecisionConfig;
        enum {
            IsFixedPrec = 1,
            IsAdaptivePrec = 0
        };
 
        using NeededTypes = detail::TypeList<dbl>;
        using NeededConfigs = detail::TypeList<
            SteppingConfig, 
            NewtonConfig,
            PrecisionConfig
            >;
    };
 
 
    template<>
    struct TrackerTraits<MultiplePrecisionTracker>
    {
        using BaseComplexType = mpfr_complex;
        using BaseRealType = mpfr_float;
        using EventEmitterType = FixedPrecisionTracker<MultiplePrecisionTracker>;
        using PrecisionConfig = FixedPrecisionConfig;
 
        enum {
            IsFixedPrec = 1,
            IsAdaptivePrec = 0
        };
 
        using NeededTypes = detail::TypeList<mpfr_complex>;
 
        using NeededConfigs = detail::TypeList<
            SteppingConfig, 
            NewtonConfig,
            PrecisionConfig
            >;
    };
 
 
    class AMPTracker; // forward declare
    template<>
    struct TrackerTraits<AMPTracker>
    {
        using BaseComplexType = mpfr_complex;
        using BaseRealType = mpfr_float;
        using EventEmitterType = AMPTracker;
        using PrecisionConfig = AdaptiveMultiplePrecisionConfig;
 
        enum {
            IsFixedPrec = 0,
            IsAdaptivePrec = 1
        };
 
        using NeededTypes = detail::TypeList<dbl, mpfr_complex>;
 
        using NeededConfigs = detail::TypeList<
            SteppingConfig, 
            NewtonConfig,
            PrecisionConfig
            >;
    };
 
 
    
 
    template<class D>
    struct TrackerTraits<FixedPrecisionTracker<D> > : public TrackerTraits<D>
    { 
        using BaseComplexType = typename TrackerTraits<D>::BaseComplexType;
        using BaseRealType = typename TrackerTraits<D>::BaseRealType;
        using EventEmitterType = typename TrackerTraits<D>::EventEmitterType;
        using PrecisionConfig = typename TrackerTraits<D>::PrecisionConfig;
 
        enum {
            IsFixedPrec = 0,
            IsAdaptivePrec = 1
        };
 
        using NeededTypes = typename TrackerTraits<D>::NeededTypes;
        using NeededConfigs = typename TrackerTraits<D>::NeededConfigs;
    };
 
} // re: namespace tracking 
} // re: namespace bertini
 
 
#endif