BCP_lp_result.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef _BCP_LP_RESULT_H
#define _BCP_LP_RESULT_H

// This file is fully docified.

#include <cfloat>
#include <string>

#include "BCP_math.hpp"
#include "BCP_error.hpp"
#include "BCP_vector.hpp"
#include "OsiSolverInterface.hpp"

enum BCP_termcode {
  BCP_Abandoned           = 0x01,
  BCP_ProvenOptimal       = 0x02,
  BCP_ProvenPrimalInf     = 0x04,
  BCP_ProvenDualInf       = 0x08,
  BCP_PrimalObjLimReached = 0x10,
  BCP_DualObjLimReached   = 0x20,
  BCP_IterationLimit      = 0x40,
  BCP_TimeLimit           = 0x80
};

class BCP_lp_result {
private:
    BCP_lp_result(const BCP_lp_result&);
    BCP_lp_result& operator=(const BCP_lp_result&);
private:
    std::string _solvername;
    double _lower_bound;
    double _primal_tolerance;
    double _dual_tolerance;
    int _termcode;
    int     _iternum;
    double  _objval;
    double* _x;
    double* _pi;
    double* _dj;
    double* _lhs;
public:
    BCP_lp_result() :
      _solvername(),
      _lower_bound(-BCP_DBL_MAX), _primal_tolerance(0), _dual_tolerance(0),
      _termcode(BCP_ProvenOptimal), _iternum(0), _objval(0),
      _x(0), _pi(0), _dj(0), _lhs(0)
    {}
    ~BCP_lp_result() {
      delete[] _x;
      delete[] _pi;
      delete[] _dj;
      delete[] _lhs;
    }
  //--------------------------------------------------------------------------
    const std::string& solvername() const { return _solvername; }
  //    int&          termcode()       { return _termcode; }
    int           termcode() const { return _termcode; }
  //    int&          iternum()        { return _iternum; }
    int           iternum()  const { return _iternum; }
  //    double&       objval()         { return _objval; }
    double        objval()   const { return _objval; }
  //    double* x()                    { return _x; }
    const double* x()        const { return _x; }
  //    double* pi()                   { return _pi; }
    const double* pi()       const { return _pi; }
  //    double* dj()                   { return _dj; }
    const double* dj()       const { return _dj; }
  //    double* lhs()                  { return _lhs; }
    const double* lhs()      const { return _lhs; }
    double primalTolerance() const { return _primal_tolerance; }
    double dualTolerance()   const { return _dual_tolerance; }
    void get_results(OsiSolverInterface& lp_solver);
    void fake_objective_value(const double val) {
      _objval = val;
    }
};

#endif