---

montecarlo.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.
//
// ************************************************************************
//
// montecarlo.h
// simple Monte Carlo optimizer class
//
// Defines class "montecarlo", which can attempt to find a global minimum
// using a random search in parameter space. This class can run either an
// internal powell local optimizer or a user-specified local optimizer on
// each test point in parameter space. It returns the best local minimum
// found.
//
// The output of montecarlo defaults to "display(false).verbose()", which
// outputs a report of the error function and parameter values each time
// an improved minimum is found. The effect of the display() member function
// is described in the comments near its declaration below. Calling
// very_verbose() additionally sets verbose() on the local optimizer called
// for every candidate point.
//
// When montecarlo::minimize() exits, it sets the parameter values to the
// best values found and calculates the error function one last time,
// returning the resulting error fution value. It does this so that the
// error fution's internal state will be consistent with the value
// returned. 
//
// Also included is class "do_nothing_optimizer", which can be given to
// montecarlo in order to just evaluate test points without running a
// local optimizer on them.
//
// 3/21/00 FRR and JSW
//
// 9/22/00:  Added virtual destructor, so derived classes can change stop()
// 6/13/00:  Some changes to verbose behavior.
//
// ************************************************************************
 

#ifndef MONTECARLO_H
#define MONTECARLO_H

#include "powell.h"

class montecarlo : public minimizer
{
public:
  // NOTE: Constructors have the side effect of seeding the random number
  // generator used by drand48() (defined in <stdlib.h>).

  // Constructor needs the error function to be minimized:
  montecarlo(abstract_error_func & aef);

  // This contructor lets you specify the subordinate minimizer to call:
  montecarlo(abstract_error_func & aef, minimizer & method);

  // How many random starting points to try (default 100):
  montecarlo & npoints(unsigned);

  // Type of verbose output on each iteration (default is false):
  //    set to true:  output each local minimum found
  //    set to false: output only if a better minimum found
  montecarlo & display(bool);

  // Type of verbose output on each iteration. Calling this function
  // causes verbose output to display those local minima whose value
  // is no greater than 1+r times the value of the best minimum seen
  // so far. Example: display(0.1) will cause all minima whose values
  // are no greater than 1.1 of the best seen so far to be displayed.
  // If the best minimum has a negative value, uses 1-r times the value
  // rather than 1+r times. If r <= 0.0, the function's effect is the
  // same as calling display(false). 
  montecarlo & display(double r);

  // The internal powell minimizer used if none specified by the constructor.
  // You can access the powell minimizer using this function so that you
  // may modify its conversion properties. See powell.h for details.
  powell & p() { return p_ ; }

  // Performs the global minimization:
  double minimize();

  // A virtual destructor ensures proper subclass destruction.
  virtual ~montecarlo() { }

private:
  powell p_;            // local minimizer
  minimizer * m;        // user-specified minimizer
  unsigned n;           // number of random points
  bool display_f;       // display flag for the type of verbose output
  double display_r;     // display ratio for the type of verbose output
  double best_e;        // holds best error function result seen
  real_vector best_x;   // holds parameter values yielding best_e
  void randomize();     // randomize the error function parameters
};

inline montecarlo & montecarlo::npoints(unsigned np)
{ n = np; return *this; }

inline montecarlo & montecarlo::display(bool f)
{ display_f = f; display_r = 0.0; return *this; }

inline montecarlo & montecarlo::display(double r)
{ display_f = false; display_r = (r <= 0.0) ? 0.0 : r; return *this; }

// ************************************************************************

class do_nothing_optimizer : public minimizer
{
public:
  // Constructor needs the error function to be minimized:
  do_nothing_optimizer(abstract_error_func & aef) : minimizer(aef) { };

  // Don't do anything!
  double minimize() { return erf(); }
};

#endif /* MONTECARLO_H */

---

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