LinearProgram.hh

Go to the documentation of this file.

/*
 *  Copyright 2007 Martin von Gagern
 *
 *
 *  This file is part of bande.
 *
 *  bande is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  bande is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


/**
 * @file
 * Interface of class bande::LinearProgram.
 */

namespace bande {

  /**
   * Encapsulation of a linear program.
   *
   * In the current implementation, this class encapsulates an LP
   * solver through the OsiSolverInterface. It extends that interface
   * by methods to access the row and column names and by registering
   * modifications with an UndoManager.
   */
  class LinearProgram {

  public:
    LinearProgram();
    virtual ~LinearProgram();

    void readMps(const char* fileName);
    void randomizeObjective();
    void setColLower(UndoManager& um, int col, double val);
    void setColUpper(UndoManager& um, int col, double val);
    bool solve();
    void dumpSolution(std::ostream& out = std::cerr) const;

    /**
     * Get the number of rows.
     * Each row represents zero to two inequalities, depending on the
     * row bounds.
     * @return the number of rows in the problem.
     */
    int getNumRows() const { return rows; }

    /**
     * Get the number of columns.
     * Each column corresponds to one variable of the solution.
     * @return the number of columns in the problem.
     */
    int getNumCols() const { return cols; }

    /**
     * Get one variable of the solution.
     * @param index the index of the variable.
     * @return the value of that variable in the current solution.
     */
    double getColSolution(int index) const { return solution[index]; }

    /**
     * Get the current lower bound of a column.
     * @param col the index of the column.
     * @return the current lower bound of that column.
     */
    double getColLower(int col) const { return solver->getColLower()[col]; }

    /**
     * Get the current upper bound of a column.
     * @param col the index of the column.
     * @return the current upper bound of that column.
     */
    double getColUpper(int col) const { return solver->getColUpper()[col]; }

    /**
     * Get the current lower bound of a row.
     * @param row the intex of the row.
     * @return the current lower bound of that row.
     */
    double getRowLower(int row) const { return solver->getRowLower()[row]; }

    /**
     * Get the current upper bound of a row.
     * @param row the index of the row.
     * @return the current upper bound of that row.
     */
    double getRowUpper(int row) const { return solver->getRowUpper()[row]; }

    /**
     * Get the name of a column.
     * This is also the name of the associated variable.
     * @param col the index of the column.
     * @return the name of that column.
     */
    std::string getColName(int col) const { return colNames[col]; }

    /**
     * Get the name of a row.
     * @param row the index of the row.
     * @return the name of that row.
     */
    std::string getRowName(int row) const { return rowNames[row]; }

    /**
     * Access to the wrapped solver interface.
     *
     * It is suggested that the returned object be used for read-only
     * access, although this is not strictly required, as many methods
     * of this wrapper simply call corresponding methods of the
     * wrapped interface and thus will reflect changes. Notable
     * Exceptions to this rules are the size of the matrix or the
     * vector of solutions.
     *
     * The returned pointer is the one used by this class, so it must
     * not be deleted by the caller of this method.
     *
     * @return a pointer to the solver interface wrapped by
     *         this object.
     */
    OsiSolverInterface* getSolver() { return solver; }

  protected:

    /**
     * The wrapped solver interface.
     */
    OsiSolverInterface* solver;

    /**
     * Number of rows.
     */
    int rows;

    /**
     * Number of columns.
     */
    int cols;

    /**
     * Column names.
     */
    std::vector<std::string> colNames;

    /**
     * Row names.
     */
    std::vector<std::string> rowNames;

    /**
     * Flag indicating a valid solution.
     */
    bool hasSolution;

    /**
     * Solution values.
     */
    const double *solution;
  };


  /**
   * Undo information for a column bound change.
   * This template is parametrized by a pointer to a method of
   * OsiSolverInterface that will accept a column index and a double
   * value. When instantiating this template, this parameter should be
   * the function to be used to undo the associated modification.
   *
   * @param f a pointer to member to the function used to undo the
   *          change associated with this object.
   */
  template<void (OsiSolverInterface::*f)(int, double)>
  class UndoColAction : public UndoBase {
  public:

    /**
     * Constructs an undo information set.
     * @param solver the solver object that will be modified.
     * @param col the column index of the column to be modified.
     * @param val the old value of the property, to be restired when
     *            undoing the modification.
     */
    UndoColAction(OsiSolverInterface* solver, int col, double val)
      : solver(solver), col(col), val(val) { }

    /**
     * Undo the operation as recorded.
     * This calls the method @e f on @e solver with the arguments
     * @e col and @e val, as they were supplied to the constructor.
     */
    void undo() { (solver->*f)(col, val); }

  protected:

    /**
     * The solver object that was be modified.
     */
    OsiSolverInterface* solver;

    /**
     * The index of the column that was modified.
     */
    int col;

    /**
     * The old value that shall be restored.
     */
    double val;

  };

}

---