config.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//include/bertini2/endgames/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.
//
//include/bertini2/endgames/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 include/bertini2/endgames/config.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/detail/typelist.hpp"
#include "bertini2/common/config.hpp"
#include "bertini2/mpfr_extensions.hpp"
 
 
namespace bertini{ namespace endgame{
 
 
        // // some forward declarations
// base
    template<class FlavorT, class PrecT>
    class EndgameBase;
 
// flavors
    template<typename PrecT>
    class PowerSeriesEndgame;
 
    template<typename PrecT>
    class CauchyEndgame;
 
// precision types
    template<typename TrackerT>
    class FixedPrecEndgame;
 
    class AMPEndgame;
 
    // end forward declarations
 
 

    template <typename TrackerT>
    struct EGPrecSelector;
 
    // specialize this in the specific files it goes in, please
 
 
 
 

    template<typename TrackerT>
    struct EndgameSelector
    {
        using EGPrecT = typename EGPrecSelector<TrackerT>::type;  
 
        using PSEG = endgame::PowerSeriesEndgame<EGPrecT>;   
        using Cauchy = endgame::CauchyEndgame<EGPrecT>;      
    };

    struct SecurityConfig
    {
        int level = 0; 
        NumErrorT max_norm = NumErrorT(1e4); 
    };
 

    struct EndgameConfig
    {
        using T = NumErrorT;  
        T sample_point_refinement_factor = 1e-2; 
        unsigned num_sample_points = 3; 
        T min_track_time = T(1e-100); 
 
        mpq_rational sample_factor{1, 2}; 
 
        unsigned max_num_refinements = 4; 
 
        T final_tolerance = 1e-11;
 
        // When the adaptive-numeric-type (double-first) endgame crosses a sample set from double up into
        // mpfr, the retained samples are widened (zero-padded) -- they were already tracked/refined to
        // final_tolerance, so by default we do NOT spend a Newton refine to sharpen them.  Set true to
        // refine every retained sample to the new (higher) precision immediately after a precision
        // increase.  No effect on fixed-precision endgames.
        bool refine_when_increasing_precision = false; 
 
        // The operating-zone test, shared by every flavor since b2#402: successive c/k estimates
        // settling is what says the cycle-number estimate has settled, and so that the Puiseux
        // asymptotics dominate.  These lived in CauchyConfig while the test did, for historical
        // rather than mathematical reasons -- the estimate reads only the geometric approach
        // samples, which every endgame maintains.
        T minimum_for_c_over_k_stabilization = T(3)/T(4); 
        unsigned int num_needed_for_stabilization = 3; 
    };
 

    struct PowerSeriesConfig
    {
        unsigned max_cycle_number = 6; 
        unsigned cycle_number_amplification = 5; 
    };
 

    struct CauchyConfig
    {
        using T = NumErrorT;  
 
        T cycle_cutoff_time = T(1)/T(100000000); 
        T ratio_cutoff_time = T(1)/T(100000000000000); 
        // minimum_for_c_over_k_stabilization and num_needed_for_stabilization moved to
        // EndgameConfig when the operating-zone test became shared (b2#402).
        T maximum_cauchy_ratio = T(1)/T(2); 
        unsigned int fail_safe_maximum_cycle_number = 250; 
 
        // Number of consecutive circle-tracked Cauchy approximations that must report the SAME cycle
        // number before a converged approximation is trusted.  Guards against an UNRELIABLE cycle
        // number: when the working precision is too low to close the loop accurately (the circle of
        // radius |t| has enough path variation that tracking error breaks closure -- NOT monodromy:
        // at high precision a nonsingular endpoint closes at cycle 1 for every radius), the
        // loop-closing count thrashes (e.g. 41, 14, 36).  Requiring N consecutive identical cycle
        // numbers refuses to accept convergence until the estimate has genuinely settled.
        // See z_notes/20260629_endgame_stepsize_reset_rootcause.
        unsigned int num_consecutive_same_cycle_number = 2; 
 
    };
 

    struct TrackBackConfig
    {
        unsigned minimum_cycle = 4; 
        bool junk_removal_test = 1; 
        unsigned max_depth_LDT = 3; 
    };
 
 
    // an empty base class
    template <typename T>
    struct AlgoTraits;

    template<typename PrecT>
    struct AlgoTraits< PowerSeriesEndgame<PrecT>>
    {
        static constexpr char const* kRecordName = "powerseries";  

        using NeededConfigs = detail::TypeList<
            PowerSeriesConfig,
            EndgameConfig,
            SecurityConfig
            >;
 
        using EmitterType = PowerSeriesEndgame<PrecT>;  
    };
 

    template<typename PrecT>
    struct AlgoTraits< CauchyEndgame<PrecT>>
    {
        static constexpr char const* kRecordName = "cauchy";  

        using NeededConfigs = detail::TypeList<
            CauchyConfig,
            EndgameConfig,
            SecurityConfig>;
    };
 
 
 
 
} } // namespaces