genmodel 0.0.20 → 0.0.21

data/ext/Genmodel/GenModelOsi.h

@@ -0,0 +1,96 @@
+/*
+ * GenModelOsi.h
+ *
+ *  Created on: 2012-10-01
+ *      Author: mbouchard
+ */
+
+#ifndef GENMODELOSI_H_
+#define GENMODELOSI_H_
+
+#if defined WIN64 || defined WIN32
+	#ifndef snprintf
+		#define snprintf sprintf_s
+	#endif
+#endif
+
+#include "GenModel.h"
+#include "OsiClpSolverInterface.hpp"
+//#include "OsiCpxSolverInterface.hpp"
+//#include "OsiSpxSolverInterface.hpp"
+//#include "OsiGrbSolverInterface.hpp"
+//#include "OsiGlpkSolverInterface.hpp"
+//#include "OsiVolSolverInterface.hpp"
+#include "CbcModel.hpp"
+//#include "CbcBranchUser.hpp"
+//#include "CbcCompareUser.hpp"
+#include "CbcCutGenerator.hpp"
+#include "CbcHeuristicLocal.hpp"
+#include "CbcHeuristicGreedy.hpp"
+#include "CglProbing.hpp"
+#include "CbcHeuristic.hpp"
+#include "GenModelOsiInterface.h"
+#include "CoinTime.hpp"
+#include "CglGomory.hpp"
+#include "CglProbing.hpp"
+#include "CglKnapsackCover.hpp"
+#include "CglOddHole.hpp"
+#include "CglClique.hpp"
+#include "CglFlowCover.hpp"
+#include "CglMixedIntegerRounding.hpp"
+
+using namespace std;
+
+class OsiData
+{
+public:
+	OsiData();
+	~OsiData();
+	long Reset();
+	long Delete();
+    
+	OsiSolverInterface* model;
+    CbcModel* mipmodel;
+    CoinBigIndex* mat_beg;
+	int* mat_r;
+	double* mat_v;
+	double* lrhs;
+	double* urhs;
+	double* ub;
+	double* lb;
+	int* typei;
+    int* typec;
+	double* obj;
+	char** cname;
+	char** rname;
+
+    int solvertype;
+	long nc;
+	long nr;
+	long nz;
+    long nq;
+    double mult;
+};
+
+class GenModelOsi : public GenModel
+{
+public:
+	~GenModelOsi() {if (solverdata != NULL) delete static_cast<OsiData*>(solverdata);}
+	long Init(string name);//, int type=0);
+	long CreateModel();
+    long CreateModel(string filename, int type=0, string dn="");
+	long AddSolverRow(vector<int>& ind, vector<double>& val, double rhs, char sense, string name);
+	long AddSolverCol(vector<int>& ind, vector<double>& val, double obj, double lb, double ub, string name, char type = 'C');
+	long AddCut(int* cols, double* vals, int nz, double rhs, char sense, const char* name);
+	long AddCol(int* newi, double* newcol, int nz, double obj, double lb, double ub, const char* name, char type = 'C');
+    long WriteProblemToLpFile(string filename);
+    long WriteSolutionToFile(string filename);
+	long Solve();
+	long SetSol();
+	long Clean();
+    long SetDirectParam(int whichparam, genmodel_param value, string type, string message);
+    long SetParam(string param, int whichparam, string type, string message, bool implemented = true);
+};
+
+
+#endif /* GENMODELOSI_H_ */

data/ext/Genmodel/GenModelOsiInterface.cpp

