|
Commons Math example source code file (AbstractScalarDifferentiableOptimizer.java)
The Commons Math AbstractScalarDifferentiableOptimizer.java source code/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.math.optimization.general; import org.apache.commons.math.FunctionEvaluationException; import org.apache.commons.math.MaxEvaluationsExceededException; import org.apache.commons.math.MaxIterationsExceededException; import org.apache.commons.math.analysis.DifferentiableMultivariateRealFunction; import org.apache.commons.math.analysis.MultivariateVectorialFunction; import org.apache.commons.math.optimization.GoalType; import org.apache.commons.math.optimization.OptimizationException; import org.apache.commons.math.optimization.RealConvergenceChecker; import org.apache.commons.math.optimization.DifferentiableMultivariateRealOptimizer; import org.apache.commons.math.optimization.RealPointValuePair; import org.apache.commons.math.optimization.SimpleScalarValueChecker; /** * Base class for implementing optimizers for multivariate scalar functions. * <p>This base class handles the boilerplate methods associated to thresholds * settings, iterations and evaluations counting.</p> * @version $Revision: 925812 $ $Date: 2010-03-21 11:49:31 -0400 (Sun, 21 Mar 2010) $ * @since 2.0 */ public abstract class AbstractScalarDifferentiableOptimizer implements DifferentiableMultivariateRealOptimizer { /** Default maximal number of iterations allowed. */ public static final int DEFAULT_MAX_ITERATIONS = 100; /** Convergence checker. */ protected RealConvergenceChecker checker; /** * Type of optimization. * @since 2.1 */ protected GoalType goal; /** Current point set. */ protected double[] point; /** Maximal number of iterations allowed. */ private int maxIterations; /** Number of iterations already performed. */ private int iterations; /** Maximal number of evaluations allowed. */ private int maxEvaluations; /** Number of evaluations already performed. */ private int evaluations; /** Number of gradient evaluations. */ private int gradientEvaluations; /** Objective function. */ private DifferentiableMultivariateRealFunction function; /** Objective function gradient. */ private MultivariateVectorialFunction gradient; /** Simple constructor with default settings. * <p>The convergence check is set to a {@link SimpleScalarValueChecker} * and the maximal number of evaluation is set to its default value.</p> */ protected AbstractScalarDifferentiableOptimizer() { setConvergenceChecker(new SimpleScalarValueChecker()); setMaxIterations(DEFAULT_MAX_ITERATIONS); setMaxEvaluations(Integer.MAX_VALUE); } /** {@inheritDoc} */ public void setMaxIterations(int maxIterations) { this.maxIterations = maxIterations; } /** {@inheritDoc} */ public int getMaxIterations() { return maxIterations; } /** {@inheritDoc} */ public int getIterations() { return iterations; } /** {@inheritDoc} */ public void setMaxEvaluations(int maxEvaluations) { this.maxEvaluations = maxEvaluations; } /** {@inheritDoc} */ public int getMaxEvaluations() { return maxEvaluations; } /** {@inheritDoc} */ public int getEvaluations() { return evaluations; } /** {@inheritDoc} */ public int getGradientEvaluations() { return gradientEvaluations; } /** {@inheritDoc} */ public void setConvergenceChecker(RealConvergenceChecker convergenceChecker) { this.checker = convergenceChecker; } /** {@inheritDoc} */ public RealConvergenceChecker getConvergenceChecker() { return checker; } /** Increment the iterations counter by 1. * @exception OptimizationException if the maximal number * of iterations is exceeded */ protected void incrementIterationsCounter() throws OptimizationException { if (++iterations > maxIterations) { throw new OptimizationException(new MaxIterationsExceededException(maxIterations)); } } /** * Compute the gradient vector. * @param evaluationPoint point at which the gradient must be evaluated * @return gradient at the specified point * @exception FunctionEvaluationException if the function gradient */ protected double[] computeObjectiveGradient(final double[] evaluationPoint) throws FunctionEvaluationException { ++gradientEvaluations; return gradient.value(evaluationPoint); } /** * Compute the objective function value. * @param evaluationPoint point at which the objective function must be evaluated * @return objective function value at specified point * @exception FunctionEvaluationException if the function cannot be evaluated * or its dimension doesn't match problem dimension or the maximal number * of iterations is exceeded */ protected double computeObjectiveValue(final double[] evaluationPoint) throws FunctionEvaluationException { if (++evaluations > maxEvaluations) { throw new FunctionEvaluationException(new MaxEvaluationsExceededException(maxEvaluations), evaluationPoint); } return function.value(evaluationPoint); } /** {@inheritDoc} */ public RealPointValuePair optimize(final DifferentiableMultivariateRealFunction f, final GoalType goalType, final double[] startPoint) throws FunctionEvaluationException, OptimizationException, IllegalArgumentException { // reset counters iterations = 0; evaluations = 0; gradientEvaluations = 0; // store optimization problem characteristics function = f; gradient = f.gradient(); goal = goalType; point = startPoint.clone(); return doOptimize(); } /** Perform the bulk of optimization algorithm. * @return the point/value pair giving the optimal value for objective function * @exception FunctionEvaluationException if the objective function throws one during * the search * @exception OptimizationException if the algorithm failed to converge * @exception IllegalArgumentException if the start point dimension is wrong */ protected abstract RealPointValuePair doOptimize() throws FunctionEvaluationException, OptimizationException, IllegalArgumentException; } Other Commons Math examples (source code examples)Here is a short list of links related to this Commons Math AbstractScalarDifferentiableOptimizer.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.