Implementation of one-dimensional optimization functions. More...

#include "mdb.h"

Macros
#define	DEFAULT_MAXEVALS 100

#define	DEFAULT_MAXPASSES 5

Functions
long	checkVariableLimits (double x, double xlo, double *xhi, long n)

long	OneDScanOptimize (double yReturn, double xGuess, double dxGuess, double xLowerLimit, double xUpperLimit, short disable, long dimensions, double target, double tolerance, double(func)(double x, long invalid), void(report)(double ymin, double *xmin, long pass, long evals, long dims), long maxSteps, long maxDivisions, long maxRepeats, unsigned long flags)
	Performs one-dimensional scan optimization on a multi-dimensional function.

long	OneDParabolicOptimization (double yReturn, double xGuess, double dx, double xLower, double xUpper, double(func)(double x, long invalid), long maxCycles, double dxLimit, double tolerance, long maximize)
	Optimizes a single-variable function using parabolic interpolation.

Detailed Description

Implementation of one-dimensional optimization functions.

Copyright

(c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
(c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License: This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Author: M. Borland, R. Soliday

Definition in file onedoptimize.c.

Macro Definition Documentation

◆ DEFAULT_MAXEVALS

#define DEFAULT_MAXEVALS 100

Definition at line 17 of file onedoptimize.c.

◆ DEFAULT_MAXPASSES

#define DEFAULT_MAXPASSES 5

Definition at line 18 of file onedoptimize.c.

Function Documentation

◆ checkVariableLimits()

long checkVariableLimits	(	double *	x,
		double *	xlo,
		double *	xhi,
		long	n )

Definition at line 48 of file simplex.c.

                                                                      {
  long i;
 
  if (xlo)
    for (i = 0; i < n; i++)
      if (xlo[i] != xhi[i] && x[i] < xlo[i])
        return 0;
 
  if (xhi)
    for (i = 0; i < n; i++)
      if (xlo[i] != xhi[i] && x[i] > xhi[i])
        return 0;
  return 1;
}

◆ OneDParabolicOptimization()

long OneDParabolicOptimization	(	double *	yReturn,
		double *	xGuess,
		double	dx,
		double	xLower,
		double	xUpper,
		double(*	func )(double x, long *invalid),
		long	maxCycles,
		double	dxLimit,
		double	tolerance,
		long	maximize )

Optimizes a single-variable function using parabolic interpolation.

This function performs optimization (minimization or maximization) of a single-variable function using parabolic interpolation. It iteratively adjusts the variable to find the function's minimum or maximum by fitting a parabola to three points and locating its vertex. The optimization continues until convergence criteria based on step size or function value tolerance are met, or until the maximum number of cycles is reached.

Parameters

yReturn	Pointer to store the optimized function value.
xGuess	Initial guess for the variable.
dx	Initial step size for searching.
xLower	The lower bound for the variable.
xUpper	The upper bound for the variable.
func	Pointer to the function to be optimized. It takes the variable and a pointer to an invalid flag.
maxCycles	The maximum number of optimization cycles to perform.
dxLimit	The minimum step size below which the optimization will stop.
tolerance	The tolerance for convergence based on the difference in function values.
maximize	If non-zero, the function will perform maximization instead of minimization.

Returns: Returns 1 on successful optimization, or a negative error code on failure.

Definition at line 299 of file onedoptimize.c.

                                                                {
  double maxFactor, fBest, xBest;
  long invalid, cycle;
  double x0, x1 = 0, x2, f0, f1 = 0, f2;
 
  maxFactor = maximize ? -1 : 1;
  invalid = 0;
 
  x0 = *xGuess;
  f0 = maxFactor * (*func)(x0, &invalid);
  xBest = x0;
  fBest = f0;
 
  *yReturn = maxFactor * f0;
  if (invalid)
    return -1;
 
  /* find direction in which function decreases */
  for (cycle = 0; cycle < 2 * maxCycles; cycle++) {
    x1 = x0 + dx;
    if (x1 == x0)
      break;
    if (x1 > xUpper || x1 < xLower)
      return -2;
    f1 = maxFactor * (*func)(x1, &invalid);
    if (invalid)
      return -1;
#ifdef DEBUG
    fprintf(stderr, "cycle = %ld, maxCycles=%ld, f1 = %21.15e, fBest = %21.15e\n",
            cycle, 2 * maxCycles, f1, fBest);
#endif
    if (f1 < fBest) {
#ifdef DEBUG
      fprintf(stderr, "f1<fBest\n");
#endif
      fBest = f1;
      xBest = x1;
    }
    if (f1 < f0) {
#ifdef DEBUG
      fprintf(stderr, "f1<f0, breaking\n");
#endif
      break;
    }
    dx = dx * (cycle % 2 == 0 ? -1 : -0.5);
  }
  if (x1 == x0)
    return 1;
  if (cycle == 2 * maxCycles) {
    if (fabs(dx) < dxLimit)
      return 1;
    return -3;
  }
#ifdef DEBUG
  fprintf(stderr, "Function decreases with dx=%e, f0=%21.15e, f1=%21.15e, cycle=%ld\n", dx, f0, f1, cycle);
#endif
 
  /* take steps until passing through minimum */
  while (1) {
    x2 = x1 + dx;
    if (x2 > xUpper || x2 < xLower)
      return -4;
    f2 = maxFactor * (*func)(x2, &invalid);
    if (invalid)
      return -1;
    if (f2 < fBest) {
      fBest = f2;
      xBest = x2;
    }
#ifdef DEBUG
    fprintf(stderr, "fBest = %21.15e, f1 = %21.15e, f2 = %21.15e\n",
            fBest, f1, f2);
#endif
    if (f2 > f1)
      break;
    if (x1 == x2)
      break;
    x0 = x1;
    f0 = f1;
    x1 = x2;
    f1 = f2;
  }
  if (x0 > x2) {
    /* arrange in increasing order */
    SWAP_DOUBLE(x0, x2);
    SWAP_DOUBLE(f0, f2);
  }
 
  /* now f0 > f1 and f2 > f1 */
  for (cycle = 0; cycle < maxCycles; cycle++) {
    double numer, denom, x3, f3, scale;
    long failed;
#ifdef DEBUG
    fprintf(stderr, "Cycle %ld:  f(%e)=%e,  f(%e)=%e,  f(%e)=%e\n",
            cycle, x0, f0, x1, f1, x2, f2);
#endif
 
    if (x2 == x0 || (x2 - x0) < dxLimit || (MAX(f2, f0) - f1) < tolerance)
      break;
    /* try parabolic interpolation */
    numer = sqr(x1 - x0) * (f1 - f2) - sqr(x1 - x2) * (f1 - f0);
    denom = (x1 - x0) * (f1 - f2) - (x1 - x2) * (f1 - f0);
    x3 = x1 - numer / denom / 2.0;
    failed = 1;
    scale = x2 - x0;
#ifdef DEBUG
    fprintf(stderr, "parabolic parameters: x3 = %e, f3 = %e, scale=%e, x0=%e, x2=%e\n",
            x3,
            isinf(x3) ? DBL_MAX : maxFactor * (*func)(x3, &invalid), scale, x0, x2);
#endif
    if (!isinf(x3) && x0 < x3 && x3 < x2 &&
        fabs(x3 - x0) > 1e-6 * scale && fabs(x3 - x1) > 1e-6 * scale &&
        fabs(x3 - x2) > 1e-6 * scale) {
      /* evaluate at parabolic interpolation point */
      failed = 0;
      f3 = maxFactor * (*func)(x3, &invalid);
      if (invalid)
        failed = 1;
      else {
        if (f3 < fBest) {
          fBest = f3;
          xBest = x3;
        }
        if (f3 < f1) {
          /* replace point 1 */
          f1 = f3;
          x1 = x3;
        } else if (f2 > f0 && f3 < f2) {
          /* replace point 2 */
          f2 = f3;
          x2 = x3;
          if (x2 < x1) {
            SWAP_DOUBLE(x1, x2);
            SWAP_DOUBLE(f1, f2);
          }
        } else if (f2 < f0 && f3 < f0) {
          /* replace point 0 */
          f0 = f3;
          x0 = x3;
          if (x0 > x1) {
            SWAP_DOUBLE(x0, x1);
            SWAP_DOUBLE(f0, f1);
          }
        } else
          failed = 1;
      }
    }
#ifdef DEBUG
    if (!failed)
      fprintf(stderr, "Parabolic interpolation succeeded\n");
#endif
    if (failed) {
      long right, other;
      for (other = 0; other < 2; other++) {
        /* try dividing one of the intervals */
        if (fabs(x0 - x1) < fabs(x1 - x2)) {
          if (!other) {
            x3 = (x1 + x2) / 2;
            right = 1;
          } else {
            x3 = (x0 + x1) / 2;
            right = 0;
          }
        } else {
          if (!other) {
            x3 = (x0 + x1) / 2;
            right = 0;
          } else {
            x3 = (x1 + x2) / 2;
            right = 1;
          }
        }
        f3 = maxFactor * (*func)(x3, &invalid);
        if (invalid)
          return -1;
        if (f3 < fBest) {
          fBest = f3;
          xBest = x3;
        }
#ifdef DEBUG
        fprintf(stderr, "f3 = %e at x3=%e\n", f3, x3);
#endif
        if (f3 < f1) {
#ifdef DEBUG
          fprintf(stderr, "Replacing point 1\n");
#endif
          f1 = f3;
          x1 = x3;
          break;
        }
        if (right && f3 < f2) {
          /* replace point 2 */
#ifdef DEBUG
          fprintf(stderr, "Replacing point 2\n");
#endif
          f2 = f3;
          x2 = x3;
          if (x2 < x1) {
            SWAP_DOUBLE(x1, x2);
            SWAP_DOUBLE(f1, f2);
          }
          break;
        } else if (!right && f3 < f0) {
          /* replace point 0 */
#ifdef DEBUG
          fprintf(stderr, "Replacing point 0\n");
#endif
          f0 = f3;
          x0 = x3;
          if (x0 > x1) {
            SWAP_DOUBLE(x0, x1);
            SWAP_DOUBLE(f0, f1);
          }
          break;
        }
      }
#ifdef DEBUG
      fprintf(stderr, "Sectioning succeeded\n");
#endif
    }
  }
#ifdef DEBUG
  fprintf(stderr, "Returning: x=%21.15e, y=%21.15e\n",
          xBest, maxFactor * fBest);
#endif
  *yReturn = maxFactor * fBest;
  *xGuess = xBest;
  return 1;
}

◆ OneDScanOptimize()

long OneDScanOptimize	(	double *	yReturn,
		double *	xGuess,
		double *	dxGuess,
		double *	xLowerLimit,
		double *	xUpperLimit,
		short *	disable,
		long	dimensions,
		double	target,
		double	tolerance,
		double(*	func )(double x, long invalid),
		void(*	report )(double ymin, double *xmin, long pass, long evals, long dims),
		long	maxSteps,
		long	maxDivisions,
		long	maxRepeats,
		unsigned long	flags )

Performs one-dimensional scan optimization on a multi-dimensional function.

This function optimizes a given multi-dimensional function by performing a one-dimensional scan along each active dimension. It iteratively adjusts each variable within its specified limits to minimize the target function value. The optimization process continues until the target is achieved, the tolerance is met, or the maximum number of repeats is reached.