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 }