---

minimize1.h

Go to the documentation of this file.

// SuperMix version 1.0  C++ source file
//
// Copyright (c) 1999 California Institute of Technology.
// All rights reserved.
//
// Redistribution and use in source and binary forms for noncommercial
// purposes are permitted provided that the above copyright notice and
// this paragraph are duplicated in all such forms and that any
// documentation and other materials related to such distribution and
// use acknowledge that the software was developed by California
// Institute of Technology. Redistribution and/or use in source or
// binary forms is not permitted for any commercial purpose. Use of
// this software does not include a permitted use of the Institute's
// name or trademark for any purpose.
//
// DISCLAIMER:
// THIS SOFTWARE AND/OR RELATED MATERIALS ARE PROVIDED "AS-IS" WITHOUT
// WARRANTY OF ANY KIND INCLUDING ANY WARRANTIES OF PERFORMANCE OR
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE OR PURPOSE (AS SET
// FORTH IN UCC 23212-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE
// LICENSED PRODUCT, HOWEVER USED.  IN NO EVENT SHALL CALTECH/JPL BE
// LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING BUT NOT LIMITED TO
// INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, INCLUDING ECONOMIC
// DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, REGARDLESS OF
// WHETHER CALTECH/JPL SHALL BE ADVISED, HAVE REASON TO KNOW, OR IN
// FACT SHALL KNOW OF THE POSSIBILITY.  THE USER BEARS ALL RISK
// RELATING TO QUALITY AND PERFORMANCE OF THE SOFTWARE AND/OR RELATED
// MATERIALS.
//
// ************************************************************************
// minimize1.h
//
// Functions for finding local minima of a real function of 1 real variable.
//
// Contains:
// minimize1(), bracket_minimum(), refine_minimum()


#ifndef MINIMIZE1_H
#define MINIMIZE1_H

// ************************************************************************
// Here's the main minimizer routine:
// Given initial guesses x1 and x2 for the location of a minimum of f(x),
// use:
//      minimize(f, x1,x2, tol);  // tol is optional
// 
// to locate a local minimum to within a fractional tolerance of tol. The
// coordinate of the minimum is returned in x1; minimize() returns f(x)
// at that point. Not supplying the optional tol, or setting it < 1.0e-7
// will use 1.0e-7 as the tolerance. The optional n_max sets the maximum
// number of iterations to attempt; the default value is 1000.

template <class F> inline
double minimize1( F f, // the function
                 double & x1, double x2, // x values
                 double tol, unsigned n_max);

template <class F> inline
double minimize1( F f, // the function
                 double & x1, double x2, // x values
                 double tol)
{ return minimize1(f,x1,x2,tol,1000); }

template <class F> inline
double minimize1( F f, // the function
                 double & x1, double x2  // x values
                )
{ return minimize1(f,x1,x2,1.0e-7,1000); }


// ************************************************************************
// A couple of more primitive routines used by minimize(), using algorithms
// adapted from Press, et.al., Numerical Recipes in C, 2nd ed.:


// bracket_minimum(f, a,b,c, fa,fb,fc):
//
// Given initial guesses a and b, find new a, b, and c such that
// f(b) < f(a) and f(b) < f(c), that is: a and c bracket a local minimum
// of f(x), and b is a point between a and c. Returns 0 if successful,
// 1 if failed (no other error messages are issued if search failed).
// The optional n_max sets the maximum number of iterations to attempt;
// the default value is 1000.

template <class F> inline
int bracket_minimum( F f,  // the function
                     double &  a, double &  b, double &  c, // x values
                     double & fa, double & fb, double & fc, // f(x) values
                     unsigned n_max );

template <class F> inline
int bracket_minimum( F f,  // the function
                     double &  a, double &  b, double &  c, // x values
                     double & fa, double & fb, double & fc  // f(x) values
                    )
{ return bracket_minimum(f,a,b,c,fa,fb,fc,1000); }


// refine_minimum(f, a,b,c);    // (tol defaults to 1.0e-7)
//
// Given a triplet of guesses a,b,c with b between a and c, and f(b) < f(a)
// and f(b) < f(c) (so a local minimum of f(x) must lie between a and c),
// adjusts the values of a,b,c until a <= b <= c and f(b) is the minimum of
// f(x), ie: b estimates the local minimum of f(x), within +/- (tol*b).
// Also, a and c will bracket the minimum, with c - a <= 2*(tol*b).
// Returns f(b). Uses Brent's method. Setting the optional tol < 1.0e-7
// will use 1.0e-7 as the tolerance. The optional n_max sets the maximum
// number of iterations to attempt; the default value is 1000.

template <class F> inline
double refine_minimum( F f, // the function
                       double & a, double & b, double & c, // x values
                       double tol, unsigned n_max);

template <class F> inline
double refine_minimum( F f, // the function
                       double & a, double & b, double & c, // x values
                       double tol)
{ return refine_minimum(f,a,b,c,tol,1000); }

template <class F> inline
double refine_minimum( F f, // the function
                       double & a, double & b, double & c  // x values
                      )
{ return refine_minimum(f,a,b,c,1.0e-7,1000); }


// ************************************************************************
#include "numerical/num_minimize1.h"

#endif  /* MINIMIZE1_H */

---

Please direct comments and corrections to supermix@submm.caltech.edu
Go to the supermix home page
Generated by 1.2.7