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
018 package org.apache.commons.math3.optimization.univariate;
019
020 import org.apache.commons.math3.util.Incrementor;
021 import org.apache.commons.math3.exception.MaxCountExceededException;
022 import org.apache.commons.math3.exception.TooManyEvaluationsException;
023 import org.apache.commons.math3.exception.NullArgumentException;
024 import org.apache.commons.math3.analysis.UnivariateFunction;
025 import org.apache.commons.math3.optimization.GoalType;
026 import 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
037 public 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 }