Doxygen/OS/_o_s_dip_interface_8cpp_source.html

 /* $Id: OSDipInterface.cpp 3038 2009-11-07 11:43:44Z Gassmann $ */

 //===========================================================================//


 #include "OSDipInterface.h"

 #include "UtilMacrosDecomp.h"


 //===========================================================================//

 void OS_DipInterface::readOSiL(std::string & fileName) {


         FileUtil *fileUtil = NULL;

         fileUtil = new FileUtil();


         try {


                 std::string osil;

                 osil = fileUtil->getFileAsString(fileName.c_str());

                 m_osilreader = new OSiLReader();

                 m_osinstance = m_osilreader->readOSiL(osil);


                 bool columnMajor = false;

                 double maxGap = 0;


                 m_coinpm

                                 = new CoinPackedMatrix(

                                                 columnMajor, //Column or Row Major

                                                 columnMajor ? m_osinstance->getConstraintNumber()

                                                                 : m_osinstance->getVariableNumber(), //Minor Dimension

                                                 columnMajor ? m_osinstance->getVariableNumber()

                                                                 : m_osinstance->getConstraintNumber(), //Major Dimension

                                                 m_osinstance->getLinearConstraintCoefficientNumber(), //Number of nonzeroes

                                                 columnMajor ? m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->values

                                                                 : m_osinstance->getLinearConstraintCoefficientsInRowMajor()->values, //Pointer to matrix nonzeroes

                                                 columnMajor ? m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->indexes

                                                                 : m_osinstance->getLinearConstraintCoefficientsInRowMajor()->indexes, //Pointer to start of minor dimension indexes -- change to allow for row storage

                                                 columnMajor ? m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts

                                                                 : m_osinstance->getLinearConstraintCoefficientsInRowMajor()->starts, //Pointers to start of columns.

                                                 0, 0, maxGap);


                 delete fileUtil;

                 fileUtil = NULL;

                 //kipp  -- worry about garbage collection here -- do I delete m_osinstance

                 //delete  osilreader;

                 //osilreader = NULL;


         } catch (const ErrorClass& eclass) {

                 std::cout << "PROBLEM READING OSiL File" << std::endl;

                 delete fileUtil;

                 std::cout << eclass.errormsg << std::endl;

                 fileUtil = NULL;

                 throw ErrorClass(eclass.errormsg);


         }


 }//end readOSiL


 //===========================================================================//

 void OS_DipInterface::readOSoL(std::string & fileName) {


         FileUtil *fileUtil = NULL;

         fileUtil = new FileUtil();

         try {


                 std::string osol;

                 osol = fileUtil->getFileAsString(fileName.c_str());

                 m_osolreader = new OSoLReader();

                 m_osoption = m_osolreader->readOSoL(osol);


                 delete fileUtil;

                 fileUtil = NULL;

                 //kipp  -- worry about garbage collection here -- do I delete m_osinstance

                 //delete  osilreader;

                 //osilreader = NULL;


         } catch (const ErrorClass& eclass) {

                 std::cout << "Problem reading OSoL File" << std::endl;

                 delete fileUtil;

                 std::cout << eclass.errormsg << std::endl;

                 fileUtil = NULL;

                 throw ErrorClass(eclass.errormsg);


         }


 }// end readOSoL


 CoinPackedMatrix * OS_DipInterface::getCoinPackedMatrix() {


         return m_coinpm;

 }//end getCoinPackedMatrix


 CoinPackedVector * OS_DipInterface::getRow(int i) {


         m_row = new CoinPackedVector();


         int k;


         SparseMatrix* sm;


         sm = m_osinstance->getLinearConstraintCoefficientsInRowMajor();


         for (k = sm->starts[i]; k < sm->starts[i + 1]; k++) {


                 m_row->insert(sm->indexes[k], sm->values[k]);


         }


         return m_row;

 }//end getRow


 const char* OS_DipInterface::getIntegerColumns() {


         int numVars = getVariableNumber();

         m_integerVars = new char[numVars];

         int i;


         for (i = 0; i < numVars; i++) {


                 if (m_osinstance->getVariableTypes()[i] == 'B'

                                 || m_osinstance->getVariableTypes()[i] == 'I')

                         m_integerVars[i] = '1';

                 else

                         m_integerVars[i] = '0';


         }

         return m_integerVars;


 }// end getIntegerColumns


 double OS_DipInterface::getObjectiveOffset() {


         double offset = 0;

         //assume only one objective function for now


         if (getObjectiveConstants() != NULL) {

                 offset = getObjectiveConstants()[0];

         }


         return offset;

 }// end getObjectiveOffset


 std::vector<std::string> OS_DipInterface::getBlockFactories() {


         //get the factory solver for each block in the model


         if (m_blockFactoriesProcessed == true)

                 return m_blockFactories;


         try {

                 if (m_osoption == NULL)

                         throw ErrorClass("we have a null osoption");


                 std::vector<OtherVariableOption*> otherVariableOptions;

                 std::vector<OtherVariableOption*>::iterator vit;


                 if (m_osoption != NULL && m_osoption->getNumberOfOtherVariableOptions()

                                 > 0) {


                         otherVariableOptions = m_osoption->getOtherVariableOptions("Dip");

                         //iterate over the vector of variable options

                         for (vit = otherVariableOptions.begin(); vit

                                         != otherVariableOptions.end(); vit++) {


                                 // right now we assume blocks are ordered  -- we ignor value

                                 if ((*vit)->name.compare("variableBlockSet") == 0) {


                                         if ((*vit)->value.size() > 0) {


                                                 m_blockFactories.push_back((*vit)->value);


                                         } else {


                                                 m_blockFactories.push_back("");

                                         }


                                 }


                         }

                 }


         }//end try


         catch (const ErrorClass& eclass) {


                 std::cout << eclass.errormsg << std::endl;

                 throw ErrorClass(eclass.errormsg);


         }

         m_blockFactoriesProcessed = true;

         return m_blockFactories;

 }//end getBlockVarIndexes


 std::vector<std::set<int> > OS_DipInterface::getBlockVarIndexes() {


         //get the variable indexes for each block in the model

         std::set<int> varSet; //variables indexes in a specific block

         if (m_blockVariableIndexesProcessed == true)

                 return m_blockVariableIndexes;


         try {

                 if (m_osoption == NULL)

                         throw ErrorClass("we have a null osoption");


                 int numVar;

                 int i;

                 std::vector<OtherVariableOption*> otherVariableOptions;

                 std::vector<OtherVariableOption*>::iterator vit;


                 if (m_osoption != NULL && m_osoption->getNumberOfOtherVariableOptions()

                                 > 0) {


                         otherVariableOptions = m_osoption->getOtherVariableOptions("Dip");

                         //iterate over the vector of variable options

                         for (vit = otherVariableOptions.begin(); vit

                                         != otherVariableOptions.end(); vit++) {


                                 // right now we assume blocks are ordered  -- we ignor value

                                 if ((*vit)->name.compare("variableBlockSet") == 0) {


                                         // see if we have a set of block variables

                                         // if so we insert into our vector of sets

                                         varSet.clear();


                                         numVar = (*vit)->numberOfVar;


                                         for (i = 0; i < numVar; i++) {


                                                 if ((*vit)->var[i]->idx

                                                                 >= m_osinstance->getVariableNumber())

                                                         throw ErrorClass(

                                                                         "found an invalid varaible index in OSoL file");


                                                 varSet.insert((*vit)->var[i]->idx);


                                         }//end for on variables in this block


                                         m_blockVariableIndexes.push_back(varSet);

                                 }// end of if


                         }//end for over constraint options

                 }// if on ospton null


                 if (m_blockVariableIndexes.size() <= 0)

                         throw ErrorClass("someting wrong -- no variables in the blocks");


         } //end try


         catch (const ErrorClass& eclass) {


                 std::cout << eclass.errormsg << std::endl;

                 throw ErrorClass(eclass.errormsg);


         }

         m_blockVariableIndexesProcessed = true;

         return m_blockVariableIndexes;

 }//end getBlockVarIndexes


 std::vector<std::map<int, int> > OS_DipInterface::getBlockConstraintIndexes() {


         if (m_blockConstraintIndexesProcessed == true)

                 return m_blockConstraintIndexes;

         //get the variable indexes for each block in the model

         std::map<int, int> conMap; //constraint indexes in a specific block

         std::set<int> varSet; //constraint indexes in a specific block

         std::set<int> coreConstraintIndexes;

         std::vector<std::set<int> > blockVariableIndexes;


         int *starts = NULL;

         int *indexes = NULL;

         int kount;


         try {


                 // first get the block variable indexes, these are necessary

                 blockVariableIndexes = getBlockVarIndexes();

                 // get the core constraint indexes

                 coreConstraintIndexes = getCoreConstraintIndexes();


                 if (blockVariableIndexes.size() <= 0)

                         throw ErrorClass("someting wrong -- no variables in the blocks");


                 std::vector<std::set<int> >::iterator vit;

                 std::set<int>::iterator sit;

                 int i;


                 for (vit = blockVariableIndexes.begin(); vit

                                 != blockVariableIndexes.end(); vit++) {


                         varSet.clear();

                         conMap.clear();


                         varSet = *vit;

                         //now get the nonzeros for the variables in

                         //varSet and see which nonzeros are in non-core

                         //constraints

                         kount = 0;

                         for (sit = varSet.begin(); sit != varSet.end(); sit++) {


                                 starts

                                                 = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts;

                                 indexes

                                                 = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->indexes;


                                 for (i = starts[*sit]; i < starts[*sit + 1]; i++) {


                                         //add the row index if not in a core constraint

                                         //don't count same index twice

                                         if (coreConstraintIndexes.find(indexes[i])

                                                         == coreConstraintIndexes.end() &&

                                                         (conMap.find(indexes[i] ) == conMap.end()  )

                                         ) {

                                                 //we have a new constraint index


                                                 conMap.insert(std::make_pair(indexes[i], kount));

                                                 kount++;

                                         }

                                 }

                         }


                         m_blockConstraintIndexes.push_back(conMap);


                 }//end for iterator


         } //end try


         catch (const ErrorClass& eclass) {


                 std::cout << eclass.errormsg << std::endl;

                 throw ErrorClass(eclass.errormsg);


         }

         m_blockConstraintIndexesProcessed = true;

         return m_blockConstraintIndexes;

 }//end getBlockConstraintIndexes


 std::vector<OSInstance*> OS_DipInterface::getBlockOSInstances() {

         //get the OSInstance for each block

         if (m_blockOSInstancesProcessed == true)

                 return m_blockOSInstances;


         std::map<int, int> conMap; //constraint indexes in a specific block

         std::set<int> varSet; //constraint indexes in a specific block

         std::vector<std::map<int, int> > blockConstraintIndexes;

         std::set<int> coreConstraintIndexes;

         std::vector<std::set<int> > blockVariableIndexes;


         int *starts = NULL;

         int *indexes = NULL;

         double *values = NULL;


         OSInstance *osinstance;

         std::vector<std::set<int> >::iterator vit;

         std::set<int>::iterator sit;

         std::map<int, int>::iterator mit;

         int i;

         int kount;


         int whichBlock;

         int numNonz;

         int k1, k2;


         //variable stuff

         int numberVar;

         std::string* varNames = NULL;

         char* varTypes = NULL;

         double* varLowerBounds = NULL;

         double* varUpperBounds = NULL;


         //constraint stuff

         int numberCon;

         std::string* conNames = NULL;

         double* conLowerBounds = NULL;

         double* conUpperBounds = NULL;

         double* conConstants = NULL;


         int idx;


         try {


                 // first get the block variable indexes, these are necessary

                 blockVariableIndexes = getBlockVarIndexes();

                 // get the core constraint indexes


                 coreConstraintIndexes = getCoreConstraintIndexes();

                 // get the block constraint indexes


                 blockConstraintIndexes = getBlockConstraintIndexes();


                 if (blockVariableIndexes.size() <= 0)

                         throw ErrorClass(

                                         "someting wrong in getBlockOSInstances() -- no variables in the blocks");


                 //

                 //loop over each block

                 //

                 whichBlock = 0;

                 for (vit = blockVariableIndexes.begin(); vit

                                 != blockVariableIndexes.end(); vit++) {


                         varSet.clear();

                         conMap.clear();

                         varSet = *vit;


                         osinstance = new OSInstance();

                         //define variable arrays

                         numberVar = varSet.size();

                         varTypes = new char[numberVar];

                         varNames = new std::string[numberVar];

                         varLowerBounds = new double[numberVar];

                         varUpperBounds = new double[numberVar];


                         //now get the nonzeros for the variables in

                         //varSet and see which nonzeros are in non-core

                         //constraints

                         kount = 0;


                         osinstance->setVariableNumber(numberVar);


                         SparseVector *objcoeff;

                         objcoeff = new SparseVector(numberVar);


                         //need to count the number  of nonzero elements

                         //in the block constraints

                         numNonz = 0;


                         for (sit = varSet.begin(); sit != varSet.end(); sit++) {


                                 varTypes[kount] = m_osinstance->getVariableTypes()[*sit];

                                 varLowerBounds[kount]

                                                 = m_osinstance->getVariableLowerBounds()[*sit];

                                 varUpperBounds[kount]

                                                 = m_osinstance->getVariableUpperBounds()[*sit];


                                 varNames[kount] = m_osinstance->getVariableNames()[*sit];


                                 objcoeff->indexes[kount] = kount;

                                 //objcoeff->values[kount] = 0.0;

                                 objcoeff->values[kount] =  m_osinstance->getDenseObjectiveCoefficients()[0][ *sit];

                                 numNonz

                                                 += m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts[*sit + 1]

                                                                 - m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts[*sit];


                                 kount++;


                         }//end of loop over the variables in this block


                         osinstance->setVariables(numberVar, varNames, varLowerBounds,

                                         varUpperBounds, varTypes);


                         // now the objective function

                         osinstance->setObjectiveNumber(1);

                         // now the coefficient

                         osinstance->addObjective(-1, "objfunction",

                                         m_osinstance->getObjectiveMaxOrMins()[0], 0.0, 1.0,

                                         objcoeff);


                         conMap = blockConstraintIndexes[whichBlock];

                         numberCon = conMap.size();


                         if (numberCon > 0) {


                                 starts = new int[numberVar + 1];

                                 indexes = new int[numNonz];

                                 values = new double[numNonz];

                                 kount = 0;

                                 starts[kount] = 0;


                                 numNonz = 0;

                                 for (sit = varSet.begin(); sit != varSet.end(); sit++) {


                                         k2

                                                         = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts[*sit

                                                                         + 1];

                                         k1

                                                         = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts[*sit];


                                         for (i = k1; i < k2; i++) {


                                                 idx

                                                                 = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->indexes[i];


                                                 //check to make sure we are not in a core constraint

                                                 if (coreConstraintIndexes.find(idx)

                                                                 == coreConstraintIndexes.end()) {


                                                         indexes[numNonz] = conMap[idx];

                                                         values[numNonz]

                                                                         = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->values[i];

                                                         numNonz++;

                                                 }


                                         }

                                         starts[kount + 1] = numNonz;


                                         kount++;


                                 }


                                 //now the constraints


                                 osinstance->setConstraintNumber(numberCon);

                                 conLowerBounds = new double[numberCon];

                                 conUpperBounds = new double[numberCon];

                                 conConstants = new double[numberCon];


                                 for (mit = conMap.begin(); mit != conMap.end(); mit++) {


                                         conLowerBounds[mit->second]

                                                         = m_osinstance->getConstraintLowerBounds()[mit->first];

                                         conUpperBounds[mit->second]

                                                         = m_osinstance->getConstraintUpperBounds()[mit->first];

                                         conConstants[mit->second] = 1.0;


                                 }


                                 std::cout << "Call setConstraints " << numberCon << std::endl;


                                 osinstance->setConstraints(numberCon, conNames, conLowerBounds,

                                                 conUpperBounds, conConstants);


                                 osinstance->setLinearConstraintCoefficients(numNonz, true,

                                                 values, 0, numNonz - 1, indexes, 0, numNonz - 1,

                                                 starts, 0, numberVar);


                         }


                         //numNonz--;


                         //add the osinstance

                         m_blockOSInstances.push_back(osinstance);


                         //see what this puppy looks like


                         //std::cout << osinstance->printModel( ) << std::endl;


                         objcoeff->bDeleteArrays = true;

                         delete objcoeff;

                         if (varLowerBounds != NULL)

                                 delete[] varLowerBounds;

                         if (varUpperBounds != NULL)

                                 delete[] varUpperBounds;

                         if (varTypes != NULL)

                                 delete[] varTypes;

                         if (varNames != NULL)

                                 delete[] varNames;


                         //delete []starts;

                         //delete []indexes;

                         //delete []values;


                         if (conLowerBounds != NULL)

                                 delete[] conLowerBounds;

                         if (conUpperBounds != NULL)

                                 delete[] conUpperBounds;

                         if (conConstants != NULL)

                                 delete[] conConstants;


                         whichBlock++;


                 }//end for iterator for the blocks


         } //end try


         catch (const ErrorClass& eclass) {


                 std::cout << eclass.errormsg << std::endl;

                 throw ErrorClass(eclass.errormsg);


         }

         m_blockOSInstancesProcessed = true;

         return m_blockOSInstances;


 }//end getBlockOSInstances()


 std::set<int> OS_DipInterface::getCoreConstraintIndexes() {


         //get the indexes of the core constraints


         if (m_coreConstraintIndexesProcessed == true)

                 return m_coreConstraintIndexes;

         try {

                 if (m_osoption == NULL)

                         throw ErrorClass("we have a null osoption");


                 int numCoreCon;

                 int i;

                 std::vector<OtherConstraintOption*> otherConstraintOptions;

                 std::vector<OtherConstraintOption*>::iterator vit;


                 if (m_osoption != NULL

                                 && m_osoption->getNumberOfOtherConstraintOptions() > 0) {


                         otherConstraintOptions = m_osoption->getOtherConstraintOptions(

                                         "Dip");

                         //iterate over the vector of contraint options

                         for (vit = otherConstraintOptions.begin(); vit

                                         != otherConstraintOptions.end(); vit++) {


                                 // get the core constraints

                                 // get the indexes of these constraints

                                 if (((*vit)->name.compare("constraintSet") == 0)

                                                 && ((*vit)->type.compare("Core") == 0)) {


                                         numCoreCon = (*vit)->numberOfCon;


                                         for (i = 0; i < numCoreCon; i++) {


                                                 if ((*vit)->con[i]->idx

                                                                 >= m_osinstance->getConstraintNumber())

                                                         throw ErrorClass(

                                                                         "found an invalid constraint index in OSoL file");


                                                 m_coreConstraintIndexes.insert((*vit)->con[i]->idx);


                                         }//end for on variables in this block


                                 }//end iff on core constraints


                         }// end of for on constraint options


                 }//end of if on osptio null


                 if (m_coreConstraintIndexes.size() <= 0)

                         throw ErrorClass(

                                         "there were no core constraints listed in the option file");

         }// end of try


         catch (const ErrorClass& eclass) {


                 std::cout << eclass.errormsg << std::endl;

                 throw ErrorClass(eclass.errormsg);


         }

         m_coreConstraintIndexesProcessed = true;

         return m_coreConstraintIndexes;


 }//end getCoreConstraintIndexes


 double* OS_DipInterface::getObjectiveFunctionCoeff() {


         //Dip has only one objective function


         return m_osinstance->getDenseObjectiveCoefficients()[0];

 }// end getObjectiveFunctionCoeff()


 OS_DipInterface::OS_DipInterface() :


         m_isProvenOptimal(false), m_bestKnownLB(-1.e20), m_bestKnownUB(1.e20),

                         m_osinstance(NULL),

                         m_osoption(NULL),

                         m_osilreader(NULL),

                         m_osolreader(NULL),

                         m_integerVars(NULL),

                         m_coinpm(NULL),

                         m_row(NULL),

                         m_blockVariableIndexesProcessed(false),

                         m_coreConstraintIndexesProcessed(false),

                         m_blockConstraintIndexesProcessed(false),

                         m_blockOSInstancesProcessed(false),

                         m_blockFactoriesProcessed(false)

 {


 }


 OS_DipInterface::~OS_DipInterface() {

         std::cout << "INSIDE OS DIP INTERFACE DESTRUCTOR" << std::endl;

         if (m_osilreader != NULL)

                 delete m_osilreader;

         if (m_osolreader != NULL)

                 delete m_osolreader;

         delete m_coinpm;


         std::vector<OSInstance*>::iterator vit;


         if (m_blockOSInstances.size() > 0) {

                 for (vit = m_blockOSInstances.begin(); vit != m_blockOSInstances.end(); vit++) {


                         delete *vit;

                 }

         }

 }


 std::map<int, std::vector< int> > OS_DipInterface::generateInitialMaster(){


         // define the classes

         FileUtil *fileUtil = NULL;

         OSiLReader *osilreader = NULL;

         DefaultSolver *solver  = NULL;

         OSInstance *osinstance = NULL;

         OSOption *osoption = NULL;


         // end classes


         std::string testFileName;

         std::string osil;


         std::map<int, std::vector< int> > indexMap;

         std::vector< int> indexes;

         fileUtil = new FileUtil();


         try {

                 testFileName = "../data/restrictedMaster5.osil";


                 osil = fileUtil->getFileAsString(testFileName.c_str());


 #ifdef MY_DEBUG

                 std::cout << "Done reading the file" << std::endl;

 #endif


                 osilreader = new OSiLReader();


                 //create the osption

                 osoption = new OSOption();


 #ifdef MY_DEBUG

                 parsingTestResult << "Reading files successfully" << std::endl;

 #endif


                 osinstance = osilreader->readOSiL(osil);


                 solver = new CoinSolver();

                 solver->sSolverName ="cbc";

                 solver->osinstance = osinstance;

                 solver->osoption = osoption;

                 std::cout << "CALLING SOLVE FOR RESTRICTED MASTER" << std::endl;

                 solver->solve();

                 int i;

                 int j;

                 int k;

                 int vecSize;

                 // now get the primal solution

                 std::vector<IndexValuePair*> primalValPair;

                 primalValPair = solver->osresult->getOptimalPrimalVariableValues( 0);

                 vecSize = primalValPair.size();


                 int numNodes = 5;

                 int numHubs = 1;

                 int totalDemand = 4;


                 int* routeDemand = NULL;

                 int startPnt;


                 routeDemand = new int[ numHubs];

                 int kount;


                 std::string* varNames;

                 varNames =  osinstance->getVariableNames();


                 //get route demands

                 kount = 0;

                 for(k = 0; k < numHubs; k++){


                         routeDemand[k ] = (int)primalValPair[ kount]->value;


                         std::cout << "Route Demand = " << routeDemand[k] << std::endl;

                         kount++;


                 }


                 //now get x variable values


                 for(k = 0; k < numHubs; k++){


                         startPnt = k*totalDemand*(numNodes*numNodes - numNodes) + (routeDemand[ k] - 1)*(numNodes*numNodes - numNodes);


                         for(i = 0; i < numNodes; i++){


                                 for(j = 0; j < i; j++){


                                         if( primalValPair[ kount]->value > .1){


                                                 std::cout << varNames[ kount] << std::endl;

                                                 indexes.push_back(startPnt +  i*(numNodes-1) + j    );


                                         }


                                         kount++;


                                 }


                                 for(j = i + 1; j < numNodes; j++){


                                         if( primalValPair[ kount]->value > .1){

                                                 std::cout << varNames[ kount] << std::endl;

                                                 indexes.push_back(startPnt +  i*(numNodes-1) + j -1   );


                                         }


                                         kount++;


                                 }


                         }


                         //create the map


                         indexMap.insert(make_pair(k, indexes));


                 }//end loop on k -- hubs


                 std::cout << "DONE CALLING SOLVE FOR RESTRICTED MASTER" << std::endl;


                 delete[] routeDemand;


                 delete osilreader;

                 osilreader = NULL;

                 delete solver;

                 solver = NULL;

                 delete osoption;

                 osoption = NULL;


         } catch (const ErrorClass& eclass) {

                 std::cout << std::endl << std::endl << std::endl;

                 if (osilreader != NULL)

                         delete osilreader;

                 if (solver != NULL)

                         delete solver;

                 if (osoption != NULL)

                         delete osoption;

                 //  Problem with the parser

                 throw ErrorClass(eclass.errormsg);

         }


         delete fileUtil;

         fileUtil = NULL;

         return indexMap;


 }//end generateInitialMaster