@@ -0,0 +1,143 @@
+#include <cassert>
+
+#include "CoinHelperFunctions.hpp"
+//#include "CoinIndexedVector.hpp"
+#include "ClpQuadraticObjective.hpp"
+#include "ClpLinearObjective.hpp"
+#include "ClpObjective.hpp"
+//#include "ClpSimplex.hpp"
+#include "GenModelOsiInterface.h"
+
+long GenModelOsiInterface::setQuadraticObjective(long nc, CoinBigIndex* Q_beg, int* Q_r, double* Q_v)
+{
+    double offset;
+    double csol[2];
+    csol[0] = 2.2;
+    csol[1] = 0.7;
+    
+    printf("Set Quadratic\n");
+    //ClpObjective * saveObjective  = modelPtr_->objectiveAsObject();
+    //modelPtr_->loadQuadraticObjective(nc, Q_beg, Q_r, Q_v);
+    
+    //double* gradz = modelPtr_->objective(csol, offset, true);
+    //for(int i = 0; i < nc; i++)
+    //    printf("gradz = %f (%d)\n", gradz[i], Q_beg[i]);
+    
+    if(quadraticObjective_ != NULL)
+       delete quadraticObjective_;
+
+    quadraticObjective_ = new ClpQuadraticObjective(modelPtr_->objective(),nc,Q_beg,Q_r,Q_v);
+    double* buf = modelPtr_->objective();
+    for(int i = 0; i < nc; i++)
+        printf("obj = %f\n", buf[i]);
+    
+    double* grad = ((ClpQuadraticObjective*)quadraticObjective_)->gradient(modelPtr_, csol, offset, true);
+    for(int i = 0; i < nc; i++)
+        printf("grad = %f\n", grad[i]);
+    
+    ClpLinearObjective * linearObjective = new ClpLinearObjective(NULL,nc);
+    modelPtr_->setObjectivePointer(linearObjective);
+    
+    return 0;
+}
+
+void GenModelOsiInterface::initialSolve()
+{
+    // save cutoff
+    double cutoff = modelPtr_->dualObjectiveLimit();
+    modelPtr_->setDualObjectiveLimit(1.0e50);
+    modelPtr_->scaling(0);
+    //modelPtr_->setLogLevel(0);
+    // solve with no objective to get feasible solution
+    setBasis(basis_,modelPtr_);
+    printf("before dual\n");
+    modelPtr_->dual();
+    printf("after dual\n");
+    basis_ = getBasis(modelPtr_);
+    modelPtr_->setDualObjectiveLimit(cutoff);
+    if (modelPtr_->problemStatus())
+    {
+        assert (modelPtr_->problemStatus()==1);
+        return;
+    }
+    ClpObjective * saveObjective  = modelPtr_->objectiveAsObject();
+    modelPtr_->setObjectivePointer(quadraticObjective_);
+    //modelPtr_->setLogLevel(1);
+    // Could load up any data into a solver
+    printf("before primal\n");
+    modelPtr_->primal();
+    printf("after primal\n");
+    modelPtr_->setDualObjectiveLimit(cutoff);
+    if (modelPtr_->objectiveValue()>cutoff)
+        modelPtr_->setProblemStatus(1);
+    // zero reduced costs
+    // Should not have to as convex
+    //CoinZeroN(modelPtr_->dualRowSolution(),modelPtr_->numberRows());
+    //CoinZeroN(modelPtr_->dualColumnSolution(),modelPtr_->numberColumns());
+    modelPtr_->setObjectivePointer(saveObjective);
+}
+
+void GenModelOsiInterface::resolve()
+{
+    initialSolve();
+}
+
+
+GenModelOsiInterface::GenModelOsiInterface () : OsiClpSolverInterface()
+{
+    quadraticObjective_ = NULL;
+}
+
+
+OsiSolverInterface* GenModelOsiInterface::clone(bool CopyData) const
+{
+    if (CopyData)
+        return new GenModelOsiInterface(*this);
+    else
+        throw string("warning GenModelOsiInterface clone with copyData false\n");
+}
+
+
+GenModelOsiInterface::GenModelOsiInterface (const GenModelOsiInterface & rhs) : OsiClpSolverInterface(rhs)
+{
+    if (rhs.quadraticObjective_)
+        quadraticObjective_=rhs.quadraticObjective_->clone();
+    else
+        quadraticObjective_=NULL;
+}
+
+GenModelOsiInterface::~GenModelOsiInterface()
+{
+    delete quadraticObjective_;
+}
+
+GenModelOsiInterface & GenModelOsiInterface::operator=(const GenModelOsiInterface& rhs)
+{
+    if (this != &rhs)
+    {
+        OsiClpSolverInterface::operator=(rhs);
+        if (rhs.quadraticObjective_)
+            quadraticObjective_=rhs.quadraticObjective_->clone();
+        else
+            quadraticObjective_=NULL;
+    }
+    return *this;
+}
+
+// Real initializer
+void GenModelOsiInterface::initialize ()
+{
+    printf("!!!! @@@@@@@@@ Initialize @@@@@@@@@ !!!!!!!\n");
+    // Save true objective and create a fake one
+    delete quadraticObjective_;
+    quadraticObjective_ = modelPtr_->objectiveAsObject();
+    ClpLinearObjective * linearObjective = new ClpLinearObjective(NULL,modelPtr_->numberColumns());
+    modelPtr_->setObjectivePointer(linearObjective);
+}
+
+// Get objective function value (can't use default)
+double GenModelOsiInterface::getObjValue() const
+{
+    // first try easy way
+    return modelPtr_->objectiveValue();
+}

data/ext/Genmodel/GenModelOsiInterface.h

@@ -0,0 +1,43 @@
+/***************************************************************************
+ *  GenModelOsiInterface.h
+ *  Replacememnt for the default OsiClpSolverInterface
+ *
+ *  February 14 9:32 2014
+ *  Copyright  2014  Mathieu Bouchard
+ *  mathbouchard@gmail.com
+ ****************************************************************************/
+
+#ifndef GENMODELOSIINTERFACE_H_
+#define GENMODELOSIINTERFACE_H_
+
+#include "OsiClpSolverInterface.hpp"
+#include <string>
+
+using namespace std;
+
+// This is to allow the user to replace initialSolve and resolve
+
+class GenModelOsiInterface : public OsiClpSolverInterface {
+
+public:
+    
+    GenModelOsiInterface ();
+    GenModelOsiInterface (const GenModelOsiInterface &);
+    virtual ~GenModelOsiInterface ();
+    virtual OsiSolverInterface * clone(bool CopyData=true) const;
+    GenModelOsiInterface & operator=(const GenModelOsiInterface& rhs);
+    
+    // Solve initial LP relaxation
+    virtual void initialSolve();
+    /// Resolve an LP relaxation after problem modification
+    virtual void resolve();
+    // Setup fake objective or somehow get nonlinear  info
+    void initialize();
+    virtual double getObjValue() const;
+    long setQuadraticObjective(long nc, CoinBigIndex* Q_beg, int* Q_r, double* Q_v);
+    
+private:
+    ClpObjective * quadraticObjective_;
+};
+
+#endif //GENMODELOSIINTERFACE_H_