Class BaseAbstractUnivariateIntegrator

    • Field Detail

      • DEFAULT_ABSOLUTE_ACCURACY

        public static final double DEFAULT_ABSOLUTE_ACCURACY
        Default absolute accuracy.
        See Also:
        Constant Field Values
      • DEFAULT_RELATIVE_ACCURACY

        public static final double DEFAULT_RELATIVE_ACCURACY
        Default relative accuracy.
        See Also:
        Constant Field Values
      • DEFAULT_MIN_ITERATIONS_COUNT

        public static final int DEFAULT_MIN_ITERATIONS_COUNT
        Default minimal iteration count.
        See Also:
        Constant Field Values
      • DEFAULT_MAX_ITERATIONS_COUNT

        public static final int DEFAULT_MAX_ITERATIONS_COUNT
        Default maximal iteration count.
        See Also:
        Constant Field Values
      • iterations

        protected final Incrementor iterations
        The iteration count.
    • Constructor Detail

      • BaseAbstractUnivariateIntegrator

        protected BaseAbstractUnivariateIntegrator​(double relativeAccuracy,
                                                   double absoluteAccuracy,
                                                   int minimalIterationCount,
                                                   int maximalIterationCount)
                                            throws MathIllegalArgumentException
        Construct an integrator with given accuracies and iteration counts.

        The meanings of the various parameters are:

        • relative accuracy: this is used to stop iterations if the absolute accuracy can't be achieved due to large values or short mantissa length. If this should be the primary criterion for convergence rather then a safety measure, set the absolute accuracy to a ridiculously small value, like Precision.SAFE_MIN.
        • absolute accuracy: The default is usually chosen so that results in the interval -10..-0.1 and +0.1..+10 can be found with a reasonable accuracy. If the expected absolute value of your results is of much smaller magnitude, set this to a smaller value.
        • minimum number of iterations: minimal iteration is needed to avoid false early convergence, e.g. the sample points happen to be zeroes of the function. Users can use the default value or choose one that they see as appropriate.
        • maximum number of iterations: usually a high iteration count indicates convergence problems. However, the "reasonable value" varies widely for different algorithms. Users are advised to use the default value supplied by the algorithm.
        Parameters:
        relativeAccuracy - relative accuracy of the result
        absoluteAccuracy - absolute accuracy of the result
        minimalIterationCount - minimum number of iterations
        maximalIterationCount - maximum number of iterations
        Throws:
        MathIllegalArgumentException - if minimal number of iterations is not strictly positive
        MathIllegalArgumentException - if maximal number of iterations is lesser than or equal to the minimal number of iterations
      • BaseAbstractUnivariateIntegrator

        protected BaseAbstractUnivariateIntegrator​(double relativeAccuracy,
                                                   double absoluteAccuracy)
        Construct an integrator with given accuracies.
        Parameters:
        relativeAccuracy - relative accuracy of the result
        absoluteAccuracy - absolute accuracy of the result
      • BaseAbstractUnivariateIntegrator

        protected BaseAbstractUnivariateIntegrator​(int minimalIterationCount,
                                                   int maximalIterationCount)
                                            throws MathIllegalArgumentException
        Construct an integrator with given iteration counts.
        Parameters:
        minimalIterationCount - minimum number of iterations
        maximalIterationCount - maximum number of iterations
        Throws:
        MathIllegalArgumentException - if minimal number of iterations is not strictly positive
        MathIllegalArgumentException - if maximal number of iterations is lesser than or equal to the minimal number of iterations
    • Method Detail

      • getMaximalIterationCount

        public int getMaximalIterationCount()
        Get the upper limit for the number of iterations.
        Specified by:
        getMaximalIterationCount in interface UnivariateIntegrator
        Returns:
        the actual upper limit
      • getEvaluations

        public int getEvaluations()
        Get the number of function evaluations of the last run of the integrator.
        Specified by:
        getEvaluations in interface UnivariateIntegrator
        Returns:
        number of function evaluations
      • getIterations

        public int getIterations()
        Get the number of iterations of the last run of the integrator.
        Specified by:
        getIterations in interface UnivariateIntegrator
        Returns:
        number of iterations
      • getMin

        protected double getMin()
        Get the lower bound.
        Returns:
        the lower bound.
      • getMax

        protected double getMax()
        Get the upper bound.
        Returns:
        the upper bound.
      • computeObjectiveValue

        protected double computeObjectiveValue​(double point)
                                        throws MathIllegalStateException
        Compute the objective function value.
        Parameters:
        point - Point at which the objective function must be evaluated.
        Returns:
        the objective function value at specified point.
        Throws:
        MathIllegalStateException - if the maximal number of function evaluations is exceeded.
      • doIntegrate

        protected abstract double doIntegrate()
                                       throws MathIllegalStateException
        Method for implementing actual integration algorithms in derived classes.
        Returns:
        the root.
        Throws:
        MathIllegalStateException - if the maximal number of evaluations is exceeded.
        MathIllegalStateException - if the maximum iteration count is exceeded or the integrator detects convergence problems otherwise