OSInstance::getConstraintLowerBounds
double * getConstraintLowerBounds()
Get constraint lower bounds.
Definition: OSInstance.cpp:2419

OSInstance::getVariableLowerBounds
double * getVariableLowerBounds()
Get variable lower bounds.
Definition: OSInstance.cpp:2161

OSInstance::getConstraintUpperBounds
double * getConstraintUpperBounds()
Get constraint upper bounds.
Definition: OSInstance.cpp:2425

values
double * values
Definition: BonFilterSolver.cpp:113

OSInstance::getVariableTypes
char * getVariableTypes()
Get variable initial values.
Definition: OSInstance.cpp:2125

OS_DipInterface::getCoinPackedMatrix
CoinPackedMatrix * getCoinPackedMatrix()
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:103

OSOption::getOtherConstraintOptions
std::vector< OtherConstraintOption * > getOtherConstraintOptions(std::string solver_name)
Get the array of other constraint options.
Definition: OSOption.cpp:4435

OS_DipInterface::m_blockOSInstancesProcessed
bool m_blockOSInstancesProcessed
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.h:119

OS_DipInterface::getVariableNumber
const int getVariableNumber() const
Get variable number.
Definition: OSDipInterface.h:181

OS_DipInterface::m_integerVars
char * m_integerVars
Definition: OSDipInterface.h:73

