Brents.h

Go to the documentation of this file.

//- ****************************************************************************
//-
//- Copyright 2009 National Technology & Engineering Solutions of Sandia, LLC
//- (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
//- Government retains certain rights in this software.
//-
//- BSD Open Source License
//- All rights reserved.
//-
//- Redistribution and use in source and binary forms, with or without
//- modification, are permitted provided that the following conditions are met:
//-
//-   1. Redistributions of source code must retain the above copyright notice,
//-      this list of conditions and the following disclaimer.
//-
//-   2. Redistributions in binary form must reproduce the above copyright
//-      notice, this list of conditions and the following disclaimer in the
//-      documentation and/or other materials provided with the distribution.
//-
//-   3. Neither the name of the copyright holder nor the names of its
//-      contributors may be used to endorse or promote products derived from
//-      this software without specific prior written permission.
//-
//- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
//- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//- POSSIBILITY OF SUCH DAMAGE.
//-
//- ****************************************************************************
 
#ifndef BRENTS_H
#define BRENTS_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <vector>
 
using namespace std;
// use standard library objects
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "UtilGlobals.h"
 
// **** _BEGIN UTIL NAMESPACE_ *************************************************
 
namespace util {
 
// **** _CLASS CONSTANTS_ ******************************************************
// **** _FORWARD REFERENCES_ ***************************************************
 
// **** _CLASS DEFINITION_ *****************************************************
//
//
//
// *****************************************************************************
template<class F>
class UTIL_EXP Brents
{
  public:
 
    // **** _PUBLIC LIFCYCLES_ *************************************************
 
    Brents();
 
    Brents(F& f, double tol);
 
    Brents(const Brents<F>& zb);
 
    virtual ~Brents();
 
    // **** _PUBLIC OPERATORS_ *************************************************
 
    Brents<F>&        operator=(const Brents<F>& zb);
 
    // **** _PUBLIC METHODS_ ***************************************************
 
    //
    double            zeroF(double ax, double bx);
 
    //
    double            minF(double ax, double bx, double cx,
                           double& xmin);
 
    void              setF(F& f);
 
    F&                getF();
 
    const F&          getF() const;
 
    void              setTolerance(double tol);
 
    double            getTolerance() const;
 
    void              setMinimumSearch();
 
    void              setMaximumSearch();
 
    bool              isMinimumSearch() const;
 
    //static void       getTest1(double a, double b, double tol);
 
    //static void       getTest2(double a, double b, double c, double tol,
    //                          const string& minmax);
 
private:
 
    // **** _PRIVATE DATA_ *****************************************************
 
    double            zbTol;
 
    F*                zbF;
 
    double            bMinMaxFlg;
};
 
// **** _INLINE FUNCTION IMPLEMENTATIONS_ **************************************
 
template<class F>
inline void Brents<F>::setF(F& f)
{
  zbF = &f;
}
 
template<class F>
inline F& Brents<F>::getF()
{
  return *zbF;
}
 
template<class F>
inline const F& Brents<F>::getF() const
{
  return *zbF;
}
 
template<class F>
inline void Brents<F>::setTolerance(double tol)
{
  zbTol = tol;
}
 
template<class F>
inline double Brents<F>::getTolerance() const
{
  return zbTol;
}
 
//
template<class F>
inline void Brents<F>::setMinimumSearch()
{
  bMinMaxFlg = 1.0;
}
 
//
template<class F>
inline void Brents<F>::setMaximumSearch()
{
  bMinMaxFlg = -1.0;
}
 
//
template<class F>
inline bool Brents<F>::isMinimumSearch() const
{
  return ((bMinMaxFlg == 1.0) ? true : false);
}
 
// **** _TEST FUNCTION IMPLEMENTATIONS_ **************************************
 
//class TestZeroIn1
//{
//  public:
//
//    //! Default Constructor.
//    TestZeroIn1() {};
//
//    //! Copy Constructor.
//    TestZeroIn1(const TestZeroIn1& tzif) {};
//
//    //! Destructor.
//   ~TestZeroIn1() {};
//
//    //! Assignment Operator.
//    TestZeroIn1& operator=(const TestZeroIn1& tzif)
//    {return *this;};
//
//    //! \brief Function parentheses operator(). Returns a double given a
//    //! single double argument. This function is the function to be zeroed.
//    //! and for which a maximum (or minimum) will be found.
//    double    operator()(double x)
//    {
//      ++fccnt;
//      return 47 - (2.0 * x * x * x - 3.0 * x + 2.0);
//    };
//
//    //! Zeros the function call count.
//    void      resetFCCount() {fccnt = 0;};
//
//    //! Returns the function call count.
//    int       getFCCount() const {return fccnt;};
//
//  private:
//
//    //! \brief The integrand function call count. Used to examine the
//    //! number of times the operator()(double x) function is called.
//    int fccnt;
//};
 
//class TestMaxF2
//{
//  public:
//
//    //! Default Constructor.
//    TestMaxF2() {};
//
//    //! Copy Constructor.
//    TestMaxF2(const TestMaxF2& tmf) {};
//
//    //! Destructor.
//   ~TestMaxF2() {};
//
//    //! Assignment Operator.
//    TestMaxF2& operator=(const TestMaxF2& tmf)
//    {return *this;};
//
//    //! \brief Function parentheses operator(). Returns a double given a
//    //! single double argument. This function is the function for which
//    //! a maximum (or minimum) will be found. These exist at +-sqrt(2)/2.
//    double    operator()(double x)
//    {
//      ++fccnt;
//      return (2.0 * x * x * x - 3.0 * x + 2.0);
//    };
//
//    //! Zeros the function call count.
//    void      resetFCCount() {fccnt = 0;};
//
//    //! Returns the function call count.
//    int       getFCCount() const {return fccnt;};
//
//  private:
//
//    //! \brief The integrand function call count. Used to examine the
//    //! number of times the operator()(double x) function is called.
//    int fccnt;
//};
 
} // end namespace util
 
#endif // BRENTS_H