// --------------------------------------------------------------------- //
bool DecompVarPool::isDuplicate(const DecompVarList& vars,
const DecompWaitingCol& wcol)
{
DecompVarList::const_iterator vi;
for (vi = vars.begin(); vi != vars.end(); vi++) {
if ((*vi)->getStrHash() == wcol.getVarPtr()->getStrHash()) {
return true;
}
}
return false;
}
// --------------------------------------------------------------------- //
bool DecompVarPool::isDuplicate(const DecompVarList& vars,
const DecompWaitingCol& wcol)
{
DecompVarList::const_iterator vi;
for (vi = vars.begin(); vi != vars.end(); vi++) {
//TODO: this is very expensive
//TODO: override DecompWaitingCol operator==
//printf("\nHERE isDup");
if ((*vi)->isEquivalent(*wcol.getVarPtr())) { //checks if s is equivalent
return true;
}
}
return false;
}
/**
* generateInitVars callback
*
* Called by DIP, we interface with Python
*/
int DippyDecompApp::generateInitVars(DecompVarList& initVars)
{
if (!m_pyInitVars) {
return 0;
}
PyObject* pVarList = PyObject_CallMethod(m_pProb, "generateInitVars", NULL);
if (pVarList == NULL) {
throw UtilException("Error calling method prob.generateInitVars()", "generateInitVars", "DippyDecompApp");
}
if (pVarList == Py_None)
// method exists, but is not implemented, return 0
{
return 0;
}
int nVars = PyObject_Length(pVarList);
// generateInitVars returns 2-tuples (index, (cost, dictionary of (variable, value) pairs))
// We can use these to construct a C++ DecompVar objects
for (int i = 0; i < nVars; i++) {
PyObject* pTuple = PyList_GetItem(pVarList, i);
int whichBlock = m_relaxIndices[PyTuple_GetItem(pTuple, 0)];
PyObject* pVarTuple = PyTuple_GetItem(pTuple, 1);
double cost = PyFloat_AsDouble(PyTuple_GetItem(pVarTuple, 0));
PyObject* pColDict = PyTuple_GetItem(pVarTuple, 1);
int* varInds = NULL;
double* varVals = NULL;
DecompVarType varType;
int numPairs = pyColDict_AsPackedArrays(pColDict, m_colIndices, &varInds, &varVals, varType);
assert(numPairs == PyObject_Length(pColDict));
DecompVar* var = new DecompVar(numPairs, varInds, varVals, cost, varType);
var->setBlockId(whichBlock);
initVars.push_back(var);
}
return nVars;
}
int OSDipApp::generateInitVars(DecompVarList & initVars) {
//---
//--- generateInitVars is a virtual method and can be overriden
//--- if the user has some idea how to initialize the list of
//--- initial variables (columns in the DW master)
//---
std::cout << "GENERATE INIT VARS" << std::endl;
UtilPrintFuncBegin(m_osLog, m_classTag, "generateInitVars()",
m_appParam.LogLevel, 2);
//---
//--- Get the initial solution from the OSOption object
//--- we want the variable other option where name="initialCol"
//---
//std::vector<OtherVariableOption*> getOtherVariableOptions(std::string solver_name);
std::vector<OtherVariableOption*> otherVarOptions;
std::vector<OtherVariableOption*>::iterator vit;
int *index = NULL;
double *value = NULL;
int i;
double objValue;
int whichBlock;
DecompVar *var;
try{
if (m_osInterface.m_osoption != NULL
&& m_osInterface.m_osoption->getNumberOfOtherVariableOptions() > 0) {
std::cout << "Number of other variable options = "
<< m_osInterface.m_osoption->getNumberOfOtherVariableOptions()
<< std::endl;
otherVarOptions = m_osInterface.m_osoption->getOtherVariableOptions(
"Dip");
//iterate over the vector
for (vit = otherVarOptions.begin(); vit != otherVarOptions.end(); vit++) {
// see if we have an initialCol option
if ((*vit)->name.compare("initialCol") == 0) {
index = new int[(*vit)->numberOfVar];
value = new double[(*vit)->numberOfVar];
objValue = 0.0;
for (i = 0; i < (*vit)->numberOfVar; i++) {
index[i] = (*vit)->var[i]->idx;
//convert the string to integer
value[ i] = atoi((*vit)->var[i]->value.c_str());
objValue += m_objective[index[i]];
}
whichBlock = atoi( (*vit)->value.c_str() );
var = new DecompVar((*vit)->numberOfVar, index, value, objValue);
var->setBlockId(whichBlock);
initVars.push_back(var);
//free local memory
UTIL_DELARR( index);
UTIL_DELARR( value);
}
}
}
}//end try
catch(const ErrorClass& eclass){
throw ErrorClass( eclass.errormsg);
}
UtilPrintFuncEnd(m_osLog, m_classTag, "generateInitVars()",
m_appParam.LogLevel, 2);
return static_cast<int> (initVars.size());
}
/**
* solveRelaxed callback
*
* This is called by DIP. This function interfaces with Python to
* call the user defined function if it's present
*
* We're expected to populate varList (basically a vector) and
* return the status of the subproblem solver.
*/
DecompSolverStatus DippyDecompApp::solveRelaxed(const int whichBlock,
const double* redCostX,
const double convexDual,
DecompVarList& varList)
{
if (!m_pySolveRelaxed) {
return DecompSolStatNoSolution;
}
PyObject* pRelaxKey = PyList_GetItem(m_relaxedKeys, whichBlock);
PyObject* pRedCostList = pyTupleList_FromDoubleArray(redCostX, m_colList);
PyObject* pConvexDual = PyFloat_FromDouble(convexDual);
// call solveRelaxed on DipProblem
PyObject* pStatandVarList = PyObject_CallMethod(m_pProb, "solveRelaxed", "OOd",
pRelaxKey,
pRedCostList,
pConvexDual);
Py_DECREF(pRedCostList);
Py_DECREF(pConvexDual);
if ( (pStatandVarList == NULL) || (pStatandVarList == Py_None) ){
throw UtilException("Error calling method prob.solveRelaxed()", "solveRelaxed", "DippyDecompApp");
}
// [status, varList] = relaxed_solver(...)
PyObject * pStatus = PyTuple_GetItem(pStatandVarList, 0);
int cStatus = PyInt_AsLong(pStatus);
DecompSolverStatus status = (DecompSolverStatus)cStatus;
PyObject * pVarList = PyTuple_GetItem(pStatandVarList, 1);
int nVars = PyObject_Length(pVarList);
// In the new design, we need to allow the possibility that the user will solve
// the problem exactly, but not find any solutions with reduced costs zero
// The below is is commented out and left in the source for posterity
// tkr 11/11/15
//if (nVars == 0) {
// throw UtilException("Empty variable list", "solveRelaxed", "DippyDecompApp");
//}
// solveRelaxed returns 3-tuples (cost, reduced cost, dictionary of (variable, value) pairs)
// We can use these to construct a C++ DecompVar objects
double cost, rc;
PyObject *pDict, *pKeys, *pCol;
string name;
double value;
for (int j = 0; j < nVars; j++) {
PyObject* pTuple = PySequence_GetItem(pVarList, j);
cost = PyFloat_AsDouble(PyTuple_GetItem(pTuple, 0));
rc = PyFloat_AsDouble(PyTuple_GetItem(pTuple, 1));
pDict = PyTuple_GetItem(pTuple, 2);
pKeys = PyDict_Keys(pDict);
vector<int> varInds;
vector<double> varVals;
for (int n = 0; n < PyObject_Length(pDict); n++) {
pCol = PyList_GetItem(pKeys, n);
value = PyFloat_AsDouble(PyDict_GetItem(pDict, pCol));
varInds.push_back(m_colIndices[pCol]);
varVals.push_back(value);
}
Py_DECREF(pKeys);
Py_DECREF(pTuple);
DecompVar* var = new DecompVar(varInds, varVals, rc, cost);
var->setBlockId(whichBlock);
varList.push_back(var);
}
Py_DECREF(pStatandVarList);
return status;
}