OSOption::getNumberOfOtherConstraintOptions
int getNumberOfOtherConstraintOptions()
Get the number of other constraint options.
Definition: OSOption.cpp:2195

OS_DipInterface::m_coreConstraintIndexesProcessed
bool m_coreConstraintIndexesProcessed
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.h:107

OSInstance::setLinearConstraintCoefficients
bool setLinearConstraintCoefficients(int numberOfValues, bool isColumnMajor, double *values, int valuesBegin, int valuesEnd, int *indexes, int indexesBegin, int indexesEnd, int *starts, int startsBegin, int startsEnd)
set linear constraint coefficients
Definition: OSInstance.cpp:4755

OSInstance::getVariableNumber
int getVariableNumber()
Get number of variables.
Definition: OSInstance.cpp:2018

ErrorClass::errormsg
std::string errormsg
errormsg is the error that is causing the exception to be thrown
Definition: OSErrorClass.h:42

OSInstance::getLinearConstraintCoefficientNumber
int getLinearConstraintCoefficientNumber()
Get number of specified (usually nonzero) linear constraint coefficient values.
Definition: OSInstance.cpp:2438

OSResult::getOptimalPrimalVariableValues
std::vector< IndexValuePair * > getOptimalPrimalVariableValues(int solIdx)
Get one solution of optimal primal variable values.
Definition: OSResult.cpp:2215

