class used to finish tracking paths during Homotopy Continuation More...

#include <powerseries.hpp>

Inheritance diagram for bertini::endgame::PowerSeriesEndgame< PrecT >:

Collaboration diagram for bertini::endgame::PowerSeriesEndgame< PrecT >:

Public Types
using	BaseEGT = EndgameBase<PowerSeriesEndgame<PrecT>, PrecT>
	The base endgame type.
using	FinalEGT = PowerSeriesEndgame<PrecT>
	The final (derived) endgame type.
using	TrackerType = typename BaseEGT::TrackerType
	The path-tracker type.
using	BaseComplexT = typename BaseEGT::BaseComplexT
	The complex number type.
using	BaseRealT = typename BaseEGT::BaseRealT
	The real number type.
using	EmitterType = PowerSeriesEndgame<PrecT>
	The event-emitter type.
using	Config
	The configuration bundle this endgame reads, public so that generic machinery which works in terms of an object's configs – the Python bindings' ConfiguredVisitor, which needs Config::UsedConfigs – can serve an endgame the same way it serves a tracker or a solver.
using	UsedConfigs
	The list of configuration types this object holds.

Public Member Functions
auto	UpperBoundOnCycleNumber () const
template<typename ComplexT>
void	ClearTimesAndSamples ()
	Function that clears all samples and times from data members for the Power Series endgame.
template<typename ComplexT>
void	SetTimes (TimeCont< ComplexT > const &times_to_set)
	Function to set the times used for the Power Series endgame.
template<typename ComplexT>
const auto &	GetTimes () const
	Function to get the times used for the Power Series endgame.
const BCT &	LatestTimeImpl () const
template<typename ComplexT>
void	SetSamples (SampCont< ComplexT > const &samples_to_set)
	Function to set the space values used for the Power Series endgame.
template<typename ComplexT>
const auto &	GetSamples () const
	Function to get the space values used for the Power Series endgame.
template<typename ComplexT>
void	SetRandVec (int size)
	Function to set the times used for the Power Series endgame.
	PowerSeriesEndgame (TrackerType const &tr, const ConfigsAsTuple &settings)
	Construct the power-series endgame for a tracker, with its configuration as a tuple.
template<typename... Ts>
	PowerSeriesEndgame (TrackerType const &tr, const Ts &... ts)
	Construct the power-series endgame for a tracker, with configs given in any order.
template<typename ComplexT>
unsigned	ComputeBoundOnCycleNumber ()
	Computes an upper bound on the cycle number.
template<typename ComplexT>
unsigned	ComputeCycleNumber (ComplexT const &t0)
	This function computes the cycle number using an exhaustive search up the upper bound computed by the above function BoundOnCyleNumber.
template<typename ComplexT>
void	ComputeAllDerivatives ()
	Compute a set of derivatives using internal data to the endgame.
template<typename ComplexT>
std::tuple< TimeCont< ComplexT >, SampCont< ComplexT > >	TransformToSPlane (int cycle_num, ComplexT const &t0, unsigned num_pts, ContStart shift_from)
	Transform the stored times and derivatives into the S-plane, scaled by the cycle number.
template<typename ComplexT>
SuccessCode	ComputeApproximationOfXAtT0 (Vec< ComplexT > &result, const ComplexT &t0)
	This function computes an approximation of the space value at the time time_t0.
template<typename ComplexT>
SuccessCode	AdvanceTime (const ComplexT &target_time)
	The samples used in the power series endgame are collected by advancing time to t = 0, by multiplying the current time by the sample factor.
template<typename ComplexT>
void	NoteWhetherInOperatingZone (SampCont< ComplexT > const &samples) const
	Watch the c/k estimates settle, and say so once when they have.
template<typename ComplexT>
SuccessCode	RunImpl (const ComplexT &start_time, const Vec< ComplexT > &start_point, ComplexT const &target_time)
	Primary function running the Power Series endgame.
template<typename Dummy = void>
SuccessCode	RunImplAMP (BCT const &start_time, Vec< BCT > const &start_point, BCT const &target_time)
	Run the power-series endgame via the double-first adaptive-numeric-type driver, migrating up to mpfr only on tracker escalation.
template<typename ComplexT>
SuccessCode	SetupSegmentT (ComplexT const &start_time, Vec< ComplexT > const &start_point, ComplexT const &target_time)
	Run the pre-loop setup and first extrapolation in a given numeric type, reporting escalation up to the driver.
template<typename Dummy = void>
SuccessCode	AdvanceTimeAMP (BCT const &target_time)
	Advance time at the active numeric type, migrating-and-retrying in mpfr on escalation.
template<typename Dummy = void>
SuccessCode	RefineAllSamplesAMP ()
	Refine all retained samples at the active numeric type, migrating-and-retrying in mpfr on escalation.
template<typename Dummy = void>
void	ComputeAllDerivativesAMP ()
	Compute all sample derivatives at the active numeric type.
template<typename Dummy = void>
SuccessCode	ComputeApproxAMP (BCT const &target_time)
	Compute the power-series extrapolation at the active numeric type, writing into final_approximation_ (BCT).
template<typename Dummy = void>
void	MigrateContainersToPrecision (unsigned newprec)
	Widen this flavor's PowerSeries containers from the complex_dbl slot up to complex_mp at the new precision.
virtual	~PowerSeriesEndgame ()=default
auto	ComputeCOverK (SampCont< ComplexT > const &samples) const -> typename Eigen::NumTraits< ComplexT >::Real
	An estimate of c/k from the three most recent geometric samples.
bool	CheckForCOverKStabilization (std::deque< T > const &c_over_k_array) const
	Have the last few c/k estimates settled to within the user's threshold?
void	SetBoundaryTime (BCT const &t)
	Set the endgame boundary (start) time.
void	SetTargetTime (BCT const &t)
	Set the final target time.
BCT const &	BoundaryTime () const
BCT const &	TargetTime () const
SuccessCode	Run (Vec< BCT > const &start_point)
	Run the endgame from the stored boundary time to the stored target time.
void	EmitComputedSample (Vec< ComplexT > const &sample, ComplexT const &time)
	Announce a completed sample point on the path, as a ComputedSamplePoint.
SuccessCode	RefineAllSamples (SampCont< ComplexT > &samples, TimeCont< ComplexT > &times)
	Refine every sample point to the endgame's refinement tolerance.
