extrema.h

Go to the documentation of this file.

 
 
#ifndef THEORETICA_EXTREMA_H
#define THEORETICA_EXTREMA_H
 
#include "../core/constants.h"
#include "./roots.h"
 
 
namespace theoretica {
 
 
    template<typename RealFunction>
    inline real maximize_goldensection(RealFunction f, real a, real b) {
 
        if(a > b) {
            TH_MATH_ERROR("maximize_goldensection", b, INVALID_ARGUMENT);
            return nan();
        }
 
        real x1 = a;
        real x2 = b;
        real x3 = b - (b - a) / PHI;
        real x4 = a + (b - a) / PHI;
 
        unsigned int iter = 0;
 
        while(abs(x2 - x1) > OPTIMIZATION_TOL && iter <= OPTIMIZATION_GOLDENSECTION_ITER) {
 
            if(f(x3) > f(x4)) {
                x2 = x4;
            } else {
                x1 = x3;
            }
 
            x3 = x2 - (x2 - x1) / PHI;
            x4 = x1 + (x2 - x1) / PHI;
 
            iter++;
        }
 
        if(iter > OPTIMIZATION_GOLDENSECTION_ITER) {
            TH_MATH_ERROR("maximize_goldensection", iter, NO_ALGO_CONVERGENCE);
            return nan();
        }
 
        return (x2 + x1) / 2.0;
    }
 
 
    template<typename RealFunction>
    inline real minimize_goldensection(RealFunction f, real a, real b) {
 
        if(a > b) {
            TH_MATH_ERROR("minimize_goldensection", b, INVALID_ARGUMENT);
            return nan();
        }
 
        real x1 = a;
        real x2 = b;
        real x3 = b - (b - a) / PHI;
        real x4 = a + (b - a) / PHI;
 
        unsigned int iter = 0;
 
        while(abs(x2 - x1) > OPTIMIZATION_TOL && iter <= OPTIMIZATION_GOLDENSECTION_ITER) {
 
            if(f(x3) < f(x4)) {
                x2 = x4;
            } else {
                x1 = x3;
            }
 
            x3 = x2 - (x2 - x1) / PHI;
            x4 = x1 + (x2 - x1) / PHI;
 
            iter++;
        }
 
        if(iter > OPTIMIZATION_GOLDENSECTION_ITER) {
            TH_MATH_ERROR("minimize_goldensection", iter, NO_ALGO_CONVERGENCE);
            return nan();
        }
 
        return (x2 + x1) / 2.0;
    }
 
 
    template<typename RealFunction>
    inline real maximize_newton(
        RealFunction f, RealFunction Df, RealFunction D2f,
        real guess = 0) {
 
        real z = root_newton(Df, D2f, guess);
 
        if(D2f(z) > 0) {
            TH_MATH_ERROR("maximize_newton", z, NO_ALGO_CONVERGENCE);
            return nan();
        }
 
        return z;
    }
 
 
    template<typename RealFunction>
    inline real minimize_newton(
        RealFunction f, RealFunction Df,
        RealFunction D2f, real guess = 0) {
 
        real z = root_newton(Df, D2f, guess);
 
        if(D2f(z) < 0) {
            TH_MATH_ERROR("minimize_newton", z, NO_ALGO_CONVERGENCE);
            return nan();
        }
 
        return z;
    }
 
 
    template<typename RealFunction>
    inline real maximize_bisection(
        RealFunction f, RealFunction Df,
        real a, real b) {
 
        real z = root_bisection(Df, a, b);
 
        if(deriv_central(Df, z) > 0) {
            TH_MATH_ERROR("maximize_bisection", z, NO_ALGO_CONVERGENCE);
            return nan();
        }
 
        return z;
    }
 
 
    template<typename RealFunction>
    inline real minimize_bisection(RealFunction f, RealFunction Df, real a, real b) {
 
        real z = root_bisection(Df, a, b);
 
        if(deriv_central(Df, z) < 0) {
            TH_MATH_ERROR("minimize_bisection", z, NO_ALGO_CONVERGENCE);
            return z;
        }
 
        return z;
    }
 
}
 
#endif