multi_extrema.h

Go to the documentation of this file.

 
 
#ifndef THEORETICA_MULTI_EXTREMA_H
#define THEORETICA_MULTI_EXTREMA_H
 
#include "../core/constants.h"
#include "../autodiff/autodiff.h"
#include "./extrema.h"
 
#include <functional>
 
 
namespace theoretica {
 
 
    template <
        typename Vector = vec<real>,
        typename ReturnVector = Vector,
        typename DualObjectiveFunction,
        autodiff::enable_scalar_field<DualObjectiveFunction> = true
    >
    inline ReturnVector multi_minimize_grad(
        DualObjectiveFunction f,
        Vector guess,
        real gamma = OPTIMIZATION_MINGRAD_GAMMA,
        real tolerance = OPTIMIZATION_MINGRAD_TOLERANCE,
        unsigned int max_iter = OPTIMIZATION_MINGRAD_ITER
    ) {
 
        ReturnVector x = guess;
 
        if(gamma <= 0) {
            TH_MATH_ERROR("multi_minimize_grad", gamma, MathError::InvalidArgument);
            return algebra::vec_error(x);
        }
 
        ReturnVector grad;
        unsigned int iter = 0;
 
        do {
 
            grad = autodiff::gradient(f, x);
            x -= gamma * grad;
            iter++;
 
        } while(grad.norm() > tolerance && iter <= max_iter);
 
        if(iter > max_iter) {
            TH_MATH_ERROR("multi_minimize_grad", iter, MathError::NoConvergence);
            return algebra::vec_error(x);
        }
 
        return x;
    }
 
 
    template <
        typename Vector = vec<real>,
        typename ReturnVector = Vector,
        typename DualObjectiveFunction,
        autodiff::enable_scalar_field<DualObjectiveFunction> = true
    >
    inline ReturnVector multi_maximize_grad(
        DualObjectiveFunction f,
        Vector guess,
        real gamma = OPTIMIZATION_MINGRAD_GAMMA,
        real tolerance = OPTIMIZATION_MINGRAD_TOLERANCE,
        unsigned int max_iter = OPTIMIZATION_MINGRAD_ITER
    ) {
 
        using ArgType = typename _internal::func_helper<DualObjectiveFunction>::first_arg_type;
 
        return multi_minimize_grad(
            [f](ArgType x) { return -f(x); },
            guess, gamma,
            tolerance, max_iter
        );
    }
 
 
    template <
        typename Vector = vec<real>,
        typename ReturnVector = Vector,
        typename DualObjectiveFunction,
        autodiff::enable_scalar_field<DualObjectiveFunction> = true
    >
    inline ReturnVector multi_minimize_lingrad(
        DualObjectiveFunction f,
        Vector guess,
        real tolerance = OPTIMIZATION_MINGRAD_TOLERANCE,
        unsigned int max_iter = OPTIMIZATION_MINGRAD_ITER
    ) {
 
        ReturnVector x = guess;
        ReturnVector grad;
        unsigned int iter = 0;
 
        constexpr size_t N = ReturnVector::size_argument;
 
        do {
 
            grad = autodiff::gradient(f, x);
 
            // Minimize f(x + gamma * gradient) in [-1, 0]
            // using Golden Section extrema search
            real gamma = minimize_golden(
                [f, x, grad](real gamma){
                    return f(multidual<N>::make_argument(x + gamma * grad)).Re();
                }, -1, 0);
 
            // Fallback value
            if(-gamma <= MACH_EPSILON)
                gamma = OPTIMIZATION_MINGRAD_GAMMA;
 
            x += gamma * grad;
            iter++;
 
        } while(grad.norm() > tolerance && iter <= max_iter);
 
        if(iter > max_iter) {
            TH_MATH_ERROR("multi_minimize_lingrad", iter, MathError::NoConvergence);
            return algebra::vec_error(x);
        }
 
        return x;
    }
 
 
    template <
        typename Vector = vec<real>,
        typename ReturnVector = Vector,
        typename DualObjectiveFunction,
        autodiff::enable_scalar_field<DualObjectiveFunction> = true
    >
    inline ReturnVector multi_maximize_lingrad(
        DualObjectiveFunction f,
        Vector guess,
        real tolerance = OPTIMIZATION_MINGRAD_TOLERANCE,
        unsigned int max_iter = OPTIMIZATION_MINGRAD_ITER) {
 
        using ArgType = typename _internal::func_helper<DualObjectiveFunction>::first_arg_type;
 
        return multi_minimize_lingrad(
            [f](ArgType x) { return -f(x); },
            guess, tolerance, max_iter
        );
    }
 
 
    template <
        typename Vector = vec<real>,
        typename ReturnVector = Vector,
        typename DualObjectiveFunction,
        autodiff::enable_scalar_field<DualObjectiveFunction> = true
    >
    inline ReturnVector multi_minimize(
        DualObjectiveFunction f, Vector guess,
        real tolerance = OPTIMIZATION_MINGRAD_TOLERANCE
    ) {
        return multi_minimize_lingrad(f, guess, tolerance);
    }
 
 
    template <
        typename Vector = vec<real>,
        typename ReturnVector = Vector,
        typename DualObjectiveFunction,
        autodiff::enable_scalar_field<DualObjectiveFunction> = true
    >
    inline ReturnVector multi_maximize(
        DualObjectiveFunction f, Vector guess,
        real tolerance = OPTIMIZATION_MINGRAD_TOLERANCE
    ) {
        return multi_maximize_lingrad(f, guess, tolerance);
    }
 
}
 
 
#endif