osoption
OSOption * osoption
Definition: OSParseosol.tab.cpp:3982

OS_DipInterface::m_blockVariableIndexes
std::vector< std::set< int > > m_blockVariableIndexes
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.h:101

DefaultSolver::osresult
OSResult * osresult
osresult holds the solution or result of the model in-memory as an OSResult object ...
Definition: OSDefaultSolver.h:61

OS_DipInterface::m_blockVariableIndexesProcessed
bool m_blockVariableIndexesProcessed
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.h:102

OS_DipInterface::m_coinpm
CoinPackedMatrix * m_coinpm
Definition: OSDipInterface.h:74

OS_DipInterface::getObjectiveFunctionCoeff
double * getObjectiveFunctionCoeff()
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:671

OS_DipInterface::m_osilreader
OSiLReader * m_osilreader
Definition: OSDipInterface.h:71

OSiLReader::readOSiL
OSInstance * readOSiL(const std::string &osil)
parse the OSiL model instance.
Definition: OSiLReader.cpp:53

OSInstance::getVariableNames
std::string * getVariableNames()
Get variable names.
Definition: OSInstance.cpp:2119

j
static char * j
Definition: OSdtoa.cpp:3622

OSOption
The Option Class.
Definition: OSOption.h:3564

OS_DipInterface::getRow
CoinPackedVector * getRow(int i)
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:108

