drwnLPSolver.h

/******************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2015, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnLPSolver.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <vector>

#include "Eigen/Core"
#include "Eigen/SparseCore"

#include "drwnBase.h"

using namespace std;
using namespace Eigen;

// drwnLPSolver ------------------------------------------------------------

class drwnLPSolver {
 public:
    // barrier method parameters
    static double t0;         
    static double mu;         
    static double eps;        
    static unsigned maxiters; 
    // line search parameters
    static double alpha;      
    static double beta;       

 protected:
    // objective
    VectorXd _c;              

    // constraints and bounds
    MatrixXd _A;              
    VectorXd _b;              

    VectorXd _lb;             
    VectorXd _ub;             

    VectorXd _x;              

 public:
    drwnLPSolver(const VectorXd& c, const MatrixXd& A, const VectorXd& b);
    drwnLPSolver(const VectorXd& c, const MatrixXd& A, const VectorXd& b,
        const VectorXd& lb, const VectorXd& ub);
    ~drwnLPSolver() { /* do nothing */ }

    void initialize(const VectorXd& x);

    double solve();

    inline const VectorXd& solution() const { return _x; }

    // accessors
    inline int size() const { return _c.rows(); }    
    inline double operator[](unsigned i) const { return _x[i]; }

 protected:
    bool isUnbounded(unsigned i) const { return ((_lb[i] == -DRWN_DBL_MAX) && (_ub[i] == DRWN_DBL_MAX)); }
    bool isWithinBounds(const VectorXd& x) const { return (x.array() > _lb.array()).all() && (x.array() < _ub.array()).all(); }

    double barrierFunction(const VectorXd& x) const;
};

// drwnSparseLPSolver ------------------------------------------------------

class drwnSparseLPSolver {
 protected:
    // objective
    VectorXd _c;              

    // constraints and bounds
    const SparseMatrix<double>& _A;  
    VectorXd _b;              

    VectorXd _lb;             
    VectorXd _ub;             

    VectorXd _x;              

 public:
    drwnSparseLPSolver(const VectorXd& c, const SparseMatrix<double>& A, const VectorXd& b);
    drwnSparseLPSolver(const VectorXd& c, const SparseMatrix<double>& A, const VectorXd& b,
        const VectorXd& lb, const VectorXd& ub);
    ~drwnSparseLPSolver() { /* do nothing */ }

    void initialize(const VectorXd& x);

    double solve();

    inline const VectorXd& solution() const { return _x; }

    // accessors
    inline int size() const { return _c.rows(); }    
    inline double operator[](unsigned i) const { return _x[i]; }

 protected:
    bool isUnbounded(unsigned i) const { return ((_lb[i] == -DRWN_DBL_MAX) && (_ub[i] == DRWN_DBL_MAX)); }
    bool isWithinBounds(const VectorXd& x) const { return (x.array() > _lb.array()).all() && (x.array() < _ub.array()).all(); }

    double barrierFunction(const VectorXd& x) const;
};