001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018package org.apache.commons.math3.optimization.univariate;
019
020import org.apache.commons.math3.util.Incrementor;
021import org.apache.commons.math3.exception.MaxCountExceededException;
022import org.apache.commons.math3.exception.TooManyEvaluationsException;
023import org.apache.commons.math3.exception.NullArgumentException;
024import org.apache.commons.math3.analysis.UnivariateFunction;
025import org.apache.commons.math3.optimization.GoalType;
026import org.apache.commons.math3.optimization.ConvergenceChecker;
027
028/**
029 * Provide a default implementation for several functions useful to generic
030 * optimizers.
031 *
032 * @version $Id: BaseAbstractUnivariateOptimizer.java 1422230 2012-12-15 12:11:13Z erans $
033 * @deprecated As of 3.1 (to be removed in 4.0).
034 * @since 2.0
035 */
036@Deprecated
037public abstract class BaseAbstractUnivariateOptimizer
038    implements UnivariateOptimizer {
039    /** Convergence checker. */
040    private final ConvergenceChecker<UnivariatePointValuePair> checker;
041    /** Evaluations counter. */
042    private final Incrementor evaluations = new Incrementor();
043    /** Optimization type */
044    private GoalType goal;
045    /** Lower end of search interval. */
046    private double searchMin;
047    /** Higher end of search interval. */
048    private double searchMax;
049    /** Initial guess . */
050    private double searchStart;
051    /** Function to optimize. */
052    private UnivariateFunction function;
053
054    /**
055     * @param checker Convergence checking procedure.
056     */
057    protected BaseAbstractUnivariateOptimizer(ConvergenceChecker<UnivariatePointValuePair> checker) {
058        this.checker = checker;
059    }
060
061    /** {@inheritDoc} */
062    public int getMaxEvaluations() {
063        return evaluations.getMaximalCount();
064    }
065
066    /** {@inheritDoc} */
067    public int getEvaluations() {
068        return evaluations.getCount();
069    }
070
071    /**
072     * @return the optimization type.
073     */
074    public GoalType getGoalType() {
075        return goal;
076    }
077    /**
078     * @return the lower end of the search interval.
079     */
080    public double getMin() {
081        return searchMin;
082    }
083    /**
084     * @return the higher end of the search interval.
085     */
086    public double getMax() {
087        return searchMax;
088    }
089    /**
090     * @return the initial guess.
091     */
092    public double getStartValue() {
093        return searchStart;
094    }
095
096    /**
097     * Compute the objective function value.
098     *
099     * @param point Point at which the objective function must be evaluated.
100     * @return the objective function value at specified point.
101     * @throws TooManyEvaluationsException if the maximal number of evaluations
102     * is exceeded.
103     */
104    protected double computeObjectiveValue(double point) {
105        try {
106            evaluations.incrementCount();
107        } catch (MaxCountExceededException e) {
108            throw new TooManyEvaluationsException(e.getMax());
109        }
110        return function.value(point);
111    }
112
113    /** {@inheritDoc} */
114    public UnivariatePointValuePair optimize(int maxEval, UnivariateFunction f,
115                                             GoalType goalType,
116                                             double min, double max,
117                                             double startValue) {
118        // Checks.
119        if (f == null) {
120            throw new NullArgumentException();
121        }
122        if (goalType == null) {
123            throw new NullArgumentException();
124        }
125
126        // Reset.
127        searchMin = min;
128        searchMax = max;
129        searchStart = startValue;
130        goal = goalType;
131        function = f;
132        evaluations.setMaximalCount(maxEval);
133        evaluations.resetCount();
134
135        // Perform computation.
136        return doOptimize();
137    }
138
139    /** {@inheritDoc} */
140    public UnivariatePointValuePair optimize(int maxEval,
141                                             UnivariateFunction f,
142                                             GoalType goalType,
143                                             double min, double max){
144        return optimize(maxEval, f, goalType, min, max, min + 0.5 * (max - min));
145    }
146
147    /**
148     * {@inheritDoc}
149     */
150    public ConvergenceChecker<UnivariatePointValuePair> getConvergenceChecker() {
151        return checker;
152    }
153
154    /**
155     * Method for implementing actual optimization algorithms in derived
156     * classes.
157     *
158     * @return the optimum and its corresponding function value.
159     * @throws TooManyEvaluationsException if the maximal number of evaluations
160     * is exceeded.
161     */
162    protected abstract UnivariatePointValuePair doOptimize();
163}