SparseMatrix::indexes
int * indexes
indexes holds an integer array of rowIdx (or colIdx) elements in coefMatrix (AMatrix).
Definition: OSGeneral.h:258

DefaultSolver::solve
virtual void solve()=0
solve is a virtual function – the actual solvers will implement their own solve method ...

OSInstance::getDenseObjectiveCoefficients
double ** getDenseObjectiveCoefficients()
getDenseObjectiveCoefficients.
Definition: OSInstance.cpp:2290

OS_DipInterface::getBlockVarIndexes
std::vector< std::set< int > > getBlockVarIndexes()
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:211

OS_DipInterface::getBlockConstraintIndexes
std::vector< std::map< int, int > > getBlockConstraintIndexes()
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:279

OS_DipInterface::~OS_DipInterface
~OS_DipInterface()
class destructor
Definition: OSDipInterface.cpp:699

OS_DipInterface::readOSiL
void readOSiL(std::string &filename)
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:23

OSInstance::setConstraintNumber
bool setConstraintNumber(int number)
set the number of constraints.
Definition: OSInstance.cpp:4672

OSiLReader
Used to read an OSiL string.
Definition: OSiLReader.h:37

SparseVector::bDeleteArrays
bool bDeleteArrays
bDeleteArrays is true if we delete the arrays in garbage collection set to true by default ...
Definition: OSGeneral.h:149

