libnest2d::opt::NloptOptimizer Class Reference

#include <src/libnest2d/include/libnest2d/optimizers/nlopt/nlopt_boilerplate.hpp>

Inheritance diagram for libnest2d::opt::NloptOptimizer:

Collaboration diagram for libnest2d::opt::NloptOptimizer:

Classes
struct	BoundsFunc
struct	FunvalCopyFunc
struct	InitValFunc
struct	ResultCopyFunc

Public Member Functions
	NloptOptimizer (nlopt::algorithm alg, StopCriteria stopcr={})
Result< Args... >	optimize_min (Func &&objectfunction, Input< Args... > initvals, Bound< Args >... bounds)
	Optimize for minimum value of the provided objectfunction.
Result< Args... >	optimize_min (Func &&objectfunction, Input< Args... > initvals)
Result< Args... >	optimize_min (Func &&objectfunction)
Result< Args... >	optimize_max (Func &&objectfunction, Input< Args... > initvals, Bound< Args >... bounds)
	Same as optimize_min but optimizes for maximum function value.
Result< Args... >	optimize_max (Func &&objectfunction, Input< Args... > initvals)
Result< Args... >	optimize_max (Func &&objectfunction)

Protected Types
using	Base = Optimizer< NloptOptimizer >
enum	OptDir

Protected Member Functions
template<class Func , class... Args>
Result< Args... >	optimize (Func &&func, std::tuple< Args... > initvals, Bound< Args >... args)

Static Protected Member Functions
template<class Fn , class... Args>
static double	optfunc (const std::vector< double > &params, std::vector< double > &, void *data)

Protected Attributes
nlopt::opt	opt_
std::vector< double >	lower_bounds_
std::vector< double >	upper_bounds_
std::vector< double >	initvals_
nlopt::algorithm	alg_
Method	localmethod_
friend	Base
enum libnest2d::opt::Optimizer::OptDir	dir_
StopCriteria	stopcr_

Detailed Description

Optimizer based on NLopt.

All the optimized types have to be convertible to double.

Member Typedef Documentation

Base

using libnest2d::opt::NloptOptimizer::Base = Optimizer<NloptOptimizer>

protected

Member Enumeration Documentation

OptDir

enum libnest2d::opt::Optimizer::OptDir

strongprotectedinherited

                     {
        MIN,
        MAX
    } dir_;

Constructor & Destructor Documentation

NloptOptimizer()

libnest2d::opt::NloptOptimizer::NloptOptimizer ( nlopt::algorithm  alg, StopCriteria  stopcr = {}  )

inlineexplicit

                                                         {}):
        Base(stopcr), alg_(alg), localmethod_(Method::L_SIMPLEX) {}

Member Function Documentation

optfunc()

template<class Fn , class... Args>

static double libnest2d::opt::NloptOptimizer::optfunc ( const std::vector< double > &  params, std::vector< double > &  , void *  data  )

inlinestaticprotected

    {
        using TData = std::pair<remove_ref_t<Fn>*, NloptOptimizer*>;
        auto typeddata = static_cast<TData*>(data);
 
        if(typeddata->second->stopcr_.stop_condition())
            typeddata->second->opt_.force_stop();
 
        auto fnptr = typeddata->first;
        auto funval = std::tuple<Args...>();
 
        // copy the obtained objectfunction arguments to the funval tuple.
        metaloop::apply(FunvalCopyFunc(params), funval);
 
        auto ret = metaloop::callFunWithTuple(*fnptr, funval,
                                              index_sequence_for<Args...>());
 
        return ret;
    }

References libnest2d::opt::metaloop::apply(), libnest2d::opt::metaloop::callFunWithTuple(), and opt_.

Here is the call graph for this function:

optimize()

template<class Func , class... Args>

Result< Args... > libnest2d::opt::NloptOptimizer::optimize ( Func &&  func, std::tuple< Args... >  initvals, Bound< Args >...  args  )

