19#include "OSInstance.h"
30#include "OSInstance.h"
33#include "CoinTime.hpp"
35#include "ClpFactorization.hpp"
36#include "ClpNetworkMatrix.hpp"
37#include "OsiClpSolverInterface.hpp"
46# error "don't have header file for math"
56# error "don't have header file for time"
66 std::cout <<
"INSIDE OSBearcatSolverXkij CONSTRUCTOR with OSOption argument" << std::endl;
70 std::cout <<
"INSIDE OSBearcatSolverXkij CONSTRUCTOR with OSOption argument" << std::endl;
221 for(i = 0; i < numVar; i++){
315 std::cout <<
"INSIDE ~OSBearcatSolverXkij DESTRUCTOR" << std::endl;
565 testVal =
qrouteCost(k - 1, l, c[ k - 1], &kountVar);
570 if(
m_vv[ k-1][
d1] + testVal <
m_vv[ k][ d] ){
629 if( isFeasible ==
false){
631 std::cout <<
"NOT ENOUGH CAPACITY " << std::endl;
671 std::cout <<
"LVALUE NEGATIVE " << l << std::endl;
679 std::cout <<
"LVALUE BIGGER THAN UPPER BOUND " << l << std::endl;
775 for(l2 = lowerVal; l2 <= l; l2++){
789 if(
m_px[j][ l1 ] != i ){
807 if(
m_g[j][i] <
m_u[i][l2] ){
825 if(
m_px[j][ l1 ] != i ){
839 if(
m_g[j][i] <
m_u[i][l2] ){
857 if( (
m_g[j][i] <
m_v[i][l2] ) && (
m_px[i][l2] != j) ){
918 currentNode = bestLastNode;
923 while(currentNode != k){
925 if(
m_px[ currentNode][ lvalue ] != successorNode){
930 successorNode = currentNode;
931 currentNode =
m_px[ currentNode][ lvalue ];
934 if(currentNode - successorNode > 0){
937 *(
m_varIdx + (*kountVar)++) = startPnt + currentNode*(
m_numNodes - 1) + successorNode;
943 *(
m_varIdx + (*kountVar)++) = startPnt + currentNode*(
m_numNodes - 1) + successorNode - 1 ;
952 successorNode = currentNode;
953 currentNode =
m_tx[ currentNode][ lvalue ];
955 if(currentNode - successorNode > 0){
957 *(
m_varIdx + (*kountVar)++) = startPnt + currentNode*(
m_numNodes - 1) + successorNode;
961 *(
m_varIdx + (*kountVar)++) = startPnt + currentNode*(
m_numNodes - 1) + successorNode - 1 ;
968 lvalue = lvalue - *(
m_demand + successorNode);
987 const double* yB,
const int numBRows,
988 int &numNewColumns,
int* &numNonzVec,
double* &costVec,
989 int** &rowIdxVec,
double** &valuesVec,
double &lowerBound)
996 int numCoulpingConstraints;
1025 double start = CoinCpuTime();
1027 cpuTime = CoinCpuTime() - start;
1028 std::cout <<
"DYNAMIC PROGRSMMING CPU TIME " << cpuTime << std::endl;
1036 std::cout <<
" whichBlock = " << k <<
" L = " <<
m_optL[ k] << std::endl;
1045 m_optValHub[ k] -= yA[ k + numCoulpingConstraints];
1047 std::cout <<
"Best Reduced Cost Hub " << k <<
" = " <<
m_optValHub[ k] << std::endl;
1056 for(j = 0; j < kountVar; j++){
1073 for(i = 0; i < numCoulpingConstraints; i++){
1136 for(j = 0; j < kountVar; j++){
1203 std::cout <<
"Lower Bound = " <<
m_lowerBnd << std::endl;
1208 std::cout <<
"TOTAL DEMAND = " <<
m_totalDemand << std::endl;
1209 std::cout <<
"Test Value = " << testVal << std::endl;
1210 throw ErrorClass(
"inconsistent demand calculation" );
1229 std::cout <<
"LEAVING GET COLUMNS" << std::endl;
1532 std::cout <<
"Executing OSBearcatSolverXkij::getInitialRestrictedMaster2( )" << std::endl;
1551 std::string testFileName;
1554 std::map<int, std::map<int, std::vector<int> > >::iterator mit;
1555 std::map<int, std::vector<int> >::iterator mit2;
1556 std::vector<int>::iterator vit;
1573 int *starts =
new int[ numThetaVar + 1 + numVarArt];
1580 for(i = 0; i < numVarArt; i++){
1586 std::vector<IndexValuePair*> primalValPair;
1594 xVar =
new double[ numXVar];
1596 for(i = 0; i < numXVar; i++){
1603 int* numRowNonz = NULL;
1604 int** colIdx = NULL;
1605 double** rowValues = NULL ;
1620 osinstance = osilreader->
readOSiL(osil);
1636 for ( mit2 = mit->second.begin() ; mit2 != mit->second.end(); mit2++ ){
1640 for ( vit = mit2->second.begin() ; vit != mit2->second.end(); vit++ ){
1644 std::cout <<
"FIXING LOWER BOUND ON VARIABLE " << osinstance->
getVariableNames()[ kount + mit2->first*
m_numNodes + *vit ] << std::endl;
1667 for(j = 0; j < i; j++){
1683 std::string* varNames;
1710 std::string masterVarName;
1716 objcoeff->
indexes[ varNumber ] = varNumber ;
1731 values[ kountNonz] = 1;
1732 indexes[ kountNonz++] = i ;
1733 starts[ startsIdx++] = kountNonz;
1779 OsiSolverInterface *si = solver->
osiSolver;
1800 while(isCutAdded ==
true){
1813 std::cout <<
"HUB " << k <<
" VARIABLES" << std::endl;
1820 for(i = idx1; i < idx2; i++){
1821 if( primalValPair[ i]->value > .01 ){
1822 std::cout << osinstance->
getVariableNames()[ primalValPair[ i]->idx ] << std::endl;
1836 getCutsX(xVar, numXVar, numNewRows, numRowNonz,
1837 colIdx,rowValues, rowLB, rowUB);
1841 if(numNewRows >= 1){
1843 std::cout <<
"WE HAVE A CUT " << std::endl;
1844 std::cout <<
"EXPRESS CUT IN X(I, J) SPACE" << std::endl;
1845 for(i = 0; i < numRowNonz[ 0]; i++){
1852 for(i = 0; i < numNewRows; i++){
1856 std::cout <<
"EXPRESS CUT IN X(K, I, J) SPACE" << std::endl;
1858 for(j = 0; j < numRowNonz[ i]; j++){
1862 std::cout << osinstance->
getVariableNames()[ colIdx[ i][ j] ] << std::endl;
1865 std::cout <<
"CUT UPPER BOUND = " << rowUB[ i] << std::endl;
1868 si->addRow(numRowNonz[ i], colIdx[ i], rowValues[ i], rowLB[ i], rowUB[ i] ) ;
1878 for(i = idx1; i < idx2; i++){
1879 if( primalValPair[ i]->value > .01 ){
1888 std::cout <<
"Optimal Objective Value = " << primalValPair[ k]->value*primalValPair[ k +
m_numHubs]->value << std::endl;
1895 std::cout << std::endl << std::endl;
1896 if( isCutAdded ==
true) {
1898 std::cout <<
"A CUT WAS ADDED, CALL SOLVE AGAIN" << std::endl;
1902 std::cout <<
"Optimal Objective Value = " << solver->
osresult->
getObjValue(0, 0) << std::endl;
1938 for(j1 = 0; j1 < i1; j1++){
1942 if( primalValPair[ idx1 ]->value > .1 ){
1949 values[ kountNonz] = 1;
1950 indexes[ kountNonz++] = j1 -
m_numHubs ;
1966 if( primalValPair[ idx1 ]->value > .1 ){
1974 values[ kountNonz] = 1;
1975 indexes[ kountNonz++] = j1 -
m_numHubs ;
1990 values[ kountNonz] = 1;
1994 std::cout <<
" m_numThetaVar " <<
m_numThetaVar << std::endl;
2002 masterVarName +=
")";
2003 intVarSet.insert ( std::pair<int,double>(varNumber, 1.0) );
2006 std::cout <<
"Optimal Objective Value = " << primalValPair[ k]->value*primalValPair[ k +
m_numHubs]->value << std::endl;
2008 objcoeff->
indexes[ k + numVarArt ] = k + numVarArt ;
2009 objcoeff->
values[ k + numVarArt ] = primalValPair[ k]->value*primalValPair[ k +
m_numHubs]->value;
2013 std::cout <<
"m_bestIPValue = " <<
m_bestIPValue << std::endl;
2014 starts[ startsIdx++] = kountNonz;
2039 values, 0, kountNonz - 1, indexes, 0, kountNonz - 1, starts, 0, startsIdx);
2042 primalValPair.clear();
2049 std::cout <<
"NONZ = " << kountNonz << std::endl;
2066 std::cout << std::endl << std::endl << std::endl;
2067 if (osilreader != NULL)
2090 std::cout <<
"Executing getOptions(OSOption *osoption)" << std::endl;
2097 std::vector<SolverOption*> solverOptions;
2098 std::vector<SolverOption*>::iterator vit;
2099 std::vector<int>::iterator vit2;
2100 std::vector<int >demand;
2101 std::vector<int >routeCapacity;
2102 std::vector<int >routeMinPickup;
2106 if (solverOptions.size() == 0)
throw ErrorClass(
"options for routeSolver not available");
2111 std::string routeString;
2112 std::string solutionString;
2113 string::size_type pos1;
2114 string::size_type pos2;
2115 string::size_type pos3;
2118 std::map<int, std::map<int, std::vector<int> > >::iterator mit;
2119 std::map<int, std::vector<int> >::iterator mit2;
2124 for (vit = solverOptions.begin(); vit != solverOptions.end(); vit++) {
2132 if( (*vit)->name.find(
"numHubs") != std::string::npos){
2135 std::istringstream hubBuffer( (*vit)->value);
2137 std::cout <<
"numHubs = " <<
m_numHubs << std::endl;
2141 if((*vit)->name.find(
"numNodes") != std::string::npos){
2144 std::istringstream numNodesBuffer( (*vit)->value);
2146 std::cout <<
"numNodes = " <<
m_numNodes << std::endl;
2149 if((*vit)->name.find(
"totalDemand") != std::string::npos){
2152 std::istringstream totalDemandBuffer( (*vit)->value);
2154 std::cout <<
"m_totalDemand = " <<
m_totalDemand << std::endl;
2157 if((*vit)->name.find(
"routeMinPickup") != std::string::npos){
2160 std::istringstream routeMinPickupBuffer( (*vit)->value);
2161 routeMinPickupBuffer >> tmpVal;
2162 routeMinPickup.push_back( tmpVal);
2166 if( (*vit)->name.find(
"demand") != std::string::npos ){
2169 std::istringstream demandBuffer( (*vit)->value);
2170 demandBuffer >> tmpVal;
2171 if(tmpVal <= 0 && demand.size() >
m_numHubs)
throw ErrorClass(
"must have strictly positive demand");
2173 demand.push_back( tmpVal);
2177 if((*vit)->name.find(
"routeCapacity") != std::string::npos ){
2178 std::istringstream routeCapacityBuffer( (*vit)->value);
2179 routeCapacityBuffer >> tmpVal;
2180 routeCapacity.push_back( tmpVal);
2185 if((*vit)->name.find(
"osilFile") != std::string::npos ){
2191 if( (*vit)->name.find(
"restrictedMasterSolution") != std::string::npos ){
2198 pos1 = (*vit)->category.find(
":");
2199 if(pos1 == std::string::npos )
throw ErrorClass(
"OSoL category attribute not properly defined");
2202 solutionString = (*vit)->category.substr( 0, pos1);
2203 routeString = (*vit)->category.substr( pos1 + 1);
2205 pos2 = solutionString.find(
"n");
2206 if(pos2 == std::string::npos )
throw ErrorClass(
"OSoL category attribute not properly defined");
2208 std::istringstream solutionBuffer( solutionString.substr( pos2 + 1) );
2209 solutionBuffer >> solutionNumber;
2213 pos3 = routeString.find(
"e");
2214 if(pos3 == std::string::npos )
throw ErrorClass(
"OSoL category attribute not properly defined");
2215 std::istringstream routeBuffer( routeString.substr( pos3 + 1) );
2216 routeBuffer >> routeNumber;
2218 std::istringstream nodeBuffer( (*vit)->value);
2219 nodeBuffer >> tmpVal;
2227 mit2 = mit->second.find( routeNumber);
2229 if(mit2 != mit->second.end() ){
2233 mit2->second.push_back( tmpVal);
2239 std::vector<int> tmpVec;
2240 tmpVec.push_back( tmpVal) ;
2241 mit->second.insert( std::pair<
int,std::vector<int> >(routeNumber, tmpVec) );
2248 std::vector<int> tmpVec;
2249 tmpVec.push_back( tmpVal) ;
2251 std::map<int, std::vector<int> > tmpMap;
2252 tmpMap.insert( std::pair<
int,std::vector<int> >(routeNumber, tmpVec) );
2253 m_initSolMap.insert( std::pair<
int, std::map<
int, std::vector<int> > >(solutionNumber, tmpMap) ) ;
2258 if( (*vit)->name.find(
"maxMasterColumns") != std::string::npos){
2261 std::istringstream maxMasterColumns( (*vit)->value);
2266 if( (*vit)->name.find(
"maxThetaNonz") != std::string::npos){
2268 std::istringstream maxThetaNonz( (*vit)->value);
2273 if( (*vit)->name.find(
"use1OPTstart") != std::string::npos){
2275 if ( (*vit)->value.find(
"true") != std::string::npos )
m_use1OPTstart =
true;
2279 if( (*vit)->name.find(
"maxBmatrixCon") != std::string::npos ){
2281 std::istringstream maxBmatrixCon( (*vit)->value);
2286 if( (*vit)->name.find(
"maxBmatrixNonz") != std::string::npos ){
2288 std::istringstream maxBmatrixNonz( (*vit)->value);
2314 for (vit2 = routeCapacity.begin(); vit2 != routeCapacity.end(); vit2++) {
2319 routeCapacity.clear();
2326 for (vit2 = routeMinPickup.begin(); vit2 != routeMinPickup.end(); vit2++) {
2331 routeMinPickup.clear();
2340 for (vit2 = demand.begin(); vit2 != demand.end(); vit2++) {
2362 int &numNewRows,
int* &numNonz,
int** &colIdx,
2363 double** &values,
double* &rowLB,
double* &rowUB) {
2378 tmpRhs =
new double[ numSepRows ];
2380 for(i = 0; i < numSepRows; i++){
2389 ErrorClass(
"number of master varibles in OSBearcatSolverXkij::getCuts inconsistent");
2398 for(i = 0; i < numTheta; i++){
2416 tmpRhs[ rowKount] -= theta[ i];
2427 for(i = indexAdjust; i < numSepRows - 1; i++){
2434 int tmpKount = indexAdjust;
2467 std::cout <<
" m_Bmatrix[ j] " << m_Bmatrix[ j] << std::endl ;
2558 std::vector<int> dualIdx;
2559 std::vector<int>::iterator vit1;
2560 std::vector<int>::iterator vit2;
2565 for(k = 0; k < indexAdjust; k++){
2577 std::cout <<
"DOING SEPARATION FOR NODE " << k +
m_numHubs << std::endl;
2586 for (vit1 = dualIdx.begin(); vit1 != dualIdx.end(); vit1++) {
2590 for (vit2 = dualIdx.begin(); vit2 != dualIdx.end(); vit2++) {
2597 std::cout <<
"CUT VARIABLE = " <<
m_variableNames[ index ] <<std::endl;
2605 std::cout <<
"CUT VARIABLE = " <<
m_variableNames[ index ] <<std::endl;
2623 for(i = indexAdjust; i < numSepRows - 1; i++){
2716 for(i = indexAdjust; i < numSepRows - 1; i++){
2744 int &numNewRows,
int* &numNonz,
int** &colIdx,
2745 double** &values,
double* &rowLB,
double* &rowUB) {
2760 tmpRhs =
new double[ numSepRows ];
2762 for(i = 0; i < numSepRows; i++){
2770 for(i = 0; i < numX; i++){
2780 tmpRhs[ rowKount] -= x[ i];
2787 for(i = indexAdjust; i < numSepRows - 1; i++){
2795 int tmpKount = indexAdjust;
2845 std::vector<int> dualIdx;
2846 std::vector<int>::iterator vit1;
2847 std::vector<int>::iterator vit2;
2852 for(k = 0; k < indexAdjust; k++){
2853 std::cout << std::endl << std::endl;
2862 std::cout <<
"DOING SEPARATION FOR NODE " << k +
m_numHubs << std::endl;
2873 for (vit1 = dualIdx.begin(); vit1 != dualIdx.end(); vit1++) {
2877 for (vit2 = dualIdx.begin(); vit2 != dualIdx.end(); vit2++) {
2884 std::cout <<
"CUT VARIABLE = " <<
m_variableNames[ index] <<std::endl;
2893 std::cout <<
"CUT VARIABLE = " <<
m_variableNames[ index] <<std::endl;
2909 for(i = indexAdjust; i < numSepRows - 1; i++){
2940 for(i = indexAdjust; i < numSepRows - 1; i++){
2982 for(j = 0; j < i; j++){
2986 m_rc[k][ kount++] = l*
m_cost[k][ i*tmpVal + j ] ;
3003 m_rc[k][ kount++] = l*
m_cost[k][ i*tmpVal + j - 1 ];
3044 m_rc[ k][ startPnt + m_Bmatrix[ j] ] -= yB[ i];
3069 for(j = 0; j < i; j++){
3114 for(i = 0; i < j; i++){
3146 std::cout << std::endl;
3147 std::cout <<
" PAU HANA TIME! " << std::endl;
3150 std::vector<int>::iterator vit;
3170 for(vit = m_zOptIndexes.begin() ; vit != m_zOptIndexes.end(); vit++){
3173 std::cout <<
"x variables for column " << i << std::endl;
3179 std::cout <<
"INDEX = " <<
m_thetaIndex[ j] << std::endl;
3187 std::cout <<
"cost = " << cost << std::endl << std::endl;
3189 std::cout << std::endl << std::endl;
3190 std::cout <<
"LOWER BOUND VALUE = " <<
m_bestLPValue << std::endl;
3191 std::cout <<
"FINAL BEST IP SOLUTION VALUE = " <<
m_bestIPValue << std::endl;
3192 std::cout <<
"NUMBER OF COLUMNS IN FINAL MASTER = " <<
m_numThetaVar << std::endl;
3195 std::cout <<
"NUMBER OF GENERATED COLUMNS = " << numColsGen << std::endl;
3196 std::cout <<
"NUMBER OF GENERATED CUTS = " <<
m_numBmatrixCon << std::endl;
3197 std::cout <<
"NUMBER OF NODES = " << numNodes << std::endl;
3198 std::cout <<
" PAU!!!" << std::endl;
3200 std::cout << std::endl << std::endl;
3205 std::cout << std::endl << std::endl;
3233 double *values =
new double[ 2*numYvar + 2*numVvar];
3234 int *indexes =
new int[ 2*numYvar + 2*numVvar];
3235 int *starts =
new int[ numYvar + numVvar + 1];
3244 std::string separationVarName;
3245 std::string separationConName;
3279 separationConName +=
")";
3294 std::cout <<
"NUMBER OF VARIABLES SET = " << numYvar + numVvar << std::endl;
3296 for(i = 0; i < numVvar; i++){
3302 values[ kountNonz ] = -1.0;
3303 indexes[ kountNonz ] = i;
3306 values[ kountNonz ] = 1.0;
3307 indexes[ kountNonz ] = rowKounter - 1;
3312 starts[ startsIdx++ ] = kountNonz;
3336 separationVarName +=
")";
3344 values[ kountNonz ] = 1.0;
3345 indexes[ kountNonz ] = i1;
3348 values[ kountNonz ] = -1.0;
3349 indexes[ kountNonz ] = kountCon ;
3352 starts[ startsIdx++ ] = kountNonz;
3359 separationVarName +=
")";
3362 values[ kountNonz ] = 1.0;
3363 indexes[ kountNonz ] = j1;
3369 values[ kountNonz ] = -1.0;
3370 indexes[ kountNonz ] = kountCon ;
3373 starts[ startsIdx++ ] = kountNonz;
3383 std::cout <<
"NUMBER OF VARIABLES ADDED = " << kount << std::endl;
3390 for(i = 0; i < numVvar; i++){
3393 objcoeff->
values[ i] = 1.0;
3405 values, 0, kountNonz - 1, indexes, 0, kountNonz - 1, starts, 0, startsIdx);
3418 CoinPackedMatrix* matrix;
3419 bool columnMajor =
true;
3421 matrix =
new CoinPackedMatrix(
3431 ClpNetworkMatrix network( *matrix);
3467 double from1Distance;
3468 double from0Distance;
3475 xvalues =
new double[ numVar];
3476 for(i = 0; i < numVar; i++){
3504 for( j = 0; j < i; j++){
3507 from1Distance = 1 - xvalues[ i*(
m_numNodes - 1) + j ];
3508 from0Distance = xvalues[ i*(
m_numNodes - 1) + j ];
3509 fraction = std::max(from1Distance, from0Distance);
3511 if(fraction < minFraction){
3513 minFraction = fraction;
3523 from1Distance = 1 - xvalues[ i*(
m_numNodes - 1) + j - 1 ];
3524 from0Distance = xvalues[ i*(
m_numNodes - 1) + j - 1 ];
3525 fraction = std::max(from1Distance, from0Distance);
3527 if(fraction < minFraction) {
3529 minFraction = fraction;
3544 for( j = 0; j < i; j++){
3547 from1Distance = 1 - xvalues[ i*(
m_numNodes - 1) + j ];
3548 from0Distance = xvalues[ i*(
m_numNodes - 1) + j ];
3549 fraction = std::max(from1Distance, from0Distance);
3551 if(fraction < minFraction) {
3553 minFraction = fraction;
3563 from1Distance = 1 - xvalues[ i*(
m_numNodes - 1) + j - 1 ];
3564 from0Distance = xvalues[ i*(
m_numNodes - 1) + j - 1 ];
3565 fraction = std::max(from1Distance, from0Distance);
3567 if(fraction < minFraction) {
3569 minFraction = fraction;
3578 std::cout <<
" HERE IS GAIL 1" << std::endl;
3583 std::cout <<
" HERE IS GAIL 2" << std::endl;
3603 const int numThetaVar) {
3610 double from1Distance;
3611 double from0Distance;
3618 xvalues =
new double[ numVar];
3619 for(i = 0; i < numVar; i++){
3626 for(i = 0; i < numThetaVar; i++){
3648 for( j = 0; j < i; j++){
3651 from1Distance = 1 - xvalues[ i*(
m_numNodes - 1) + j ];
3652 from0Distance = xvalues[ i*(
m_numNodes - 1) + j ];
3653 fraction = std::max(from1Distance, from0Distance);
3655 if(fraction < minFraction){
3657 minFraction = fraction;
3667 from1Distance = 1 - xvalues[ i*(
m_numNodes - 1) + j - 1 ];
3668 from0Distance = xvalues[ i*(
m_numNodes - 1) + j - 1 ];
3669 fraction = std::max(from1Distance, from0Distance);
3671 if(fraction < minFraction) {
3673 minFraction = fraction;
3684 std::cout <<
"MIN FRACTION = " << minFraction << std::endl;
3692 for( j = 0; j < i; j++){
3695 from1Distance = 1 - xvalues[ i*(
m_numNodes - 1) + j ];
3696 from0Distance = xvalues[ i*(
m_numNodes - 1) + j ];
3697 fraction = std::max(from1Distance, from0Distance);
3699 if(fraction < minFraction) {
3701 minFraction = fraction;
3711 from1Distance = 1 - xvalues[ i*(
m_numNodes - 1) + j - 1 ];
3712 from0Distance = xvalues[ i*(
m_numNodes - 1) + j - 1 ];
3713 fraction = std::max(from1Distance, from0Distance);
3715 if(fraction < minFraction) {
3717 minFraction = fraction;
3748 const std::map<int, int> &varConMap,
int &varIdx,
int &numNonz,
3749 int* &indexes,
double* &values) {
3766 std::cout <<
"Branching on Variable: " <<
m_variableNames[ varIdx] << std::endl;
3771 if( varConMap.find( varIdx) == varConMap.end() ){
3829 const int numThetaVar,
const std::map<int, int> &varConMap,
3830 int &varIdx,
int &numNonz,
int* &indexes,
double* &values) {
3846 std::cout <<
"Branching on Variable: " <<
m_variableNames[ varIdx] << std::endl;
3851 if( varConMap.find( varIdx) == varConMap.end() ){
3947 std::map<int, int>::iterator mit;
3949 int numVars = inVars.size();
3957 std::vector<double> valuesVec;
3958 double *values = NULL;
3960 std::vector<int> indexesVec;
3961 int *indexes = NULL ;
3963 int *starts =
new int[ numVars + 1 + numVarArt];
3977 for(mit = inVars.begin(); mit != inVars.end(); mit++){
3983 thetaPntTmp =
new int[ numVars + 1];
3984 thetaIndexTmp =
new int[ numNonz];
3988 for(mit = inVars.begin(); mit != inVars.end(); mit++){
4000 thetaPntTmp[ kount] = 0;
4002 for(mit = inVars.begin(); mit != inVars.end(); mit++){
4016 thetaPntTmp[ kount] = numNonz;
4022 inVars[ mit->first] = numVarArt + kount - 1 ;
4038 for(i = 0; i < numVarArt; i++){
4048 for(mit = inVars.begin(); mit != inVars.end(); mit++){
4051 intVarSet.insert ( std::pair<int,double>(mit->second, 1.0) );
4060 for(j = thetaPntTmp[ mit->second - numVarArt]; j < thetaPntTmp[ mit->second - numVarArt + 1 ]; j++){
4080 si->writeLp(
"gailTest" );
4088 starts[ startsIdx++] = numNonz;
4090 for(i = 0; i < numVarArt; i++){
4092 starts[ startsIdx++] = numNonz;
4093 valuesVec.push_back( 1.0);
4094 indexesVec.push_back( i);
4104 for(mit = inVars.begin(); mit != inVars.end(); mit++){
4107 valuesVec.push_back( 1.0);
4123 for(i = 0; i < numAmatrixRows; i++){
4142 valuesVec.push_back( rowCount);
4143 indexesVec.push_back( i);
4172 valuesVec.push_back( rowCount);
4188 starts[ startsIdx++] = numNonz;
4194 values =
new double[ numNonz];
4195 indexes =
new int[ numNonz];
4197 if(numNonz != valuesVec.size() )
throw ErrorClass(
"dimension problem in reset");
4198 if(numNonz != indexesVec.size() )
throw ErrorClass(
"dimension problem in reset");
4200 for(i = 0; i < numNonz; i++){
4202 values[ i] = valuesVec[i];
4203 indexes[ i] = indexesVec[i];
4242 for(i = 0; i < numVarArt; i++){
4244 objcoeff->
indexes[ varNumber ] = varNumber ;
4258 for(mit = inVars.begin(); mit != inVars.end(); mit++){
4260 objcoeff->
indexes[ varNumber ] = varNumber ;
4262 objcoeff->
values[ varNumber ] = si->getObjCoefficients()[ mit->first] ;
4264 m_thetaCost[ varNumber] = si->getObjCoefficients()[ mit->first];
4288 si->getRowLower()[ i], si->getRowUpper()[ i], 0);
4300 values, 0, numNonz - 1, indexes, 0, numNonz - 1, starts, 0, startsIdx);
4306 delete[] tmpConvexity;
4307 tmpConvexity = NULL;
4308 delete[] thetaPntTmp;
4310 delete[] thetaIndexTmp;
4311 thetaIndexTmp = NULL;
4319 ostringstream outStr;
4320 outStr << theString;
4322 return outStr.str();
std::string makeStringFromInt2(std::string theString, int theInt)
Implements a solve method for the Coin solvers.
virtual void buildSolverInstance()
The implementation of the corresponding virtual function.
OsiSolverInterface * osiSolver
osiSolver is the osi solver object – in this case clp, glpk, cbc, cplex, symphony or dylp
virtual void solve()
The implementation of the corresponding virtual function.
std::string sSolverName
sSolverName is the name of the Coin solver used, e.g.
OSInstance * osinstance
osinstance holds the problem instance in-memory as an OSInstance object
OSOption * osoption
osoption holds the solver options in-memory as an OSOption object
OSResult * osresult
osresult holds the solution or result of the model in-memory as an OSResult object
used for throwing exceptions.
std::string errormsg
errormsg is the error that is causing the exception to be thrown
class used to make it easy to read and write files.
std::string getFileAsString(const char *fname)
read a file and return contents as a string.
Variables * variables
variables is a pointer to a Variables object
Objectives * objectives
objectives is a pointer to a Objectives object
OSInstance * getSeparationInstance()
std::string m_initOSiLFile
double ** m_newColumnRowValue
virtual OSInstance * getInitialRestrictedMaster()
OSInstance* OSBearcatSolverXkij::getInitialRestrictedMaster( ){.
int * m_routeCapacity
the route capacity – bus seating limit this can vary with the route/hub
double ** m_newRowColumnValue
virtual void resetMaster(std::map< int, int > &inVars, OsiSolverInterface *si)
INPUT:
double qrouteCost(const int &k, const int &l, const double *c, int *kountVar)
kipp – document
OSInstance * m_osinstanceSeparation
int * m_upperBoundL
largest possible L-value on a route – this will be the minimum of m_routeCapacity and total demand
double ** m_rc
the reduced cost vector for each k, we asssume order is (l, i, j)
virtual void getBranchingCut(const double *thetaVar, const int numThetaVar, const std::map< int, int > &varConMap, int &varIdx, int &numNonz, int *&indexes, double *&values)
RETURN VALUES: varIdx – the variable number x_{ij} for branching numNonz – number of theta indexes in...
void calcReducedCost(const double *yA, const double *yB)
calculate the reduced costs c – input of the objective function costs yA – dual values on node assign...
void createVariableNames()
int m_minDemand
m_minDemand is the value of the minimum demand node – it is not the minimum demand that must be carri...
int * convexityRowIndex
conconvexityRowIndex holds the index of the convexity row that the theta columns are in.
void getOptions(OSOption *osoption)
void getCutsTheta(const double *thetaVar, const int numThetaVar, int &numNewRows, int *&numNonz, int **&colIdx, double **&values, double *&rowLB, double *&rowUB)
RETURN VALUES: int numNewRows – number of new rows generated int* numNonz – number of nonzeros in eac...
~OSBearcatSolverXkij()
Default Destructor.
int * m_routeMinPickup
the minimum number of students that we pickup on a route this can vary with the route/hub
OSBearcatSolverXkij()
Default Constructor.
void getInitialSolution()
generate an intitial feasible solution in theta space for the initial master
bool m_use1OPTstart
if m_use1OPTstart is true we use the option file to fix the nodes to hubs found by SK's 1OPT heuristi...
std::map< int, std::map< int, std::vector< int > > > m_initSolMap
the index on the outer map is on the solution number, the index on the inner map indexes the route nu...
int * m_separationIndexMap
m_separationIndexMap maps the variable index into the appropriate row in the separation problem for t...
void getCutsX(const double *xVar, const int numXVar, int &numNewRows, int *&numNonz, int **&colIdx, double **&values, double *&rowLB, double *&rowUB)
RETURN VALUES: int numNewRows – number of new rows generated int* numNonz – number of nonzeros in eac...
virtual void pauHana(std::vector< int > &m_zOptIndexes, int numNodes, int numColsGen)
int * m_lowerBoundL
smallest possible L-value on a route for now this will equal
ClpSimplex * m_separationClpModel
int * m_demand
m_demand is the vector of node demands
virtual void initializeDataStructures()
allocate memory and initialize arrays
int m_maxThetaNonz
m_maxMasterNonz is the maximumn number of nonzero elements we allow in the transformation matrix betw...
virtual void getColumns(const double *yA, const int numARows, const double *yB, const int numBRows, int &numNewColumns, int *&numNonz, double *&cost, int **&rowIdx, double **&values, double &lowerBound)
RETURN VALUES: int numNewColumns – number of new columns generated int* numNonz – number of nonzeros ...
int getBranchingVar(const double *theta, const int numThetaVar)
RETURN VALUES: return the integer index of a fractional x_{ij} variable.
int m_upperBoundLMax
largest possible L-value over all routes
double ** m_cost
the distance/cost vectors
double artVarCoeff
artVarCoeff is the coefficient of the artificial variable in the objective function
double zeroTol
we terminate column generation when the reduced costs are not smaller than zeroTol
OSDecompParam m_osDecompParam
share the parameters with the decomposition solver
int m_maxBmatrixCon
m_maxBmatrixCon is the maximum number of B matrix constraints it is the number of tour breaking const...
int m_numNodes
m_numNodes is the number of nodes (both pickup and hub) in the model
int m_maxMasterRows
m_maxMasterColumns is the maximumn number of rows we allow in the master, in this application it is e...
int m_numBmatrixCon
m_numBmatrixCon is the number of constraints in B - 1, we have the -1 because: m_pntBmatrix[ k] point...
int m_numHubs
m_numHubs is the number of hubs/routes
std::string * m_variableNames
std::set< std::pair< int, double > > intVarSet
intVarSet holds and std::pair where the first element is the index of an integer variable and the sec...
OSInstance * m_osinstanceMaster
int m_maxMasterColumns
m_maxMasterColumns is the maximumn number of columns we allow in the master
int m_maxBmatrixNonz
m_maxBmatrixNonz is the maximum number of nonzero elements in the B matrix constraints
The in-memory representation of an OSiL instance..
double * getConstraintLowerBounds()
Get constraint lower bounds.
double * getVariableUpperBounds()
Get variable upper bounds.
bool setConstraintNumber(int number)
set the number of constraints.
bool bVariablesModified
bVariablesModified is true if the variables data has been modified.
bool addVariable(int index, std::string name, double lowerBound, double upperBound, char type)
add a variable.
std::string printModel()
Print the infix representation of the problem.
bool addConstraint(int index, std::string name, double lowerBound, double upperBound, double constant)
add a constraint.
int getConstraintNumber()
Get number of constraints.
bool bConstraintsModified
bConstraintsModified is true if the constraints data has been modified.
int getLinearConstraintCoefficientNumber()
Get number of specified (usually nonzero) linear constraint coefficient values.
SparseMatrix * getLinearConstraintCoefficientsInRowMajor()
Get linear constraint coefficients in row major.
SparseMatrix * getLinearConstraintCoefficientsInColumnMajor()
Get linear constraint coefficients in column major.
double ** getDenseObjectiveCoefficients()
getDenseObjectiveCoefficients.
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
InstanceData * instanceData
A pointer to an InstanceData object.
double * getVariableLowerBounds()
Get variable lower bounds.
int getVariableNumber()
Get number of variables.
bool setInstanceDescription(std::string description)
set the instance description.
std::string * getVariableNames()
Get variable names.
bool addObjective(int index, std::string name, std::string maxOrMin, double constant, double weight, SparseVector *objectiveCoefficients)
add an objective.
bool setObjectiveNumber(int number)
set the number of objectives.
bool setVariableNumber(int number)
set the number of variables.
double * getConstraintUpperBounds()
Get constraint upper bounds.
std::vector< SolverOption * > getSolverOptions(std::string solver_name)
Get the options associated with a given solver.
std::string getSolutionStatusType(int solIdx)
Get the [i]th optimization solution status type, where i equals the given solution index.
std::vector< IndexValuePair * > getOptimalPrimalVariableValues(int solIdx)
Get one solution of optimal primal variable values.
double getObjValue(int solIdx, int objIdx)
Used to read an OSiL string.
OSInstance * readOSiL(const std::string &osil)
parse the OSiL model instance.
double value
value is the value of the objective function coefficient corresponding to the variable with index idx
ObjCoef ** coef
coef is pointer to an array of ObjCoef object pointers
Objective ** obj
coef is pointer to an array of ObjCoef object pointers
int * indexes
indexes holds an integer array of rowIdx (or colIdx) elements in coefMatrix (AMatrix).
int * starts
starts holds an integer array of start elements in coefMatrix (AMatrix), which points to the start of...
double * values
values holds a double array of value elements in coefMatrix (AMatrix), which contains nonzero element...
a sparse vector data structure
double * values
values holds a double array of nonzero values.
int * indexes
indexes holds an integer array of indexes whose corresponding values are nonzero.
double lb
lb corresponds to the optional attribute that holds the variable lower bound.
Variable ** var
Here we define a pointer to an array of var pointers.