OS_DipInterface::getObjectiveOffset
double getObjectiveOffset()
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:147

OS_DipInterface::m_osoption
OSOption * m_osoption
Definition: OSDipInterface.h:70

SparseMatrix
a sparse matrix data structure
Definition: OSGeneral.h:223

OSInstance::getLinearConstraintCoefficientsInRowMajor
SparseMatrix * getLinearConstraintCoefficientsInRowMajor()
Get linear constraint coefficients in row major.
Definition: OSInstance.cpp:2544

OSDipInterface.h

OS_DipInterface::OS_DipInterface
OS_DipInterface()
class constructor
Definition: OSDipInterface.cpp:680

OSInstance::setObjectiveNumber
bool setObjectiveNumber(int number)
set the number of objectives.
Definition: OSInstance.cpp:4558

DefaultSolver::osoption
OSOption * osoption
osoption holds the solver options in-memory as an OSOption object
Definition: OSDefaultSolver.h:58

OS_DipInterface::m_osolreader
OSoLReader * m_osolreader
Definition: OSDipInterface.h:72

DefaultSolver
The Default Solver Class.
Definition: OSDefaultSolver.h:35

k
void fint fint * k
Definition: BonBqpdSolver.cpp:27

OSInstance::addObjective
bool addObjective(int index, std::string name, std::string maxOrMin, double constant, double weight, SparseVector *objectiveCoefficients)
add an objective.