SuccessCode	RefineSample (Vec< ComplexT > &result, Vec< ComplexT > const &current_sample, ComplexT const &current_time, NumErrorT tol, unsigned max_iterations) const
	A function passed off to the precision-specific endgame part.
SuccessCode	EndgameTrackPath (Vec< ComplexT > &result, ComplexT const &start_time, ComplexT const &end_time, Vec< ComplexT > const &start_point) const
	Track through the tracker, adapting at the numeric-type boundary.
SuccessCode	EscalateAndMigrate (unsigned guard)
	Raise the endgame to the next precision and migrate the containers' complex_dbl slot up to complex_mp when the tracker's authority escalates.
const auto &	EndgameSettings () const
	This function is inferior to the templated Get<ConfigT> function provided.
const auto &	SecuritySettings () const
bool	BeyondSecurityMaxNorm (RealT const &norm) const
unsigned	CycleNumber () const
void	CycleNumber (unsigned c)
	Set the cycle number.
void	IncrementCycleNumber (unsigned inc)
	Increase the cycle number by the given increment.
const auto &	FinalTolerance () const
	Get the final tolerance to which we are tracking the solution.
void	SetFinalTolerance (NumErrorT const &ft)
	Setter for the final tolerance.
const Vec< ComplexT > &	FinalApproximation () const
	Get the most-recent approximation.
const Vec< ComplexT > &	PreviousApproximation () const
	Get the second-most-recent approximation.
NumErrorT	ApproximateError () const
	Get the most recent accuracy estimate.
const BCT &	LatestTime () const
	Get the latest time at which a point on the path was computed.
SuccessCode	ComputeInitialSamples (const ComplexT &start_time, const ComplexT &target_time, const Vec< ComplexT > &x_endgame_start, TimeCont< ComplexT > &times, SampCont< ComplexT > &samples)
	Get the system being tracked on, which is referred to by the tracker.
const T &	Get () const
	Get the held configuration object of type T.
void	Set (T const &t)
	Set the held configuration object of type T.
void	AddObserver (AnyObserver &new_observer) const
	Add an observer (non-owning) to observe this observable.
void	AddObserver (std::shared_ptr< AnyObserver > const &new_observer) const
	Add an observer whose lifetime is co-owned by this observable.
void	RemoveObserver (AnyObserver &observer) const
	Remove an observer from this observable.
virtual bool	ObservableIsA (std::type_index t) const
	Whether this observable may be observed as the given type.

Public Attributes
BCT	latest_time_cache_
	Scratch so LatestTimeImpl can return a BCT reference in the complex_dbl fast lane.
std::tuple< Ts... >	configuration_
	The held configuration objects, one per config type.

Protected Types
using	TupleOfTimes = typename BaseEGT::TupleOfTimes
	A tuple of time containers, one per numeric type.
using	TupleOfSamps = typename BaseEGT::TupleOfSamps
	A tuple of sample containers, one per numeric type.
using	TupOfVec = typename BaseEGT::TupOfVec
	A tuple of vector containers, one per numeric type.
using	BCT = BaseComplexT
	The complex number type.
using	BRT = BaseRealT
	The real number type.
using	Configs = typename AlgoTraits<FinalEGT>::NeededConfigs
	The configuration bundle (Configured base).
using	ConfigsAsTuple = typename Configs::ToTuple
	The configuration structs as a tuple.
using	Configured
	The Configured base type.
using	NeededTypes
	Arithmetic types this endgame may compute in (sourced from the tracker).
using	TupOfReal
	A tuple of real values, one per numeric type.

Protected Member Functions
template<typename ComplexT>
void	AssertSizesTimeSpace () const
	Debug-assert that the stored time and sample containers have consistent, sufficient sizes.
template<typename ComplexT>
void	AssertSizesTimeSpaceDeriv () const
	Debug-assert that the time, sample, and derivative containers have consistent, sufficient sizes.
void	RefreshCOverKProbe (unsigned size) const
	Draw the c/k probe direction for a run.
Vec< ComplexT > const &	GetCOverKProbe (unsigned size, unsigned prec) const
	The fixed random direction the c/k estimate is projected along.
const PowerSeriesEndgame< PrecT > &	AsFlavor () const
	convert the base endgame into the derived type.
PowerSeriesEndgame< PrecT > &	AsFlavor ()
	Non-const version of AsFlavor.
void	NotifyObservers (AnyEvent const &e) const
	Sends an event to observers that subscribed to its exact dynamic type, then to all catch-all (untyped) observers.
void	NotifyObservers (AnyEvent &e) const
	Notify all observers of a (mutable) event.
bool	HasObservers () const
	Whether anyone is currently observing (conservative).

Protected Attributes
unsigned	upper_bound_on_cycle_number_
	State variable representing a computed upper bound on the cycle number.
TupleOfTimes	times_
	Holds the time values for different space values used in the Power series endgame.
TupleOfSamps	samples_
	Holds the space values used in the Power series endgame.
TupleOfSamps	derivatives_
	Holds the derivatives at each space point.
TupleOfTimes	c_over_k_
	The sliding window of recent c/k estimates, one deque per numeric type.
bool	announced_operating_zone_ = false
	Whether InEGOperatingZone has been emitted for this run.
TupOfVec	rand_vector_
	Random vector used in computing an upper bound on the cycle number.
Vec< BCT >	final_approximation_
	The latest computed approximation of the endpoint.
Vec< BCT >	previous_approximation_
	The previous approximation of the endpoint.
unsigned int	cycle_number_
	The current estimate of the cycle number.
NumErrorT	approximate_error_
	The error estimate between successive approximations.
BCT	start_time_
	The endgame boundary time; set via SetBoundaryTime().
BCT	target_time_
	The final target time (default 0); set via SetTargetTime().
Vec< complex_dbl >	c_over_k_probe_as_drawn_
	The random direction the c/k estimate is projected along, as drawn: in double precision, so that it is exact in every lane and at every multiple precision.
TupOfVec	c_over_k_probe_
	The c/k probe in each numeric type the endgame computes in: exact conversions of c_over_k_probe_as_drawn_, re-derived when their size or precision is wrong, never rounded.

Detailed Description

template<typename PrecT>
class bertini::endgame::PowerSeriesEndgame< PrecT >

class used to finish tracking paths during Homotopy Continuation

Explanation

The bertini::PowerSeriesEndgame class enables us to finish tracking on possibly singular paths on an arbitrary square homotopy.

The intended usage is to:

