extremefinder.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Kristofer Tingdahl
 Date:          4-11-2002
 RCS:           $Id$
________________________________________________________________________
 
 
-*/
 
#include "algomod.h"
#include "task.h"
#include "ranges.h"
#include "mathfunc.h"
 
 
mExpClass(Algo) ExtremeFinder1D : public SequentialTask
{
public:
                        ExtremeFinder1D( const FloatMathFunction& func,
                                         bool max, int itermax, float tol,
                                         const Interval<float>& startinterval,
                                         const Interval<float>* limitinterval);
    virtual             ~ExtremeFinder1D();
 
    void                reStart( const Interval<float>& startinterval,
                                 const Interval<float>* limitinterval);
    float               extremePos() const;
    float               extremeVal() const;
    int                 nrIter() const;
    int                 nextStep();
protected:
 
    float                       ax_,bx_,cx_;
    float                       e_, d_;
    float                       a_, b_;
    float                       u_, w_, v_, x_;
    float                       fw_, fv_, fx_;
 
    Interval<float>*            limits_;
    int                         iter_;
    const float                 tol_;
    const FloatMathFunction&    func_;
    const bool                  max_;
    const int                   itermax_;
};
 
 
mExpClass(Algo) BisectionExtremeFinder1D : public SequentialTask
{
public:
                        BisectionExtremeFinder1D(
                                        const FloatMathFunction&,
                                        bool max, int itermax, float tol,
                                        const Interval<float>& startinterval,
                                        const Interval<float>* limitinterval);
    virtual             ~BisectionExtremeFinder1D();
 
    void                reStart( const Interval<float>& startinterval,
                                 const Interval<float>* limitinterval);
    float               extremePos() const;
    float               extremeVal() const;
    int                 nrIter() const;
    int                 nextStep();
protected:
    Interval<float>*            limits_;
    int                         iter;
    const float                 tol;
    const bool                  max;
    const int                   itermax;
 
    Interval<float>             current;
    float                       startfuncval;
    float                       stopfuncval;
    float                       centerfuncval;
 
    bool                        isok;
    const FloatMathFunction&    func;
};
 
 
mExpClass(Algo) ExtremeFinderND : public SequentialTask
{
 
public:
 
                        ExtremeFinderND( const FloatMathFunctionND&,
                                         bool max, int itermax );
    virtual             ~ExtremeFinderND();
 
    template<class IDXABL>      
    void                setStartPos( const IDXABL& sp )
                        {
                            for ( int idx=0; idx<n_; idx++ )
                                p_[idx] = sp[idx];
                        }
 
    int                 nextStep();
                        /*<!\retval 0   Finished
                            \retval 1   More to do
                            \retval -1  Error (no extreme found or
                                        itermax reached The extreme value)
                        */
 
    int                 nrIter() const;
    float               extremeVal() const      { return fret_; }
    const float*        extremePos() const      { return p_; }
    template<class IDXABL>      
    void                extremePos( IDXABL& sp ) const
                        {
                            for ( int idx=0; idx<n_; idx++ )
                                sp[idx] = p_[idx];
                        }
private:
 
    float               linExtreme(float*);
 
    float*              p_;
    ObjectSet<float>    xi_;
    float               ftol_;
    int                 n_;
    int                 iter_;
    float               fret_;
 
    float*              pt_;
 
    const bool                  max_;
    const int                   itermax_;
    const FloatMathFunctionND&  func_;
};