OSInstance::getObjectiveMaxOrMins
std::string * getObjectiveMaxOrMins()
Get objective maxOrMins.
Definition: OSInstance.cpp:2258

SparseVector
a sparse vector data structure
Definition: OSGeneral.h:122

OS_DipInterface::m_row
CoinPackedVector * m_row
Definition: OSDipInterface.h:75

OSInstance::getLinearConstraintCoefficientsInColumnMajor
SparseMatrix * getLinearConstraintCoefficientsInColumnMajor()
Get linear constraint coefficients in column major.
Definition: OSInstance.cpp:2524

OSoLReader::readOSoL
OSOption * readOSoL(const std::string &osol)
parse the OSoL solver options.
Definition: OSoLReader.cpp:76

OSInstance::setVariables
bool setVariables(int number, std::string *names, double *lowerBounds, double *upperBounds, char *types)
set all the variable related elements.

int
static int
Definition: OSdtoa.cpp:2173

SparseMatrix::values
double * values
values holds a double array of value elements in coefMatrix (AMatrix), which contains nonzero element...
Definition: OSGeneral.h:264

DefaultSolver::osinstance
OSInstance * osinstance
osinstance holds the problem instance in-memory as an OSInstance object
Definition: OSDefaultSolver.h:54

OS_DipInterface::getObjectiveConstants
const double * getObjectiveConstants() const
Get objective constants.
Definition: OSDipInterface.h:153

