base_endgame.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//base_endgame.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.
//
//base_endgame.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 base_endgame.hpp.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) 2015 - 2025 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_BASE_ENDGAME_HPP
#define BERTINI_BASE_ENDGAME_HPP
 
#pragma once
 
#include <iostream>
#include <typeinfo>
 
 
#include "bertini2/mpfr_complex.hpp"
 
#include "bertini2/system/system.hpp"
 
#include "bertini2/detail/enable_permuted_arguments.hpp"
 
#include "bertini2/trackers/config.hpp"
#include "bertini2/endgames/config.hpp"
#include "bertini2/endgames/interpolation.hpp"
#include "bertini2/endgames/events.hpp"
 
#include "bertini2/logging.hpp"
 
#include "bertini2/detail/configured.hpp"
 
 
namespace bertini{ namespace endgame {
 
            
template<class FlavorT, class PrecT>
class EndgameBase : 
    public detail::Configured< typename AlgoTraits<FlavorT>::NeededConfigs >,
    public PrecT,
    public virtual Observable
{
public:
    using TrackerType = typename PrecT::TrackerType;
 
    using BaseComplexType = typename tracking::TrackerTraits<TrackerType>::BaseComplexType;
    using BaseRealType = typename tracking::TrackerTraits<TrackerType>::BaseRealType;
 
    using EmitterType = FlavorT;
 
protected:
 
    using BCT = BaseComplexType;
    using BRT = BaseRealType;
 
 
    using Configured = detail::Configured< typename AlgoTraits<FlavorT>::NeededConfigs >;
    using Configs = typename AlgoTraits<FlavorT>::NeededConfigs;
    using ConfigsAsTuple = typename Configs::ToTuple;
 
    // a list of all the needed arithemtic types (complex for complex trackers)
    using NeededTypes = detail::TypeList<BCT>;
    using TupOfVec = typename NeededTypes::ToTupleOfVec;
    using TupOfReal = typename NeededTypes::ToTupleOfReal;
    using TupleOfTimes = typename NeededTypes::template ToTupleOfCont<TimeCont>;
    using TupleOfSamps = typename NeededTypes::template ToTupleOfCont<SampCont>;
 
 
 
    // universal endgame state variables
    mutable Vec<BCT> final_approximation_; 
    mutable Vec<BCT> previous_approximation_; 
    mutable unsigned int cycle_number_ = 0; 
    mutable NumErrorT approximate_error_;
 
 
 
 

    const FlavorT& AsFlavor() const
    {
        return dynamic_cast<const FlavorT&>(*this);
    }

    FlavorT& AsFlavor()
    {
        return dynamic_cast<FlavorT&>(*this);
    }
 
public:

    SuccessCode Run(const BCT & start_time, const Vec<BCT> & start_point, BCT const& target_time)
    {
        return this->AsFlavor().RunImpl(start_time, start_point, target_time);
    }

    SuccessCode Run(BCT const& start_time, Vec<BCT> const& start_point)
    {
        return Run(start_time, start_point, static_cast<BCT>(0));
    }
 
 
    template<typename CT>
    SuccessCode RefineAllSamples(SampCont<CT> & samples, TimeCont<CT> & times)
    {
        for (size_t ii=0; ii<samples.size(); ++ii)
        {
            auto refine_success = this->RefineSample(samples[ii], samples[ii],  times[ii], 
                                        this->FinalTolerance() * this->EndgameSettings().sample_point_refinement_factor,
                                        this->EndgameSettings().max_num_newton_iterations);
            if (refine_success != SuccessCode::Success)
            {
                // BOOST_LOG_TRIVIAL(severity_level::trace) << "refining failed, code " << int(refine_success);
                return refine_success;
            }
            NotifyObservers(SampleRefined<EmitterType>(AsFlavor()));
        }
 
        if (tracking::TrackerTraits<TrackerType>::IsAdaptivePrec) // known at compile time
        {
            auto max_precision = this->EnsureAtUniformPrecision(times, samples);
            this->GetSystem().precision(max_precision);
        }
 
        return SuccessCode::Success;
    }
 

    SuccessCode RefineSample(Vec<BCT> & result, Vec<BCT> const& current_sample, BCT const& current_time, NumErrorT tol, unsigned max_iterations) const
    {
        return this->RefineSampleImpl(result, current_sample, current_time, tol, max_iterations);
    }
 
    void ChangePrecision(unsigned p)
    {
        AsFlavor().ChangePrecision(p);
        PrecT::ChangePrecision(p);
        ChangePrecision(this->final_approximation_,p);
        ChangePrecision(this->previous_approximation_,p);
    }
 

    inline
    const auto & EndgameSettings() const
    {
        return Configured::template Get<EndgameConfig>();
    }
    
    inline
    const auto & SecuritySettings() const
    {
        return this->template Get<SecurityConfig>();
    }
 
    explicit EndgameBase(TrackerType const& tr, const ConfigsAsTuple& settings ) :
        Configured( settings ), PrecT(tr), EndgamePrecPolicyBase<TrackerType>(tr)
    {}
 
 
    template< typename... Ts >
    explicit
    EndgameBase(TrackerType const& tr, const Ts&... ts ) : EndgameBase(tr, Configs::Unpermute( ts... ) ) 
    {}
 
 
    inline unsigned CycleNumber() const { return cycle_number_;}
    inline void CycleNumber(unsigned c) { cycle_number_ = c;}
    inline void IncrementCycleNumber(unsigned inc) { cycle_number_ += inc;}
 
    
    inline
    const auto& FinalTolerance() const
    {
        return this->template Get<EndgameConfig>().final_tolerance;
    }
 
 

    inline
    void SetFinalTolerance(BRT const& ft){this->template Get<EndgameConfig>().final_tolerance = ft;}
 
 
 

    template<typename CT>
    inline
    const Vec<CT>& FinalApproximation() const 
    {
        return final_approximation_;
    }

    template<typename CT>
    inline
    const Vec<CT>& PreviousApproximation() const 
    {
        return previous_approximation_;
    }

    inline
    NumErrorT ApproximateError() const
    {
        return approximate_error_;
    }
 

    inline 
    const BCT& LatestTime() const
    {
        return AsFlavor().LatestTimeImpl();
    }
 
    // /**
    // \brief Get the system being tracked on, which is referred to by the tracker.
    // */
    // inline
    // const System& GetSystem() const 
    // { 
    //  return GetTracker().GetSystem();
    // }
 
  
    template<typename CT>
    SuccessCode ComputeInitialSamples(const CT & start_time,const CT & target_time, const Vec<CT> & x_endgame_start, TimeCont<CT> & times, SampCont<CT> & samples) // passed by reference to allow times to be filled as well.
    {   
        using RT = typename Eigen::NumTraits<CT>::Real;
        assert(this->template Get<EndgameConfig>().num_sample_points>0 && "number of sample points must be positive");
 
        if (tracking::TrackerTraits<TrackerType>::IsAdaptivePrec)
        {
            assert(Precision(start_time)==Precision(x_endgame_start) && "Computing initial samples requires input time and space with uniform precision");
        }
 
        samples.clear();
        times.clear();
 
        samples.push_back(x_endgame_start);
        times.push_back(start_time);
 
        auto num_vars = this->GetSystem().NumVariables();
        //start at 1, because the input point is the 0th element.
        for(int ii=1; ii < this->template Get<EndgameConfig>().num_sample_points; ++ii)
        { 
            times.emplace_back((times[ii-1] + target_time) * RT(this->template Get<EndgameConfig>().sample_factor)); // next time is a point between the previous time and target time.
            samples.emplace_back(Vec<CT>(num_vars));                                               // sample_factor gives us some point between the two, usually the midpoint.      
 
            auto tracking_success = this->GetTracker().TrackPath(samples[ii],times[ii-1],times[ii],samples[ii-1]);
            this->EnsureAtPrecision(times[ii],Precision(samples[ii]));
 
            if (tracking_success!=SuccessCode::Success)
                return tracking_success;
        }
 
        return SuccessCode::Success;
    }
 
    virtual ~EndgameBase() = default;
};
            
} }// end namespaces bertini
                
 
#endif