Create a system, tracker, and instantiate some settings.
Using the tracker created track to the engame boundary, by default this is t = 0.1.
Create a PowerSeriesEndgame, associating it to the tracker you wish to use. The tracker knows the system being solved.
For each path being tracked send the PowerSeriesEndgame the time value and other variable values that it should use to start the endgame.
The PowerSeriesEndgame, if successful, will store the homotopy solutions at t = 0.

Example Usage

Below we demonstrate a basic usage of the PowerSeriesEndgame class to find the singularity at t = 0.

The pattern is as described above: create an instance of the class, feeding it the system to be used, and the endgame boundary time and other variable values at the endgame boundary.

using namespace bertini::tracking;
using RealT = tracking::TrackerTraits<TrackerType>::BaseRealT; // Real types
using ComplexT = tracking::TrackerTraits<TrackerType>::BaseComplexT; Complex types
 
// 1. Define the polynomial system that we wish to solve.
System target_sys;
Var x = Variable::Make("x"), t = Variable::Make("t"), y = Variable::Make("y");
 
VariableGroup vars{x,y};
target_sys.AddVariableGroup(vars);
 
target_sys.AddFunction((pow(x-1,3));
target_sys.AddFunction((pow(y-1,2));
 
// 1b. Homogenize and patch the polynomial system to work over projective space.
sys.Homogenize();
sys.AutoPatch();
 
// 2. Create a start system, for us we will use a total degree start system.
auto TD_start_sys = bertini::start_system::TotalDegreeLinearProduct(target_sys);
 
// 2b. Creating homotopy between the start system and system we wish to solve.
auto my_homotopy = (1-t)*target_sys + t*TD_start_sys*Rational::Rand(); //the random number is our gamma for a random path between t = 1 and t = 0.
my_homotopy.AddPathVariable(t);
 
//Sets up configuration settings for our particular system.
auto precision_config = PrecisionConfig(my_homotopy);
 
 
// 3. Creating a tracker. For us this is an AMPTracker.
AMPTracker tracker(my_homotopy);
 
//Tracker setup of settings.
SteppingConfig<RealT> stepping_preferences;
stepping_preferences.initial_step_size = RealT(1)/RealT(5);// change a stepping preference
NewtonConfig newton_preferences;
tracker.Setup(TestedPredictor,
            RealFromString("1e-6"),
            RealFromString("1e5"),
        stepping_preferences,
        newton_preferences);
tracker.PrecisionSetup(precision_config);
 
//We start at t = 1, and will stop at t = 0.1 before starting the endgames.
ComplexT t_start(1), t_endgame_boundary(0.1);
 
//This will hold our solutions at t = 0.1
std::vector<Vec<ComplexT> > my_homotopy_solutions_at_endgame_boundary;
 
// result holds the value we track to at 0.1, and tracking success will report if we are unsucessful.
Vec<ComplexT> result;
 
//4. Track all points to 0.1
for (unsigned ii = 0; ii < TD_start_sys.NumStartPoints(); ++ii)
{
    DefaultPrecision(ambient_precision);
    auto start_point = TD_start_sys.StartPoint<ComplexT>(ii);
 
    tracker.TrackPath(result,t_start,t_endgame_boundary,start_point);
 
    my_homotopy_solutions_at_endgame_boundary.push_back(result);
}
 
 
//Settings for the endgames.
 
PowerSeriesConfig power_series_settings;
power_series_settings.max_cycle_number = 4;
 
 
// 5. Create a power series endgame, and use them to get the soutions at t = 0.
EndgameSelector<TrackerType>::PSEG my_pseg_endgame(tracker,power_series_settings,tolerances);
 
 
std::vector<Vec<ComplexT> > my_homotopy_solutions;
 
std::vector<Vec<ComplexT> > my_homotopy_divergent_paths;
 
for(auto s : my_homotopy_solutions_at_endgame_boundary)
{
    SuccessCode endgame_success = my_pseg_endgame.Run(t_endgame_boundary,s);
 
    if(endgame_success == SuccessCode::Success)
    {
        my_homotopy_solutions.push_back(my_homotopy.DehomogenizePoint(my_endgame.FinalApproximation<ComplexT>()));
    }
    else
    {
        my_homotopy_divergent_paths.push_back(my_homotopy.DehomogenizePoint(my_endgame.FinalApproximation<ComplexT>()));
    }
}

If this documentation is insufficient, please contact the authors with suggestions, or get involved! Pull requests welcomed.

Testing

Test suite driving this class: endgames_test.

File: test/endgames/generic_pseg_test.hpp File: test/endgames/amp_powerseries_test.cpp File: test/endgames/fixed_double_powerseries_test.cpp FIle: test/endgames/fixed_multiple_powerseries_test.cpp

Member Typedef Documentation

◆ BaseComplexT

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::BaseComplexT = typename BaseEGT::BaseComplexT

The complex number type.

◆ BaseEGT

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::BaseEGT = EndgameBase<PowerSeriesEndgame<PrecT>, PrecT>

The base endgame type.

◆ BaseRealT

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::BaseRealT = typename BaseEGT::BaseRealT

The real number type.

◆ BCT

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::BCT = BaseComplexT

protected

The complex number type.

◆ BRT

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::BRT = BaseRealT

protected

The real number type.

◆ Config

using bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::Config

inherited

The configuration bundle this endgame reads, public so that generic machinery which works in terms of an object's configs – the Python bindings' ConfiguredVisitor, which needs Config::UsedConfigs – can serve an endgame the same way it serves a tracker or a solver.

The same type as the protected Configured alias below.

◆ Configs

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::Configs = typename AlgoTraits<FinalEGT>::NeededConfigs

protected

The configuration bundle (Configured base).

◆ ConfigsAsTuple

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::ConfigsAsTuple = typename Configs::ToTuple

protected

The configuration structs as a tuple.

◆ Configured

using bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::Configured

protectedinherited

The Configured base type.

◆ EmitterType

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::EmitterType = PowerSeriesEndgame<PrecT>

The event-emitter type.

◆ FinalEGT

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::FinalEGT = PowerSeriesEndgame<PrecT>

The final (derived) endgame type.

◆ NeededTypes

using bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::NeededTypes

protectedinherited

Arithmetic types this endgame may compute in (sourced from the tracker).

◆ TrackerType

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::TrackerType = typename BaseEGT::TrackerType

The path-tracker type.

◆ TupleOfSamps

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::TupleOfSamps = typename BaseEGT::TupleOfSamps

protected

A tuple of sample containers, one per numeric type.

◆ TupleOfTimes

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::TupleOfTimes = typename BaseEGT::TupleOfTimes

protected

A tuple of time containers, one per numeric type.

◆ TupOfReal

using bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::TupOfReal

protectedinherited

A tuple of real values, one per numeric type.

◆ TupOfVec

template<typename PrecT>

using bertini::endgame::PowerSeriesEndgame< PrecT >::TupOfVec = typename BaseEGT::TupOfVec

protected

A tuple of vector containers, one per numeric type.

◆ UsedConfigs

using bertini::detail::Configured< Ts >::UsedConfigs

inherited

The list of configuration types this object holds.

Constructor & Destructor Documentation

◆ PowerSeriesEndgame() [1/2]

template<typename PrecT>

bertini::endgame::PowerSeriesEndgame< PrecT >::PowerSeriesEndgame	(	TrackerType const &	tr,
		const ConfigsAsTuple &	settings )

inlineexplicit

Construct the power-series endgame for a tracker, with its configuration as a tuple.

◆ PowerSeriesEndgame() [2/2]

template<typename PrecT>

template<typename... Ts>

bertini::endgame::PowerSeriesEndgame< PrecT >::PowerSeriesEndgame	(	TrackerType const &	tr,
		const Ts &...	ts )

inlineexplicit

Construct the power-series endgame for a tracker, with configs given in any order.

◆ ~PowerSeriesEndgame()

template<typename PrecT>

virtual bertini::endgame::PowerSeriesEndgame< PrecT >::~PowerSeriesEndgame ( )

virtualdefault

Member Function Documentation

◆ AddObserver() [1/2]

void bertini::Observable::AddObserver ( AnyObserver & new_observer ) const

inlineinherited

Add an observer (non-owning) to observe this observable.

Stores only a raw reference: the caller is responsible for keeping the observer alive while it is attached. This is the right overload for stack-allocated C++ observers added and removed within a scope. For an observer whose lifetime you would rather have tracked, see the shared_ptr overload.

Observers that override SubscribedEventTypes() with a non-empty list are registered in a type-indexed map so NotifyObservers only calls them for events they declared interest in. Observers returning an empty list (the default) are placed in a catch-all list and receive every event.

Safe to call from inside an observer's Observe() (i.e. during a notification): the add is deferred and applied once the current notification loop finishes. This is what lets a "meta-observer" attach new observers in response to events.

Exceptions

IncompatibleObserver if the observer's ObservedKind() is not one this observable can be observed as.

◆ AddObserver() [2/2]

void bertini::Observable::AddObserver ( std::shared_ptr< AnyObserver > const & new_observer ) const

inlineinherited

Add an observer whose lifetime is co-owned by this observable.

The observable keeps a shared_ptr, so the observer stays alive (and keeps receiving events) for as long as it is attached, even after the caller drops their own reference — "attach it and forget it", with no dangling. It is released when RemoveObserver is called or this observable is destroyed. (Stack-allocated C++ observers can't be shared_ptr-owned; use the reference overload for those.)

Exceptions

IncompatibleObserver if incompatible (see the reference overload).

◆ AdvanceTime()

template<typename PrecT>

template<typename ComplexT>

SuccessCode bertini::endgame::PowerSeriesEndgame< PrecT >::AdvanceTime ( const ComplexT & target_time )

inline

The samples used in the power series endgame are collected by advancing time to t = 0, by multiplying the current time by the sample factor.

Input:

target_time: This is the time we are trying to approximate, default is t = 0.

Output:

SuccessCode: This reports back if we were successful in advancing time.

Details:

Template Parameters

ComplexT The complex number type. This function computes the next time value for the power series endgame. After computing this time value, it will track to it and compute the derivative at this time value for further appoximations to be made during the endgame.

◆ AdvanceTimeAMP()

template<typename PrecT>

template<typename Dummy = void>

SuccessCode bertini::endgame::PowerSeriesEndgame< PrecT >::AdvanceTimeAMP ( BCT const & target_time )

inline

Advance time at the active numeric type, migrating-and-retrying in mpfr on escalation.

◆ ApproximateError()

NumErrorT bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::ApproximateError ( ) const

inlineinherited

Get the most recent accuracy estimate.

◆ AsFlavor() [1/2]

PowerSeriesEndgame< PrecT > & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::AsFlavor ( )

inlineprotectedinherited

Non-const version of AsFlavor.

◆ AsFlavor() [2/2]

const PowerSeriesEndgame< PrecT > & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::AsFlavor ( ) const

inlineprotectedinherited

convert the base endgame into the derived type.

This enables the CRPT as used by the endgames

◆ AssertSizesTimeSpace()

template<typename PrecT>

template<typename ComplexT>

void bertini::endgame::PowerSeriesEndgame< PrecT >::AssertSizesTimeSpace ( ) const

inlineprotected

Debug-assert that the stored time and sample containers have consistent, sufficient sizes.

◆ AssertSizesTimeSpaceDeriv()

template<typename PrecT>

template<typename ComplexT>

void bertini::endgame::PowerSeriesEndgame< PrecT >::AssertSizesTimeSpaceDeriv ( ) const

inlineprotected

Debug-assert that the time, sample, and derivative containers have consistent, sufficient sizes.

◆ BeyondSecurityMaxNorm()

bool bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::BeyondSecurityMaxNorm ( RealT const & norm ) const

inlineinherited

Returns: True when a dehomogenized norm calls for security truncation: above max_norm, or NaN. NaN must count as beyond – every IEEE comparison against NaN is false, so a plain norm > max_norm valve is BLIND to exactly the paths most likely to be diverging (a NaN dehom norm means the homogenizing coordinate vanished: the path is at infinity).

◆ BoundaryTime()

BCT const & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::BoundaryTime ( ) const

inlineinherited

Returns: The endgame boundary (start) time.

◆ CheckForCOverKStabilization()

bool bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::CheckForCOverKStabilization ( std::deque< T > const & c_over_k_array ) const

inlineinherited

Have the last few c/k estimates settled to within the user's threshold?

The operating-zone test: consecutive estimates agreeing to within minimum_for_c_over_k_stabilization, for num_needed_for_stabilization of them, is taken as the cycle-number estimate having settled. Both endgames use this and mean the same thing by it (b2#402).

Template Parameters

T	The element type of the estimate window; real or complex, since only its magnitude is read (the Cauchy endgame keeps reals, the power series endgame keeps its numeric type).

Parameters

c_over_k_array The estimates so far, oldest first.

Returns: Whether they have settled.

◆ ClearTimesAndSamples()

template<typename PrecT>

template<typename ComplexT>

void bertini::endgame::PowerSeriesEndgame< PrecT >::ClearTimesAndSamples ( )

inline

Function that clears all samples and times from data members for the Power Series endgame.

◆ ComputeAllDerivatives()

template<typename PrecT>

template<typename ComplexT>

void bertini::endgame::PowerSeriesEndgame< PrecT >::ComputeAllDerivatives ( )

inline

Compute a set of derivatives using internal data to the endgame.

Input:

None: all data needed are class data members.

Output:

None: Derivatives are members of this class.

Details:

Template Parameters

ComplexT The complex number type.

◆ ComputeAllDerivativesAMP()

template<typename PrecT>

template<typename Dummy = void>

void bertini::endgame::PowerSeriesEndgame< PrecT >::ComputeAllDerivativesAMP ( )

inline

Compute all sample derivatives at the active numeric type.

◆ ComputeApproxAMP()

template<typename PrecT>

template<typename Dummy = void>

SuccessCode bertini::endgame::PowerSeriesEndgame< PrecT >::ComputeApproxAMP ( BCT const & target_time )

inline

Compute the power-series extrapolation at the active numeric type, writing into final_approximation_ (BCT).

◆ ComputeApproximationOfXAtT0()

template<typename PrecT>

template<typename ComplexT>

SuccessCode bertini::endgame::PowerSeriesEndgame< PrecT >::ComputeApproximationOfXAtT0	(	Vec< ComplexT > &	result,
		const ComplexT &	t0 )

inline

This function computes an approximation of the space value at the time time_t0.

Input:

result: Passed by reference this holds the value of the approximation we compute t0: This is the time value for which we wish to compute an approximation at.

Output:

SuccessCode: This reports back if we were successful in making an approximation.

Details:

Template Parameters

ComplexT The complex number type. This function handles computing an approximation at the origin. We compute the cycle number best for the approximation, and convert derivatives and times to the s-plane where s = t^(1/c). We use the converted times and derivatives along with the samples to do a Hermite interpolation.

◆ ComputeBoundOnCycleNumber()

template<typename PrecT>

template<typename ComplexT>

unsigned bertini::endgame::PowerSeriesEndgame< PrecT >::ComputeBoundOnCycleNumber ( )

inline

Computes an upper bound on the cycle number.

Consult page 53 of [4].

Input:

None: all data needed are class data members.

Output:

upper_bound_on_cycle_number_: Used for an exhaustive search for the best cycle number for approimating the path to t = 0.

Details:

Template Parameters

ComplexT The complex number type.

◆ ComputeCOverK()

auto bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::ComputeCOverK ( SampCont< ComplexT > const & samples ) const->typenameEigen::NumTraits< ComplexT >::Real

inlineinherited

An estimate of c/k from the three most recent geometric samples.

Assumes the path is in the endgame operating zone, where the Puiseux asymptotics dominate; as the cycle-number estimate settles, successive values of this estimate settle with it, which is what CheckForCOverKStabilization watches for.

It reads only the geometrically-spaced approach samples and the fixed probe, which every endgame flavor maintains – the power series endgame's samples_ and the Cauchy endgame's pseg_samples_ are the same window under two names – so it belongs here rather than to either flavor (b2#402). Consult page 53 of [4] for the heuristic.

Template Parameters

ComplexT The complex number type.

Parameters

samples The geometric approach samples; the first three are used.

Returns: The estimate, never below 1.

◆ ComputeCycleNumber()

template<typename PrecT>

template<typename ComplexT>

unsigned bertini::endgame::PowerSeriesEndgame< PrecT >::ComputeCycleNumber ( ComplexT const & t0 )

inline

This function computes the cycle number using an exhaustive search up the upper bound computed by the above function BoundOnCyleNumber.

## Input:
        None: all data needed are class data members.

## Output:
        cycle_number_: Used to create a hermite interpolation to t = 0.

##Details:
        \tparam ComplexT The complex number type.
    This is done by an exhaustive search from 1 to upper_bound_on_cycle_number. There is a conversion to the s-space from t-space in this function.

As a by-product the derivatives at each of the samples is returned for further use.

◆ ComputeInitialSamples()

SuccessCode bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::ComputeInitialSamples	(	const ComplexT &	start_time,
		const ComplexT &	target_time,
		const Vec< ComplexT > &	x_endgame_start,
		TimeCont< ComplexT > &	times,
		SampCont< ComplexT > &	samples )

inlineinherited

Get the system being tracked on, which is referred to by the tracker.

Populates time and space samples so that we are ready to start the endgame.

Input

    start_time: is the time when we start the endgame process usually this is .1
    x_endgame_start: is the space value at start_time
    times: a deque of time values. These values will be templated to be ComplexT
    samples: a deque of sample values that are in correspondence with the values in times. These values will be vectors with entries of ComplexT.

Output

SuccessCode indicating whether tracking to all samples was successful.

Details

The first sample will be (x_endgame_start) and the first time is start_time.
From there we do a geometric progression using the sample factor (which by default is 1/2).
Hence, next_time = start_time * sample_factor.
We track then to the next_time and construct the next_sample.

Parameters

start_time	The time value at which we start the endgame.
target_time	The time value that we are trying to find a solution to.
x_endgame_start	The current space point at start_time.
times	A deque that will hold all the time values of the samples we are going to use to start the endgame.
samples	a deque that will hold all the samples corresponding to the time values in times.

Template Parameters

ComplexT The complex number type.

◆ CycleNumber() [1/2]

unsigned bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::CycleNumber ( ) const

inlineinherited

Returns: The current cycle number.

◆ CycleNumber() [2/2]

void bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::CycleNumber ( unsigned c )

inlineinherited

Set the cycle number.

◆ EmitComputedSample()

void bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::EmitComputedSample	(	Vec< ComplexT > const &	sample,
		ComplexT const &	time )

inlineinherited

Announce a completed sample point on the path, as a ComputedSamplePoint.

The payload rides at BaseComplexT, so the adaptive endgame's hardware-double fast lane must convert – and only pays for that when something is actually observing. Shared by the initial window here and by each flavor's time advance, so the conversion rule lives in one place.

Parameters

sample	The newly completed sample point on the path.
time	The time value at which it was computed.

Template Parameters

ComplexT The complex number type the endgame is currently working in.

◆ EndgameSettings()

const auto & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::EndgameSettings ( ) const

inlineinherited

This function is inferior to the templated Get<ConfigT> function provided.

◆ EndgameTrackPath()

SuccessCode bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::EndgameTrackPath	(	Vec< ComplexT > &	result,
		ComplexT const &	start_time,
		ComplexT const &	end_time,
		Vec< ComplexT > const &	start_point ) const

inlineinherited

Track through the tracker, adapting at the numeric-type boundary.

The tracker's TrackPath I/O is fixed to BaseComplexT (its TrackerLoopInitialization / CopySolution are non-templatable virtuals). When the adaptive-numeric-type endgame is computing in the hardware complex_dbl fast lane (ComplexT != BCT, i.e. the AMP case), we convert at the boundary: hand the tracker mpfr points at DoublePrecision – so the AMP tracker uses its hardware-double slot internally – then downcast the result back to complex_dbl. If the tracker escalated internally (GetCurrentPrecision() > DoublePrecision()), the caller's escalation hook discards this result and migrates the endgame to mpfr, so the truncating downcast is harmless.

When ComplexT == BCT (every fixed-precision tracker, and the AMP endgame's mpfr lane) this is a direct, zero-overhead call to the tracker – byte-identical to calling TrackPath itself.

MICRO-OPT (future): a native complex_dbl TrackPath overload on the AMP tracker would remove the boundary conversion churn (~1-2% of a track). Deferred – see the sprint notes.

◆ EscalateAndMigrate()

SuccessCode bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::EscalateAndMigrate ( unsigned guard )

inlineinherited

Raise the endgame to the next precision and migrate the containers' complex_dbl slot up to complex_mp when the tracker's authority escalates.

◆ FinalApproximation()

const Vec< ComplexT > & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::FinalApproximation ( ) const

inlineinherited

Get the most-recent approximation.

◆ FinalTolerance()

const auto & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::FinalTolerance ( ) const

inlineinherited

Get the final tolerance to which we are tracking the solution.

◆ Get()

const T & bertini::detail::Configured< Ts >::Get ( ) const

inlineinherited

Get the held configuration object of type T.

◆ GetCOverKProbe()

Vec< ComplexT > const & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::GetCOverKProbe	(	unsigned	size,
		unsigned	prec ) const

inlineprotectedinherited

The fixed random direction the c/k estimate is projected along.

An exact conversion of the direction as drawn, at the requested precision. Converted, not rounded in place: the drawn values are doubles, which every multiple precision holds exactly, so the direction is the same in both lanes and survives any change of precision.

Template Parameters

ComplexT The complex number type.

Parameters

size	The number of coordinates the probe must have.
prec	The working precision to supply it at.

Returns: The probe, by const reference.

◆ GetSamples()

template<typename PrecT>

template<typename ComplexT>

const auto & bertini::endgame::PowerSeriesEndgame< PrecT >::GetSamples ( ) const

inline

Function to get the space values used for the Power Series endgame.

◆ GetTimes()

template<typename PrecT>

template<typename ComplexT>

const auto & bertini::endgame::PowerSeriesEndgame< PrecT >::GetTimes ( ) const

inline

Function to get the times used for the Power Series endgame.

◆ HasObservers()

bool bertini::Observable::HasObservers ( ) const

inlineprotectedinherited

Whether anyone is currently observing (conservative).

Lets an emitter skip constructing an event – and any work needed to build its payload, such as a numeric-type conversion – when there is no observer to receive it. Conservative: returns true if any watcher list is non-empty (even if a stale, emptied typed bucket lingers), so it never wrongly suppresses a real observer.

◆ IncrementCycleNumber()

void bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::IncrementCycleNumber ( unsigned inc )

inlineinherited

Increase the cycle number by the given increment.

◆ LatestTime()

const BCT & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::LatestTime ( ) const

inlineinherited

Get the latest time at which a point on the path was computed.

◆ LatestTimeImpl()

template<typename PrecT>

const BCT & bertini::endgame::PowerSeriesEndgame< PrecT >::LatestTimeImpl ( ) const

inline

Returns: The most recent time value in the sample sequence.

◆ MigrateContainersToPrecision()

template<typename PrecT>

template<typename Dummy = void>

void bertini::endgame::PowerSeriesEndgame< PrecT >::MigrateContainersToPrecision ( unsigned newprec )

inline

Widen this flavor's PowerSeries containers from the complex_dbl slot up to complex_mp at the new precision.

◆ NoteWhetherInOperatingZone()

template<typename PrecT>

template<typename ComplexT>

void bertini::endgame::PowerSeriesEndgame< PrecT >::NoteWhetherInOperatingZone ( SampCont< ComplexT > const & samples ) const

inline

Watch the c/k estimates settle, and say so once when they have.

InEGOperatingZone announces that the path has reached the asymptotic regime, where the Puiseux model the endgame is built on dominates. That is what makes the samples usable quantitatively, so a consumer that is told it every advance is being told nothing.

The window slides, exactly as the Cauchy endgame's does, so the test reads the most recent estimates rather than the first ever taken.

Template Parameters

ComplexT The complex number type.

Parameters

samples The current geometric window; at least three are needed for an estimate.

◆ NotifyObservers() [1/2]

void bertini::Observable::NotifyObservers ( AnyEvent & e ) const

inlineprotectedinherited

Notify all observers of a (mutable) event.

◆ NotifyObservers() [2/2]

void bertini::Observable::NotifyObservers ( AnyEvent const & e ) const

inlineprotectedinherited

Sends an event to observers that subscribed to its exact dynamic type, then to all catch-all (untyped) observers.

Mutations of the observer lists are deferred for the duration of a notification (see AddObserver/RemoveObserver), so iterating the live lists here is safe even when an observer subscribes/unsubscribes mid-dispatch. An observer that returns ObserveResult::Unsubscribe is dropped once the (possibly nested) notification completes. The depth counter keeps this correct under re-entrant emission.

◆ ObservableIsA()

virtual bool bertini::Observable::ObservableIsA ( std::type_index t ) const

inlinevirtualinherited

Whether this observable may be observed as the given type.

Drives the compatibility check in AddObserver. The default accepts the wildcard typeid(void) and this observable's own dynamic type. An observable that emits its events templated on a base type (so a single observer type serves many concrete observables) should also accept that base type — e.g. ZeroDim accepts AnyZeroDim.

◆ PreviousApproximation()

const Vec< ComplexT > & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::PreviousApproximation ( ) const

inlineinherited

Get the second-most-recent approximation.

◆ RefineAllSamples()

SuccessCode bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::RefineAllSamples	(	SampCont< ComplexT > &	samples,
		TimeCont< ComplexT > &	times )

inlineinherited

Refine every sample point to the endgame's refinement tolerance.

◆ RefineAllSamplesAMP()

template<typename PrecT>

template<typename Dummy = void>

SuccessCode bertini::endgame::PowerSeriesEndgame< PrecT >::RefineAllSamplesAMP ( )

inline

Refine all retained samples at the active numeric type, migrating-and-retrying in mpfr on escalation.

◆ RefineSample()

SuccessCode bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::RefineSample	(	Vec< ComplexT > &	result,
		Vec< ComplexT > const &	current_sample,
		ComplexT const &	current_time,
		NumErrorT	tol,
		unsigned	max_iterations ) const

inlineinherited

A function passed off to the precision-specific endgame part.

Templated on ComplexT so the adaptive-numeric-type endgame can refine in the hardware-complex_dbl fast lane as well as in complex_mp. The precision policy (FixedPrecEndgame / AMPEndgame) provides the matching RefineSampleImpl overload(s). Fixed precision only ever instantiates this at BCT.

◆ RefreshCOverKProbe()

void bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::RefreshCOverKProbe ( unsigned size ) const

inlineprotectedinherited

Draw the c/k probe direction for a run.

Called at the start of every run, after whatever reseed the caller does for the path, so the direction is a function of the random-number stream at that point and nothing else.

Parameters

size	The number of coordinates the probe must have.

◆ RemoveObserver()

void bertini::Observable::RemoveObserver ( AnyObserver & observer ) const

inlineinherited

Remove an observer from this observable.

Like AddObserver, this is safe to call during a notification: the removal is deferred until the current notification loop finishes.

◆ Run()

SuccessCode bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::Run ( Vec< BCT > const & start_point )

inlineinherited

Run the endgame from the stored boundary time to the stored target time.

Re-precisions the stored times to match start_point before dispatching to RunImpl, so the caller never needs to worry about precision alignment.

Call SetBoundaryTime() before invoking Run().

◆ RunImpl()

template<typename PrecT>

template<typename ComplexT>

SuccessCode bertini::endgame::PowerSeriesEndgame< PrecT >::RunImpl	(	const ComplexT &	start_time,
		const Vec< ComplexT > &	start_point,
		ComplexT const &	target_time )

inline

Primary function running the Power Series endgame.

Input:

start_time: This is the time value for which the endgame begins, by default this is t = 0.1 start_point: An approximate solution of the homotopy at t = start_time target_time: The time value that we are wishing to approximate to. This is default set to t = 0.

Output:

SuccessCode: This reports back if we were successful in advancing time.

Details:

Template Parameters

ComplexT The complex number type. Tracking forward with the number of sample points, this function will make approximations using Hermite interpolation. This process will continue until two consecutive approximations are withing final tolerance of each other.

◆ RunImplAMP()

template<typename PrecT>

template<typename Dummy = void>

SuccessCode bertini::endgame::PowerSeriesEndgame< PrecT >::RunImplAMP	(	BCT const &	start_time,
		Vec< BCT > const &	start_point,
		BCT const &	target_time )

inline

Run the power-series endgame via the double-first adaptive-numeric-type driver, migrating up to mpfr only on tracker escalation.

◆ SecuritySettings()

const auto & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::SecuritySettings ( ) const

inlineinherited

Returns: The security (divergence-bailout) settings.

◆ Set()

void bertini::detail::Configured< Ts >::Set ( T const & t )

inlineinherited

Set the held configuration object of type T.

◆ SetBoundaryTime()

void bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::SetBoundaryTime ( BCT const & t )

inlineinherited

Set the endgame boundary (start) time.

◆ SetFinalTolerance()

void bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::SetFinalTolerance ( NumErrorT const & ft )

inlineinherited

Setter for the final tolerance.

◆ SetRandVec()

template<typename PrecT>

template<typename ComplexT>

void bertini::endgame::PowerSeriesEndgame< PrecT >::SetRandVec ( int size )

inline

Function to set the times used for the Power Series endgame.

◆ SetSamples()

template<typename PrecT>

template<typename ComplexT>

void bertini::endgame::PowerSeriesEndgame< PrecT >::SetSamples ( SampCont< ComplexT > const & samples_to_set )

inline

Function to set the space values used for the Power Series endgame.

◆ SetTargetTime()

void bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::SetTargetTime ( BCT const & t )

inlineinherited

Set the final target time.

◆ SetTimes()

template<typename PrecT>

template<typename ComplexT>

void bertini::endgame::PowerSeriesEndgame< PrecT >::SetTimes ( TimeCont< ComplexT > const & times_to_set )

inline

Function to set the times used for the Power Series endgame.

◆ SetupSegmentT()

template<typename PrecT>

template<typename ComplexT>

SuccessCode bertini::endgame::PowerSeriesEndgame< PrecT >::SetupSegmentT	(	ComplexT const &	start_time,
		Vec< ComplexT > const &	start_point,
		ComplexT const &	target_time )

inline

Run the pre-loop setup and first extrapolation in a given numeric type, reporting escalation up to the driver.

◆ TargetTime()

BCT const & bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::TargetTime ( ) const

inlineinherited

Returns: The final target time.

◆ TransformToSPlane()

template<typename PrecT>

template<typename ComplexT>

std::tuple< TimeCont< ComplexT >, SampCont< ComplexT > > bertini::endgame::PowerSeriesEndgame< PrecT >::TransformToSPlane	(	int	cycle_num,
		ComplexT const &	t0,
		unsigned	num_pts,
		ContStart	shift_from )

inline

Transform the stored times and derivatives into the S-plane, scaled by the cycle number.

This function transforms the times and derivatives into the S-plane, scaled by the cycle number, and maps them into the interval [0, 1].

Parameters

cycle_num	The cycle number to use.
t0	The base time value of the transform.
num_pts	The number of points to transform.
shift_from	Which end of the sample containers to transform from.

◆ UpperBoundOnCycleNumber()

template<typename PrecT>

auto bertini::endgame::PowerSeriesEndgame< PrecT >::UpperBoundOnCycleNumber ( ) const

inline

Returns: The computed upper bound on the cycle number.

Member Data Documentation

◆ announced_operating_zone_

template<typename PrecT>

bool bertini::endgame::PowerSeriesEndgame< PrecT >::announced_operating_zone_ = false

mutableprotected

Whether InEGOperatingZone has been emitted for this run.

The event says the path has ENTERED the zone, which happens once; it is not a per-advance heartbeat.

◆ approximate_error_

NumErrorT bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::approximate_error_

mutableprotectedinherited

The error estimate between successive approximations.

Initialized to infinity, not left indeterminate: ApproximateError() is a public accessor, so a caller may read it before any endgame has run. Infinity is also the only safe sentinel here – every convergence gate in the flavors has the shape approximate_error_ < FinalTolerance(), and an indeterminate value that happened to be small would be a false convergence.

◆ c_over_k_

template<typename PrecT>

TupleOfTimes bertini::endgame::PowerSeriesEndgame< PrecT >::c_over_k_

mutableprotected

The sliding window of recent c/k estimates, one deque per numeric type.

Kept at num_needed_for_stabilization + 1 entries, so the stabilization test always reads the most recent estimates rather than the first ones ever taken – the same window the Cauchy endgame keeps (b2#402).

◆ c_over_k_probe_

TupOfVec bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::c_over_k_probe_

mutableprotectedinherited

The c/k probe in each numeric type the endgame computes in: exact conversions of c_over_k_probe_as_drawn_, re-derived when their size or precision is wrong, never rounded.

◆ c_over_k_probe_as_drawn_

Vec<complex_dbl> bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::c_over_k_probe_as_drawn_

mutableprotectedinherited

The random direction the c/k estimate is projected along, as drawn: in double precision, so that it is exact in every lane and at every multiple precision.

Drawn at the start of every run (RefreshCOverKProbe) and fixed for the run, so consecutive estimates differ only because the samples differ. A fresh random probe every call made the stabilization test noisy – it could certify the operating zone spuriously – and churned mpfr allocations. See z_notes/20260629.

◆ configuration_

std::tuple<Ts...> bertini::detail::Configured< Ts >::configuration_

inherited

The held configuration objects, one per config type.

◆ cycle_number_

unsigned int bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::cycle_number_

mutableprotectedinherited

The current estimate of the cycle number.

◆ derivatives_

template<typename PrecT>

TupleOfSamps bertini::endgame::PowerSeriesEndgame< PrecT >::derivatives_

mutableprotected

Holds the derivatives at each space point.

◆ final_approximation_

Vec<BCT> bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::final_approximation_

mutableprotectedinherited

The latest computed approximation of the endpoint.

◆ latest_time_cache_

template<typename PrecT>

BCT bertini::endgame::PowerSeriesEndgame< PrecT >::latest_time_cache_

mutable

Scratch so LatestTimeImpl can return a BCT reference in the complex_dbl fast lane.

◆ previous_approximation_

Vec<BCT> bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::previous_approximation_

mutableprotectedinherited

The previous approximation of the endpoint.

◆ rand_vector_

template<typename PrecT>

TupOfVec bertini::endgame::PowerSeriesEndgame< PrecT >::rand_vector_

mutableprotected

Random vector used in computing an upper bound on the cycle number.

Dual-slot (TupOfVec) so the adaptive-numeric-type endgame can form the cycle-number dot products in the active type (it is multiplied against Vec<ComplexT> sample differences, which must match scalar type). Single-slot for fixed precision, as before.

◆ samples_

template<typename PrecT>

TupleOfSamps bertini::endgame::PowerSeriesEndgame< PrecT >::samples_

mutableprotected

Holds the space values used in the Power series endgame.

◆ start_time_

BCT bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::start_time_

protectedinherited

The endgame boundary time; set via SetBoundaryTime().

◆ target_time_

BCT bertini::endgame::EndgameBase< PowerSeriesEndgame< PrecT >, PrecT >::target_time_

protectedinherited

The final target time (default 0); set via SetTargetTime().

◆ times_

template<typename PrecT>

TupleOfTimes bertini::endgame::PowerSeriesEndgame< PrecT >::times_

mutableprotected

Holds the time values for different space values used in the Power series endgame.

◆ upper_bound_on_cycle_number_

template<typename PrecT>

unsigned bertini::endgame::PowerSeriesEndgame< PrecT >::upper_bound_on_cycle_number_

mutableprotected

State variable representing a computed upper bound on the cycle number.

Public Types

Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Explanation

Example Usage

Testing

Member Typedef Documentation

◆ BaseComplexT

◆ BaseEGT

◆ BaseRealT

◆ BCT

◆ BRT

◆ Config

◆ Configs

◆ ConfigsAsTuple

◆ Configured

◆ EmitterType

◆ FinalEGT

◆ NeededTypes

◆ TrackerType

◆ TupleOfSamps

◆ TupleOfTimes

◆ TupOfReal

◆ TupOfVec

◆ UsedConfigs

Constructor & Destructor Documentation

◆ PowerSeriesEndgame() [1/2]

◆ PowerSeriesEndgame() [2/2]

◆ ~PowerSeriesEndgame()

Member Function Documentation

◆ AddObserver() [1/2]

◆ AddObserver() [2/2]

◆ AdvanceTime()

Input:

Output:

Details:

◆ AdvanceTimeAMP()

◆ ApproximateError()

◆ AsFlavor() [1/2]

◆ AsFlavor() [2/2]

◆ AssertSizesTimeSpace()

◆ AssertSizesTimeSpaceDeriv()

◆ BeyondSecurityMaxNorm()

◆ BoundaryTime()

◆ CheckForCOverKStabilization()

◆ ClearTimesAndSamples()

◆ ComputeAllDerivatives()

Input:

Output:

Details:

◆ ComputeAllDerivativesAMP()

◆ ComputeApproxAMP()

◆ ComputeApproximationOfXAtT0()

Input:

Output:

Details:

◆ ComputeBoundOnCycleNumber()

Input:

Output:

Details:

◆ ComputeCOverK()

◆ ComputeCycleNumber()

◆ ComputeInitialSamples()

Input

Output

Details

◆ CycleNumber() [1/2]

◆ CycleNumber() [2/2]

◆ EmitComputedSample()

◆ EndgameSettings()

◆ EndgameTrackPath()

◆ EscalateAndMigrate()

◆ FinalApproximation()

◆ FinalTolerance()

◆ Get()

◆ GetCOverKProbe()