inlineprotected

    {
        lower_bounds_.resize(sizeof...(Args));
        upper_bounds_.resize(sizeof...(Args));
        initvals_.resize(sizeof...(Args));
 
        opt_ = nlopt::opt(alg_, sizeof...(Args) );
 
        // Copy the bounds which is obtained as a parameter pack in args into
        // lower_bounds_ and upper_bounds_
        metaloop::apply(BoundsFunc(*this), args...);
 
        opt_.set_lower_bounds(lower_bounds_);
        opt_.set_upper_bounds(upper_bounds_);
 
        nlopt::opt localopt;
        switch(opt_.get_algorithm()) {
        case nlopt::GN_MLSL:
        case nlopt::GN_MLSL_LDS:
            localopt = nlopt::opt(method2nloptAlg(localmethod_),
                                  sizeof...(Args));
            localopt.set_lower_bounds(lower_bounds_);
            localopt.set_upper_bounds(upper_bounds_);
            opt_.set_local_optimizer(localopt);
        default: ;
        }
 
        double abs_diff = stopcr_.absolute_score_difference;
        double rel_diff = stopcr_.relative_score_difference;
        double stopval = stopcr_.stop_score;
        if(!std::isnan(abs_diff)) opt_.set_ftol_abs(abs_diff);
        if(!std::isnan(rel_diff)) opt_.set_ftol_rel(rel_diff);
        if(!std::isnan(stopval))  opt_.set_stopval(stopval);
 
        if(this->stopcr_.max_iterations > 0)
            opt_.set_maxeval(this->stopcr_.max_iterations );
 
        // Take care of the initial values, copy them to initvals_
        metaloop::apply(InitValFunc(*this), initvals);
 
        std::pair<remove_ref_t<Func>*, NloptOptimizer*> data =
                std::make_pair(&func, this);
 
        switch(dir_) {
        case OptDir::MIN:
            opt_.set_min_objective(optfunc<Func, Args...>, &data); break;
        case OptDir::MAX:
            opt_.set_max_objective(optfunc<Func, Args...>, &data); break;
        }
 
        Result<Args...> result;
        nlopt::result rescode;
 
        try {
            rescode = opt_.optimize(initvals_, result.score);
            result.resultcode = static_cast<ResultCodes>(rescode);
        } catch( nlopt::forced_stop& ) {
            result.resultcode = ResultCodes::FORCED_STOP;
        }
 
        metaloop::apply(ResultCopyFunc(*this), result.optimum);
 
        return result;
    }

References libnest2d::opt::StopCriteria::absolute_score_difference, alg_, libnest2d::opt::metaloop::apply(), libnest2d::opt::Optimizer< NloptOptimizer >::dir_, libnest2d::opt::FORCED_STOP, libnest2d::opt::initvals(), initvals_, localmethod_, lower_bounds_, libnest2d::opt::StopCriteria::max_iterations, libnest2d::opt::method2nloptAlg(), opt_, libnest2d::opt::StopCriteria::relative_score_difference, libnest2d::opt::StopCriteria::stop_score, libnest2d::opt::Optimizer< NloptOptimizer >::stopcr_, and upper_bounds_.

Here is the call graph for this function:

optimize_max() [1/3]

Result< Args... > libnest2d::opt::Optimizer< NloptOptimizer >::optimize_max ( Func &&  objectfunction )

inlineinherited

    {
        dir_ = OptDir::MAX;
        return static_cast<Subclass*>(this)->template optimize<Func, Args...>(
                    forward<Func>(objectfunction),
                    Input<Args...>(),
                    Bound<Args>()... );
    }

optimize_max() [2/3]

Result< Args... > libnest2d::opt::Optimizer< NloptOptimizer >::optimize_max ( Func &&  objectfunction, Input< Args... >  initvals  )

inlineinherited

    {
        dir_ = OptDir::MAX;
        return static_cast<Subclass*>(this)->template optimize<Func, Args...>(
                    forward<Func>(objectfunction), initvals, Bound<Args>()... );
    }

