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) 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/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(SamplesRecomputedAtHigherPrecision,EndgameEvent);
 

    ADD_BERTINI_EVENT_TYPE(TimeAdvanced,EndgameEvent);

    template<class ObservedT>
    class ComputedSamplePoint : public EndgameEvent<ObservedT>
    { BOOST_TYPE_INDEX_REGISTER_CLASS
    public:
 
        using ComplexT = typename ObservedT::BaseComplexT;  

        ComputedSamplePoint(const ObservedT & obs,
                            Vec<ComplexT> const& new_point,
                            ComplexT const& new_time) : EndgameEvent<ObservedT>(obs),
                                                        new_point_(new_point),
                                                        new_time_(new_time)
        {}
 
        virtual ~ComputedSamplePoint() = default;
        ComputedSamplePoint() = delete;

        const auto& NewSample() const {return new_point_;}

        const auto& NewTime() const {return new_time_;}
 
    private:
        const Vec<ComplexT>& new_point_;
        const ComplexT& new_time_;
    };
 

    template<class ObservedT>
    class CircleAdvanced : public EndgameEvent<ObservedT>
    { BOOST_TYPE_INDEX_REGISTER_CLASS
    public:
 
        using ComplexT = typename ObservedT::BaseComplexT;  
        CircleAdvanced(const ObservedT & obs,
                       Vec<ComplexT> const& new_point,
                       ComplexT 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<ComplexT>& new_point_;
        const ComplexT& 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