OS_DipInterface::getCoreConstraintIndexes
std::set< int > getCoreConstraintIndexes()
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:603

OSInstance::getConstraintNumber
int getConstraintNumber()
Get number of constraints.
Definition: OSInstance.cpp:2327

DefaultSolver::sSolverName
std::string sSolverName
sSolverName is the name of the Coin solver used, e.g.
Definition: OSDefaultSolver.h:68

OS_DipInterface::readOSoL
void readOSoL(std::string &filename)
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:74

OS_DipInterface::getBlockOSInstances
std::vector< OSInstance * > getBlockOSInstances()
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:359

OSoLReader
Used to read an OSoL string.
Definition: OSoLReader.h:37

OS_DipInterface::m_blockConstraintIndexes
std::vector< std::map< int, int > > m_blockConstraintIndexes
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.h:113

OS_DipInterface::m_blockOSInstances
std::vector< OSInstance * > m_blockOSInstances
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.h:118

OS_DipInterface::getBlockFactories
std::vector< std::string > getBlockFactories()
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:160

CoinSolver
Implements a solve method for the Coin solvers.
Definition: OSCoinSolver.h:37

FileUtil::getFileAsString
std::string getFileAsString(const char *fname)
read a file and return contents as a string.
Definition: OSFileUtil.cpp:35

SparseMatrix::starts
int * starts
starts holds an integer array of start elements in coefMatrix (AMatrix), which points to the start of...
Definition: OSGeneral.h:252

SparseVector::values
double * values
values holds a double array of nonzero values.
Definition: OSGeneral.h:164

OSInstance::getVariableUpperBounds
double * getVariableUpperBounds()
Get variable upper bounds.
Definition: OSInstance.cpp:2167

OS_DipInterface::getIntegerColumns
const char * getIntegerColumns()
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:127

OS_DipInterface::m_blockConstraintIndexesProcessed
bool m_blockConstraintIndexesProcessed
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.h:114

SparseVector::indexes
int * indexes
indexes holds an integer array of indexes whose corresponding values are nonzero. ...
Definition: OSGeneral.h:159

OS_DipInterface::m_osinstance
OSInstance * m_osinstance
Definition: OSDipInterface.h:69

OSOption::getNumberOfOtherVariableOptions
int getNumberOfOtherVariableOptions()
Get the number of other variable options.
Definition: OSOption.cpp:2122

OS_DipInterface::m_blockFactories
std::vector< std::string > m_blockFactories
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.h:124

OSInstance::setVariableNumber
bool setVariableNumber(int number)
set the number of variables.
Definition: OSInstance.cpp:4469

OSInstance
The in-memory representation of an OSiL instance..
Definition: OSInstance.h:2262

osinstance
OSInstance * osinstance
Definition: OSParseosil.tab.cpp:3860

FileUtil
class used to make it easy to read and write files.
Definition: OSFileUtil.h:37

OSInstance::setConstraints
bool setConstraints(int number, std::string *names, double *lowerBounds, double *upperBounds, double *constants)
set all the constraint related elements.

OS_DipInterface::m_coreConstraintIndexes
std::set< int > m_coreConstraintIndexes
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.h:106

ErrorClass
used for throwing exceptions.
Definition: OSErrorClass.h:31

OS_DipInterface::m_blockFactoriesProcessed
bool m_blockFactoriesProcessed
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.h:125

OS_DipInterface::generateInitialMaster
std::map< int, std::vector< int > > generateInitialMaster()
Returns array[getNumCols()] specifying if a variable is integer.
Definition: OSDipInterface.cpp:719

OSOption::getOtherVariableOptions
std::vector< OtherVariableOption * > getOtherVariableOptions(std::string solver_name)
Get the &lt;other&gt; variable options associated with a particular solver.
Definition: OSOption.cpp:3315