nag_algorithms/common/config.hpp

//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) 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
// jeb collins, west texas a&m
 
#pragma once
 
#include "bertini2/system/start_systems.hpp"
#include "bertini2/nag_algorithms/common/policies.hpp"
 
namespace bertini{
    namespace algorithm{
 
template<typename T>
using SolnCont = std::vector<T>;
 
namespace classic{
 
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); //E.4.1
    T newton_during_endgame = T(1)/T(1000000); //E.4.2
 
    T final_tolerance = T(1)/T(100000000000); //E.5.1
 
    T path_truncation_threshold = T(100000); //E.4.13
};
        
    
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; 
    
    // 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;
    T newton_before_endgame; 
    T newton_during_endgame; 
    T final_tolerance; 
};
 
 
 
struct PostProcessingConfig{
    using T = NumErrorT;
    
    T real_threshold = T(1)/T(100000000); 
 
    T endpoint_finite_threshold = T(1)/T(100000);  
 
    T same_point_tolerance {T(1)/T(10000000000)}; 
};
 
template<typename ComplexT>
struct ZeroDimConfig
{
    unsigned initial_ambient_precision = DoublePrecision();
    unsigned max_num_crossed_path_resolve_attempts = 2; 
 
    ComplexT start_time = ComplexT(1);
    ComplexT endgame_boundary = ComplexT(1)/ComplexT(10);
    ComplexT target_time = ComplexT(0);
 
    std::string path_variable_name = "ZERO_DIM_PATH_VARIABLE";
};
 
struct MetaConfig
{
    classic::AlgoChoice tracktype = classic::AlgoChoice::ZeroDim;
};
 
 
// a forward declare
template <typename T>
    struct AlgoTraits;
 
 
} } // namespaces