DROP Function R¹ Solver Package contains several Built-in R¹ To R¹ Solvers.

• BracketingControlParams BracketingControlParams implements the control parameters for bracketing solutions. BracketingControlParams provides the following parameters.

  • The starting variate from which the search for bracketing begins
  • The initial width for the brackets
  • The factor by which the width expands with each iterative search
  • The number of such iterations.

• BracketingOutput BracketingOutput carries the results of the bracketing initialization. In addition to the fields of ExecutionInitializationOutput, BracketingOutput holds the left/right bracket variates and the corresponding values for the objective function.

• ConvergenceControlParams ConvergenceControlParams holds the fields needed for the controlling the execution of Newton's method. ConvergenceControlParams does that using the following parameters.

• ConvergenceOutput ConvergenceOutput extends the ExecutionInitializationOutput by retaining the starting variate that results from the convergence zone search. ConvergenceOutput does not add any new field to ExecutionInitializationOutput.

• ExecutionControl ExecutionControl implements the core fixed point search execution control and customization functionality. ExecutionControl is used for a) calculating the absolute tolerance, and b) determining whether the OF has reached the goal. ExecutionControl determines the execution termination using its ExecutionControlParams instance.

• ExecutionControlParams ExecutionControlParams holds the parameters needed for controlling the execution of the fixed point finder. ExecutionControlParams fields control the fixed point search in one of the following ways:

  • Number of iterations after which the search is deemed to have failed
  • Relative Objective Function Tolerance Factor which, when reached by the objective function, will indicate that the fixed point has been reached Variate Convergence Factor, factor applied to the initial variate to determine the absolute convergence.
  • Absolute Tolerance fall-back, which is used to determine that the fixed point has been reached when the relative tolerance factor becomes zero
  • Absolute Variate Convergence Fall-back, fall-back used to determine if the variate has converged.

• ExecutionInitializationOutput ExecutionInitializationOutput holds the output of the root initializer calculation. The following are the fields held by ExecutionInitializationOutput.

  • Whether the initialization completed successfully
  • The number of iterations, the number of objective function calculations, and the time taken for the initialization
  • The starting variate from the initialization

• ExecutionInitializer ExecutionInitializer implements the initialization execution and customization functionality. ExecutionInitializer performs two types of variate initialization:

  • Bracketing initialization: This brackets the fixed point using the bracketing algorithm described in https://lakshmidrip.github.io/DROP-Numerical-Core/. If successful, a pair of variate/OF coordinate nodes that bracket the fixed point are generated. These brackets are eventually used by routines that iteratively determine the fixed point. Bracketing initialization is controlled by the parameters in BracketingControlParams.
  • Convergence Zone initialization: This generates a variate that lies within the convergence zone for the iterative determination of the fixed point using the Newton's method. Convergence Zone Determination is controlled by the parameters in ConvergenceControlParams. ExecutionInitializer behavior can be customized/optimized through several of the initialization heuristics techniques implemented in the InitializationHeuristics class.

• FixedPointFinder FixedPointFinder is the base abstract class that is implemented by customized invocations, e.g., Newton method, or any of the bracketing methodologies. FixedPointFinder invokes the core routine for determining the fixed point from the goal. The ExecutionControl determines the execution termination. The initialization heuristics implements targeted customization of the search.

• FixedPointFinder main flow comprises of the following steps:

  • Initialize the fixed point search zone by determining either a) the brackets, or b) the starting variate.
  • Compute the absolute OF tolerance that establishes the attainment of the fixed point.
  • Launch the variate iterator that iterates the variate.
  • Iterate until the desired tolerance has been attained
  • Return the fixed point output.

• Fixed point finders that derive from this provide implementations for the following:

  • Variate initialization: They may choose either bracketing initializer, or the convergence initializer; functionality is provided for both in this module.
  • Variate Iteration: Variates are iterated using a) any of the standard primitive built-in variate iterators (or custom ones), or b) a variate selector scheme for each iteration.

• FixedPointFinderBracketing FixedPointFinderBracketing customizes the FixedPointFinder for bracketing based fixed point finder functionality.

FixedPointFinderBracketing applies the following customization: * Initializes the fixed point finder by computing the starting brackets * Iterating the next search variate using one of the specified variate iterator primitives.

By default, FixedPointFinderBracketing does not do compound iterations of the variate using any schemes - that is done by classes that extend it.

• FixedPointFinderBrent FixedPointFinderBrent customizes FixedPointFinderBracketing by applying the Brent's scheme of compound variate selector.

Brent's scheme, as implemented here, is described in http://www.credit-trader.org. This implementation retains absolute shifts that have happened to the variate for the past 2 iterations as the discriminant that determines the next variate to be generated.

FixedPointFinderBrent uses the following parameters specified in VariateIterationSelectorParams: * The Variate Primitive that is regarded as the "fast" method * The Variate Primitive that is regarded as the "robust" method * The relative variate shift that determines when the "robust" method is to be invoked over the "fast" * The lower bound on the variate shift between iterations that serves as the fall-back to the "robust"

• FixedPointFinderNewton FixedPointFinderNewton customizes the FixedPointFinder for Open (Newton's) fixed point finder functionality.

FixedPointFinderNewton applies the following customization: * Initializes the fixed point finder by computing a starting variate in the convergence zone * Iterating the next search variate using the Newton's method.

• FixedPointFinderOutput FixedPointFinderOutput holds the result of the fixed point search.

• FixedPointFinderOutput contains the following fields:

  • Whether the search completed successfully
  • The number of iterations, the number of objective function base/derivative calculations, and the time taken for the search
  • The output from initialization

• FixedPointFinderOutput FixedPointFinderZheng implements the fixed point locator using Zheng's improvement to Brent's method.

• FixedPointFinderZheng FixedPointFinderZheng overrides the iterateCompoundVariate method to achieve the desired simplification in the iterative variate selection.

• IteratedBracket IteratedBracket holds the left/right bracket variates and the corresponding values for the objective function during each iteration.

• IteratedVariate IteratedVariate holds the variate and the corresponding value for the objective function during each iteration.

• VariateIterationSelectorParams VariateIterationSelectorParams implements the control parameters for the compound variate selector scheme used in Brent's method.

Brent's method uses the following fields in VariateIterationSelectorParams to generate the next variate: * The Variate Primitive that is regarded as the "fast" method * The Variate Primitive that is regarded as the "robust" method * The relative variate shift that determines when the "robust" method is to be invoked over the "fast" * The lower bound on the variate shift between iterations that serves as the fall-back to the "robust"

• VariateIteratorPrimitive VariateIteratorPrimitive implements the various Primitive Variate Iterator routines.

VariateIteratorPrimitive implements the following iteration primitives: * Bisection * False Position * Quadratic * Inverse Quadratic * Ridder

It may be readily enhanced to accommodate additional primitives.

• Main => https://lakshmidrip.github.io/DROP/
• Wiki => https://github.com/lakshmiDRIP/DROP/wiki
• GitHub => https://github.com/lakshmiDRIP/DROP
• Repo Layout Taxonomy => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
• Javadoc => https://lakshmidrip.github.io/DROP/Javadoc/index.html
• Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
• Release Versions => https://lakshmidrip.github.io/DROP/version.html
• Community Credits => https://lakshmidrip.github.io/DROP/credits.html
• Issues Catalog => https://github.com/lakshmiDRIP/DROP/issues