optimize_max() [3/3]

Result< Args... > libnest2d::opt::Optimizer< NloptOptimizer >::optimize_max ( Func &&  objectfunction, Input< Args... >  initvals, Bound< Args >...  bounds  )

inlineinherited

Same as optimize_min but optimizes for maximum function value.

    {
        dir_ = OptDir::MAX;
        return static_cast<Subclass*>(this)->template optimize<Func, Args...>(
                    forward<Func>(objectfunction), initvals, bounds... );
    }

optimize_min() [1/3]

Result< Args... > libnest2d::opt::Optimizer< NloptOptimizer >::optimize_min ( Func &&  objectfunction )

inlineinherited

    {
        dir_ = OptDir::MIN;
        return static_cast<Subclass*>(this)->template optimize<Func, Args...>(
                    forward<Func>(objectfunction),
                    Input<Args...>(),
                    Bound<Args>()... );
    }

optimize_min() [2/3]

Result< Args... > libnest2d::opt::Optimizer< NloptOptimizer >::optimize_min ( Func &&  objectfunction, Input< Args... >  initvals  )

inlineinherited

    {
        dir_ = OptDir::MIN;
        return static_cast<Subclass*>(this)->template optimize<Func, Args...>(
                    forward<Func>(objectfunction), initvals, Bound<Args>()... );
    }

optimize_min() [3/3]

Result< Args... > libnest2d::opt::Optimizer< NloptOptimizer >::optimize_min ( Func &&  objectfunction, Input< Args... >  initvals, Bound< Args >...  bounds  )

inlineinherited

Optimize for minimum value of the provided objectfunction.

Parameters

objectfunction	The function that will be searched for the minimum return value.
initvals	A tuple with the initial values for the search
bounds	A parameter pack with the bounds for each dimension.

Returns

Returns a Result<Args...> structure. An example call would be: auto result = opt.optimize_min( [](tuple<double> x) // object function { return std::pow(std::get<0>(x), 2); }, make_tuple(-0.5), // initial value {-1.0, 1.0} // search space bounds );

    {
        dir_ = OptDir::MIN;
        return static_cast<Subclass*>(this)->template optimize<Func, Args...>(
                    forward<Func>(objectfunction), initvals, bounds... );
    }

Member Data Documentation

alg_

nlopt::algorithm libnest2d::opt::NloptOptimizer::alg_

protected

Referenced by optimize().

Base

friend libnest2d::opt::NloptOptimizer::Base

protected

dir_

enum libnest2d::opt::Optimizer::OptDir libnest2d::opt::Optimizer< NloptOptimizer >::dir_

protectedinherited

initvals_

std::vector<double> libnest2d::opt::NloptOptimizer::initvals_

protected

Referenced by libnest2d::opt::NloptOptimizer::InitValFunc::operator()(), libnest2d::opt::NloptOptimizer::ResultCopyFunc::operator()(), and optimize().

localmethod_

Method libnest2d::opt::NloptOptimizer::localmethod_

protected

Referenced by libnest2d::opt::GeneticOptimizer::localMethod(), and optimize().

lower_bounds_

std::vector<double> libnest2d::opt::NloptOptimizer::lower_bounds_

protected

Referenced by libnest2d::opt::NloptOptimizer::BoundsFunc::operator()(), and optimize().

opt_

nlopt::opt libnest2d::opt::NloptOptimizer::opt_

protected

Referenced by optfunc(), and optimize().

stopcr_

StopCriteria libnest2d::opt::Optimizer< NloptOptimizer >::stopcr_

protectedinherited

upper_bounds_

std::vector<double> libnest2d::opt::NloptOptimizer::upper_bounds_

protected

Referenced by libnest2d::opt::NloptOptimizer::BoundsFunc::operator()(), and optimize().

---

The documentation for this class was generated from the following file:

• src/libnest2d/include/libnest2d/optimizers/nlopt/nlopt_boilerplate.hpp