opt.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2014 Micah C Chambers (micahc.vt@gmail.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * @file opt.h Contains base class for all optimizers, defines Function types,
 * and StopReason
 * 
 *****************************************************************************/

#ifndef OPT_H
#define OPT_H

#include <functional>
#include <Eigen/Dense>

namespace npl
{

using std::function;
using Eigen::MatrixXd;
using Eigen::VectorXd;

typedef function<int(const VectorXd& x, double& v, VectorXd& g)> ValGradFunc;

typedef function<int(const VectorXd& x, VectorXd& g)> GradFunc;

typedef function<int(const VectorXd& x, double& v)> ValFunc;

typedef function<int(const VectorXd& x, double v, const VectorXd& g, size_t iter)> CallBackFunc;

int testgrad(double& error, const VectorXd& x, double stepsize, double tol,
        const ValFunc& valfunc, const ValGradFunc& valgradfunc);

int testgrad(double& error, const VectorXd& x, double stepsize, double tol, 
        const ValFunc& valfunc, const GradFunc& gradfunc);

int gRosenbrock_G(const VectorXd& x, VectorXd& gradient);

int gRosenbrock_V(const VectorXd& x, double& v);

void gRosenbrock_callCounts(size_t& vcalls, size_t& gcalls);

inline
int noopCallback(const VectorXd& x, double value, const VectorXd& grad, size_t iter)
{
    (void)(x);
    (void)(value);
    (void)(grad);
    (void)(iter);
    return 0;
}

enum StopReason
{
    ENDGRAD,    // end due to gradient below threshold
    ENDSTEP,    // end due to step size below threshold
    ENDVALUE,   // end due to change in value below threshold
    ENDABSVALUE, // end due to surpassing value threshold
    ENDITERS,   // end due to number iterations
    ENDFAIL     // end tue to some error
};

using std::max;
using std::abs;


class Optimizer
{
    
public:
    VectorXd state_x;
    
    double stop_G;

    double stop_X;

    double stop_F;

    double stop_F_over;
    
    double stop_F_under;

    int stop_Its;
    
    Optimizer(size_t dim, const ValFunc& valfunc, const GradFunc& gradfunc, 
                const ValGradFunc& valgradfunc, 
                const CallBackFunc& callback = noopCallback);
    
    Optimizer(size_t dim, const ValFunc& valfunc, const GradFunc& gradfunc, 
                const CallBackFunc& callback = noopCallback);
    
    virtual 
    StopReason optimize() { return ENDFAIL; };

    static std::string explainStop(StopReason r);
protected:

    ValGradFunc m_compFG;
    GradFunc m_compG;
    ValFunc m_compF;
    CallBackFunc m_callback;
};

} // npl

#endif //OPT_H