config.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//nag_algorithms/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.
//
//nag_algorithms/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 nag_algorithms/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/system/start_systems.hpp"
 
#include <type_traits>
 
namespace bertini{
    namespace algorithm{
 
template<typename T>
using SolnCont = std::vector<T>;
 
namespace classic{
 
enum class EndgameChoice
{
    PowerSeries = 1,
    Cauchy = 2
};

struct EndgameChoiceConfig
{
    EndgameChoice endgame = EndgameChoice::PowerSeries;  
};
 
enum class AlgoChoice
{
    EvalFunctions = -4,
    EvalFunctionJacobian = -3,
    NewtonIteration = -2,
    NewtonIterationCondNum = -1,
    ZeroDim = 0,
    NID = 1,
    SampleComponent = 2,
    MembershipTest = 3,
    ExtractWitnessSet = 4,
    WitnessSetProjection = 5,
    IsosingularStab = 6
};
 
} // namespace classic
 
 

struct TolerancesConfig
{
    using T = NumErrorT;  
 
    T newton_before_endgame = T(1)/T(100000); 
    T newton_during_endgame = T(1)/T(1000000); 
 
};
 

struct MidPathConfig
{
    using T = NumErrorT;  
 
    T same_point_tolerance = T(1)/T(100000);  
};
 
 

struct AutoRetrackConfig
{
    using T = NumErrorT;  
 
    T midpath_decrease_tolerance_factor = T(1)/T(2);  
};
 
 

struct SharpeningConfig
{
    using T = NumErrorT;  
 
    unsigned sharpendigits = 0; 
 
    // std::function<Vec<T>> sharpen_method_; ///< function taking a vector, and sharpening it.
 
    T function_residual_tolerance = Eigen::NumTraits<T>::dummy_precision(); 
 
    T ratio_tolerance = T(99)/T(100); 
};
 
 

struct RegenerationConfig
{
    using T = NumErrorT;  
 
    bool remove_infinite_endpoints = true; 
 
    bool higher_dimension_check = true; 
    unsigned start_level = 0;  
    // These are the SLICE-moving tracking tolerances (Bertini 1's SliceTol* family) -- the tolerances
    // for moving the linear slices during regeneration, kept separate from the main tracking
    // tolerances in TolerancesConfig.  The slice_ prefix makes every config field name unique across
    // structs, which is what lets a field be set on an owner without naming its struct
    // (owner.update(field=...) routes by field).
    // Defaulted to the same values as the main tracking tolerances they shadow (TolerancesConfig),
    // which is where Bertini 1 takes its SliceTol* defaults from.  They were uninitialized, so a
    // default-constructed config read indeterminate memory and had no default to document (b2#406).
    // Regeneration is scaffolding today, so nothing computes differently for this.
    T slice_newton_before_endgame = T(1)/T(100000); 
    T slice_newton_during_endgame = T(1)/T(1000000); 
    T slice_final_tolerance = T(1)/T(100000000000); 
};
 
 

struct PostProcessingConfig{
    using T = NumErrorT;  
 
    T real_threshold = T(1)/T(100000000); 
 
    T endpoint_finite_threshold = T(100000);  
 
    T same_point_tolerance_multiplier {T(10)}; 
 
    T condition_number_threshold {T(100000000)}; 
};

template<typename ComplexT>
inline unsigned DefaultInitialAmbientPrecision()
{
    if constexpr (std::is_same<ComplexT, complex_dbl>::value)
        return DoublePrecision();
    else
        return DefaultPrecision();
}

enum class RecallPolicy
{
    Nothing,          
    Completed,        
    Everything,       
};

struct RecordsConfig
{
    RecallPolicy recall = RecallPolicy::Completed;  
};
 
// Not templated on the complex type: the three times are stored as exact, precision-free
// mpq_rational (real) and converted to the tracking complex type at the current working precision at
// use -- the same pattern SteppingConfig uses for its step sizes.  This keeps the config precision-
// agnostic (one struct, not a DoublePrec/Multiprec pair), and is in fact more correct under adaptive
// precision: a value like the endgame boundary 1/10 is materialized at full working precision rather
// than frozen at whatever precision the config happened to be constructed at.
//
// The times are real because a zero-dim solve tracks along the real t-axis (1 -> 0).  Complex
// homotopy times remain available at the endgame level (set directly), just not through this config.
struct ZeroDimConfig
{
    // Per-complex-type default; the ZeroDim algorithm overwrites this in DefaultSettingsSetup with
    // DefaultInitialAmbientPrecision<BaseComplexT>() (it knows its tracking type, this struct does not).
    unsigned initial_ambient_precision = DefaultPrecision();  
    unsigned max_num_crossed_path_resolve_attempts = 2; 

    unsigned num_threads = 0;

    double max_path_wall_clock_duration = 0;

    double max_solve_wall_clock_duration = 0;
 
    mpq_rational start_time{1};          
    mpq_rational endgame_boundary{1, 10}; 
    mpq_rational target_time{0};         
 
    std::string path_variable_name = "ZERO_DIM_PATH_VARIABLE";  
};

struct MetaConfig
{
    classic::AlgoChoice tracktype = classic::AlgoChoice::ZeroDim;  
};

struct RandomConfig
{
    unsigned long random_seed = 0;  
};
 
 
// a forward declare
template <typename T>
    struct AlgoTraits;
 
 
} } // namespaces