endgames/events.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//events.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.
//
//events.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 events.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
 

 
#pragma once
 
#include "bertini2/detail/events.hpp"
 
namespace bertini {
 
    namespace endgame{
 
 
    
    ADD_BERTINI_EVENT_TYPE(EndgameEvent,ConstEvent);

    ADD_BERTINI_EVENT_TYPE(EndgameFailure,ConstEvent);

    ADD_BERTINI_EVENT_TYPE(EndgameSuccess,ConstEvent);

    ADD_BERTINI_EVENT_TYPE(MinTrackTimeReached,EndgameFailure);

    ADD_BERTINI_EVENT_TYPE(RefiningFailed,EndgameFailure);

    ADD_BERTINI_EVENT_TYPE(CycleNumTooHigh,EndgameFailure);

    ADD_BERTINI_EVENT_TYPE(SecurityMaxNormReached,EndgameFailure);

    ADD_BERTINI_EVENT_TYPE(Initializing,EndgameEvent);
 

    ADD_BERTINI_EVENT_TYPE(TimeAdvanced,EndgameEvent);

    template<class ObservedT>
    class CircleAdvanced : public EndgameEvent<ObservedT>
    { BOOST_TYPE_INDEX_REGISTER_CLASS
    public:
 
        using CT = typename ObservedT::BaseComplexType;
        CircleAdvanced(const ObservedT & obs, 
                       Vec<CT> const& new_point,
                       CT const& new_time) : EndgameEvent<ObservedT>(obs),
                                                    new_point_(new_point),
                                                    new_time_(new_time)
        {}
 
 
        virtual ~CircleAdvanced() = default;
        CircleAdvanced() = delete;
        
        const auto& NewSample() const {return new_point_;}
 
        const auto& NewTime() const {return new_time_;}
 
    private:
        const Vec<CT>& new_point_;
        const CT& new_time_;
    };
 

    ADD_BERTINI_EVENT_TYPE(ClosedLoop,EndgameEvent);

    ADD_BERTINI_EVENT_TYPE(ApproximatedRoot,EndgameEvent);

    ADD_BERTINI_EVENT_TYPE(Converged,EndgameSuccess);

    ADD_BERTINI_EVENT_TYPE(SampleRefined,EndgameEvent);

    ADD_BERTINI_EVENT_TYPE(InEGOperatingZone,EndgameEvent);
    
 
    template<class ObservedT>
    class PrecisionChanged : public EndgameEvent<ObservedT>
    { BOOST_TYPE_INDEX_REGISTER_CLASS
    public:
        PrecisionChanged(const ObservedT & obs, 
                     unsigned previous, unsigned next) : EndgameEvent<ObservedT>(obs),
                                                    prev_(previous),
                                                    next_(next)
        {}
 
 
        virtual ~PrecisionChanged() = default;
        PrecisionChanged() = delete;
        
        auto Previous() const {return prev_;}

        auto Next() const {return next_;}
    private:
        const unsigned prev_, next_;
    };
 
 
    }// re: namespace endgames
}// re: namespace bertini