Changeset 341


Ignore:
Timestamp:
Nov 11, 2009 11:33:42 PM (10 years ago)
Author:
bjarni
Message:

Move PPROBLEM handling to separate source file CoinProblem?.c and remove LoadNamesType? (was depreciated)

Location:
trunk/CoinMP/src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/CoinMP/src/CoinMP.cpp

    r339 r341  
    2121#include <memory.h>
    2222
     23#include "CoinProblem.h"
    2324#include "CoinResult.h"
    2425
     
    373374/************************************************************************/
    374375
    375 /*
    376 
    377 typedef struct {
    378                                 int SolutionStatus;
    379                                 char SolutionText[200];
    380 
    381                                 double ObjectValue;
    382                                 double MipBestBound;
    383                                 int IterCount;
    384                                 int MipNodeCount;
    385 
    386                                 double* ColActivity;
    387                                 double* ReducedCost;
    388                                 double* SlackValues;
    389                                 double* ShadowPrice;
    390 
    391                                 double* ObjLoRange;
    392                                 double* ObjUpRange;
    393                                 double* RhsLoRange;
    394                                 double* RhsUpRange;
    395 
    396                                 int* ColStatus;
    397                                 int* RowStatus;
    398                                 } RESULTINFO, *PRESULT;
    399 
    400 
    401 PRESULT coinCreateResultObject(void)
    402 {
    403         PRESULT pResult;
    404 
    405         pResult = (PRESULT)malloc(sizeof(RESULTINFO));
    406         memset(pResult, 0, sizeof(RESULTINFO));
    407 
    408         pResult->SolutionStatus = 0;
    409         strcpy(pResult->SolutionText, "");
    410 
    411         pResult->ObjectValue  = 0.0;
    412         pResult->MipBestBound = 0.0;
    413         pResult->IterCount    = 0;
    414         pResult->MipNodeCount = 0;
    415 
    416         pResult->ColActivity = NULL;
    417         pResult->ReducedCost = NULL;
    418         pResult->SlackValues = NULL;
    419         pResult->ShadowPrice = NULL;
    420 
    421         pResult->ObjLoRange = NULL;
    422         pResult->ObjUpRange = NULL;
    423         pResult->RhsLoRange = NULL;
    424         pResult->RhsUpRange = NULL;
    425 
    426         pResult->ColStatus = NULL;
    427         pResult->RowStatus = NULL;
    428 
    429         return pResult;
    430 }
    431 
    432 
    433 void coinClearResultObject(PRESULT pResult)
    434 {
    435         if (!pResult) {
    436                 return;
    437         }
    438         if (pResult->ColActivity)   free(pResult->ColActivity);
    439         if (pResult->ReducedCost)   free(pResult->ReducedCost);
    440         if (pResult->SlackValues)   free(pResult->SlackValues);
    441         if (pResult->ShadowPrice)   free(pResult->ShadowPrice);
    442 
    443         if (pResult->ObjLoRange)    free(pResult->ObjLoRange);
    444         if (pResult->ObjUpRange)    free(pResult->ObjUpRange);
    445         if (pResult->ObjUpRange)    free(pResult->ObjUpRange);
    446         if (pResult->RhsUpRange)    free(pResult->RhsUpRange);
    447 
    448         if (pResult->ColStatus)     free(pResult->ColStatus);
    449         if (pResult->ColStatus)     free(pResult->ColStatus);
    450         free(pResult);
    451 }
    452 */
     376
    453377typedef struct {
    454378                                ClpSimplex *clp;
     
    470394                                CglSimpleRounding *rounding;
    471395
    472                                 int LoadNamesType;
    473 
    474                                 char ProblemName[200];
    475 
    476                                 int ColCount;
    477                                 int RowCount;
    478                                 int NZCount;
    479                                 int RangeCount;
    480                                 int ObjectSense;
    481                                 double ObjectConst;
    482 
    483                                 int lenColNamesBuf;
    484                                 int lenRowNamesBuf;
    485                                 int lenObjNameBuf;
    486 
    487                                 double* ObjectCoeffs;
    488                                 double* RHSValues;
    489                                 double* RangeValues;
    490                                 char* RowType;
    491                                 int* MatrixBegin;
    492                                 int* MatrixCount;
    493                                 int* MatrixIndex;
    494                                 double* MatrixValues;
    495                                 double* LowerBounds;
    496                                 double* UpperBounds;
    497                                 char* ColNamesBuf;
    498                                 char* RowNamesBuf;
    499                                 char** ColNamesList;
    500                                 char** RowNamesList;
    501                                 char* ObjectName;
    502 
    503                                 double* InitValues;
    504 
    505                                 double* RowLower;
    506                                 double* RowUpper;
    507 
    508                                 char* ColType;
    509 
    510                                 int SolveAsMIP;
    511                                 int IntCount;
    512                                 int BinCount;
    513                                 int numInts;
    514                                 char* IsInt;
    515 
    516                                 int SosCount;
    517                                 int SosNZCount;
    518                                 int* SosType;
    519                                 int* SosPrior;
    520                                 int* SosBegin;
    521                                 int* SosIndex;
    522                                 double* SosRef;
    523 
    524                                 int PriorCount;
    525                                 int* PriorIndex;
    526                                 int* PriorValues;
    527                                 int* BranchDir;
    528 
     396                                PPROBLEM  pProblem;
    529397                                PRESULT   pResult;
    530                                 //int SolutionStatus;
    531                                 //char SolutionText[200];
    532398
    533399                                MSGLOGCALLBACK  MessageLogCallback;
     
    563429        pCoin->nodehandler = NULL;
    564430
    565         pCoin->LoadNamesType = SOLV_LOADNAMES_LIST;
    566 
    567         strcpy(pCoin->ProblemName, ProblemName);
    568 
    569         pCoin->ColCount    = 0;
    570         pCoin->RowCount    = 0;
    571         pCoin->NZCount     = 0;
    572         pCoin->RangeCount  = 0;
    573         pCoin->ObjectSense = 0;
    574         pCoin->ObjectConst = 0.0;
    575 
    576         pCoin->lenColNamesBuf   = 0;
    577         pCoin->lenRowNamesBuf   = 0;
    578         pCoin->lenObjNameBuf = 0;
    579 
    580         pCoin->ObjectCoeffs = NULL;
    581         pCoin->RHSValues    = NULL;
    582         pCoin->RangeValues  = NULL;
    583         pCoin->RowType      = NULL;
    584         pCoin->MatrixBegin  = NULL;
    585         pCoin->MatrixCount  = NULL;
    586         pCoin->MatrixIndex  = NULL;
    587         pCoin->MatrixValues = NULL;
    588         pCoin->LowerBounds  = NULL;
    589         pCoin->UpperBounds  = NULL;
    590         pCoin->ColNamesBuf  = NULL;
    591         pCoin->RowNamesBuf  = NULL;
    592         pCoin->ColNamesList = NULL;
    593         pCoin->RowNamesList = NULL;
    594         pCoin->ObjectName   = NULL;
    595 
    596         pCoin->InitValues       = NULL;
    597 
    598         pCoin->RowLower         = NULL;
    599         pCoin->RowUpper         = NULL;
    600 
    601         pCoin->ColType          = NULL;
    602 
    603         pCoin->SolveAsMIP       = 0;
    604         pCoin->IntCount         = 0;
    605         pCoin->BinCount         = 0;
    606         pCoin->numInts          = 0;
    607         pCoin->IsInt            = NULL;
    608 
    609         pCoin->SosCount         = 0;
    610         pCoin->SosNZCount       = 0;
    611         pCoin->SosType          = NULL;
    612         pCoin->SosPrior         = NULL;
    613         pCoin->SosBegin         = NULL;
    614         pCoin->SosIndex         = NULL;
    615         pCoin->SosRef           = NULL;
    616 
    617         pCoin->PriorCount       = 0;
    618         pCoin->PriorIndex       = NULL;
    619         pCoin->PriorValues      = NULL;
    620         pCoin->BranchDir        = NULL;
    621 
     431        pCoin->pProblem = coinCreateProblemObject();
    622432        pCoin->pResult = coinCreateResultObject();
    623         //pCoin->SolutionStatus = 0;
    624         //strcpy(pCoin->SolutionText, "");
     433
     434        coinSetProblemName(pCoin->pProblem, ProblemName);
    625435
    626436        pCoin->MessageLogCallback = NULL;
     
    632442
    633443
    634 int coinComputeRowLowerUpper(PCOIN pCoin, char* RowType, double* RHSValues, double* RangeValues)
     444
     445void coinCopyNamesList(PPROBLEM pProblem, PCOIN pCoin)
    635446{
    636447        int i;
    637         double RangeABS;
    638 
    639         if (!pCoin->RowLower || !pCoin->RowUpper) {
    640                 return 0;
    641         }
    642         if (!RowType) {
    643                 /* if NO RowType, we treat RHSValues as RowLower and RangeValues as RowUpper */
    644                 for (i = 0; i < pCoin->RowCount; i++) {
    645                         pCoin->RowLower[i] = RHSValues ? RHSValues[i] : -COIN_DBL_MAX;
    646                         pCoin->RowUpper[i] = RangeValues ? RangeValues[i] : COIN_DBL_MAX;
    647                 }
    648                 return 1;
    649         }
    650         for (i = 0; i < pCoin->RowCount; i++ ){
    651                 switch (RowType[i]) {
    652                         case 'L':
    653                                 pCoin->RowLower[i] = -COIN_DBL_MAX;
    654                                 pCoin->RowUpper[i] = RHSValues ? RHSValues[i] : COIN_DBL_MAX;
    655                                 break;
    656 
    657                         case 'G':
    658                                 pCoin->RowLower[i] = RHSValues ? RHSValues[i] : -COIN_DBL_MAX;
    659                                 pCoin->RowUpper[i] = COIN_DBL_MAX;
    660                                 break;
    661 
    662                         case 'E':
    663                                 pCoin->RowLower[i] = RHSValues ? RHSValues[i] : 0.0;
    664                                 pCoin->RowUpper[i] = RHSValues ? RHSValues[i] : 0.0;
    665                                 break;
    666 
    667                         case 'R':
    668                                 RangeABS = (RangeValues) ? ((RangeValues[i] >= 0.0) ? RangeValues[i] : -RangeValues[i]) : 0.0;
    669                                 pCoin->RowLower[i] = (RHSValues ? RHSValues[i] : -COIN_DBL_MAX) - RangeABS;
    670                                 pCoin->RowUpper[i] = RHSValues ? RHSValues[i] : COIN_DBL_MAX;
    671                                 break;
    672 
    673                         case 'N':
    674                                 pCoin->RowLower[i] = -COIN_DBL_MAX;
    675                                 pCoin->RowUpper[i] = COIN_DBL_MAX;
    676                                 break;
    677 
    678                         default:
    679                                 return 0;
    680                 }
    681         }
    682         return 1;
    683 }
    684 
    685 int coinGetLenNameBuf(const char* NameBuf, int Count)
    686 {
    687         int i, len;
    688         int lenBuf;
    689         const char* pName;
    690 
    691         lenBuf = 0;
    692         pName = &NameBuf[0];
    693         for (i = 0; i < Count; i++) {
    694                 len = (int)strlen(pName) + 1;
    695                 lenBuf += len;
    696                 pName = pName + len;
    697         }
    698         return lenBuf;
    699 }
    700 
    701 
    702 int coinGetLenNameBufType(char** NameList, int Count, int LoadNameType)
    703 {
    704         int i, len;
    705         int lenBuf;
    706         char* NameBuf;
    707 
    708         lenBuf = 0;
    709         switch (LoadNameType) {
    710 
    711                 case SOLV_LOADNAMES_BUFFER:
    712                         NameBuf = (char* )NameList;
    713                         lenBuf = coinGetLenNameBuf(NameBuf, Count);
    714                         break;
    715 
    716                 case SOLV_LOADNAMES_DEFAULT:
    717                 case SOLV_LOADNAMES_LIST:
    718                         for (i = 0; i < Count; i++) {
    719                                 len = (int)strlen(NameList[i]) + 1;
    720                                 lenBuf += len;
    721                         }
    722                         break;
    723 
    724                 default:
    725                         return 0;
    726         }
    727         return lenBuf;
    728 }
    729 
    730 
    731 int coinSetupNamesList(char** NamesList, char* NamesBuf, char** argNamesList, int Count, int LoadNamesType)
    732 {
    733         int i,k,len;
    734 
    735         if (!NamesList || !argNamesList || !NamesBuf || Count == 0) {
    736                 return 0;
    737         }
    738         k = 0;
    739         for (i = 0; i < Count; i++) {
    740                 NamesList[i] = &NamesBuf[k];
    741                 if (LoadNamesType == SOLV_LOADNAMES_LIST) {
    742                         strcpy(NamesList[i], argNamesList[i]);
    743                 }
    744                 len = (int)strlen(NamesList[i]) + 1;
    745                 k += len;
    746         }
    747         return 1;
    748 }
    749 
    750 
    751 
    752 void coinLoadNamesList(PCOIN pCoin, char** ColNamesList, char** RowNamesList, char* objectName)
    753 {
    754         int i;
    755448
    756449        /* Load names */
    757         if (RowNamesList || ColNamesList) {
     450        if (pProblem->RowNamesList || pProblem->ColNamesList) {
    758451                std::vector<std::string> rowNamesVect;
    759452                std::vector<std::string> colNamesVect;
    760                 rowNamesVect.reserve(pCoin->RowCount);
    761                 colNamesVect.reserve(pCoin->ColCount);
    762                 if (RowNamesList) {
    763                         for (i = 0; i < pCoin->RowCount; i++) {
    764                                 rowNamesVect.push_back(RowNamesList[i]);
     453                rowNamesVect.reserve(pProblem->RowCount);
     454                colNamesVect.reserve(pProblem->ColCount);
     455                if (pProblem->RowNamesList) {
     456                        for (i = 0; i < pProblem->RowCount; i++) {
     457                                rowNamesVect.push_back(pProblem->RowNamesList[i]);
    765458                        }
    766459                }
    767                 if (ColNamesList) {
    768                         for (i = 0; i < pCoin->ColCount; i++) {
    769                                 colNamesVect.push_back(ColNamesList[i]);
     460                if (pProblem->ColNamesList) {
     461                        for (i = 0; i < pProblem->ColCount; i++) {
     462                                colNamesVect.push_back(pProblem->ColNamesList[i]);
    770463                        }
    771464                }
     
    773466        }
    774467}
     468
    775469
    776470
     
    784478{
    785479        PCOIN pCoin = (PCOIN)hProb;
     480        PPROBLEM pProblem = pCoin->pProblem;
    786481
    787482        if (ColCount == 0) {
    788483                return SOLV_CALL_FAILED;
    789484        }
    790         pCoin->ColCount = ColCount;
    791         pCoin->RowCount = RowCount;
    792         pCoin->NZCount = NZCount;
    793         pCoin->RangeCount = RangeCount;
    794         pCoin->ObjectSense = ObjectSense;
    795         pCoin->ObjectConst = ObjectConst;
    796 
    797         if (ColNames)   pCoin->lenColNamesBuf = coinGetLenNameBufType(ColNames, ColCount, pCoin->LoadNamesType);
    798         if (RowNames)   pCoin->lenRowNamesBuf = coinGetLenNameBufType(RowNames, RowCount, pCoin->LoadNamesType);
    799         if (ObjectName) pCoin->lenObjNameBuf  = (int)strlen(ObjectName) + 1;
    800 
    801         if (ObjectCoeffs) pCoin->ObjectCoeffs = (double*) malloc(pCoin->ColCount     * sizeof(double));
    802         if (RHSValues)    pCoin->RHSValues    = (double*) malloc(pCoin->RowCount     * sizeof(double));
    803         if (RangeValues)  pCoin->RangeValues  = (double*) malloc(pCoin->RowCount     * sizeof(double));
    804         if (RowType)      pCoin->RowType      = (char*)   malloc(pCoin->RowCount     * sizeof(char));
    805         if (MatrixBegin)  pCoin->MatrixBegin  = (int*)    malloc((pCoin->ColCount+1) * sizeof(int));
    806         if (MatrixCount)  pCoin->MatrixCount  = (int*)    malloc(pCoin->ColCount     * sizeof(int));
    807         if (MatrixIndex)  pCoin->MatrixIndex  = (int*)    malloc(pCoin->NZCount      * sizeof(int));
    808         if (MatrixValues) pCoin->MatrixValues = (double*) malloc(pCoin->NZCount      * sizeof(double));
    809         if (LowerBounds)  pCoin->LowerBounds  = (double*) malloc(pCoin->ColCount     * sizeof(double));
    810         if (UpperBounds)  pCoin->UpperBounds  = (double*) malloc(pCoin->ColCount     * sizeof(double));
    811         if (ColNames)     pCoin->ColNamesList = (char**)  malloc(pCoin->ColCount     * sizeof(char* ));
    812         if (RowNames)     pCoin->RowNamesList = (char**)  malloc(pCoin->RowCount     * sizeof(char* ));
    813         if (ColNames)     pCoin->ColNamesBuf  = (char*)   malloc(pCoin->lenColNamesBuf * sizeof(char));
    814         if (RowNames)     pCoin->RowNamesBuf  = (char*)   malloc(pCoin->lenRowNamesBuf * sizeof(char));
    815         if (ObjectName)   pCoin->ObjectName   = (char*)   malloc(pCoin->lenObjNameBuf  * sizeof(char));
    816 
    817         if (pCoin->RowCount > 0) {
    818                 pCoin->RowLower = (double* )malloc(pCoin->RowCount*sizeof(double));
    819                 pCoin->RowUpper = (double* )malloc(pCoin->RowCount*sizeof(double));
    820                 if (!pCoin->RowLower || !pCoin->RowUpper) {
     485        pProblem->ColCount = ColCount;
     486        pProblem->RowCount = RowCount;
     487        pProblem->NZCount = NZCount;
     488        pProblem->RangeCount = RangeCount;
     489        pProblem->ObjectSense = ObjectSense;
     490        pProblem->ObjectConst = ObjectConst;
     491
     492        if (ColNames)   pProblem->lenColNamesBuf = coinGetLenNameListBuf(ColNames, ColCount);
     493        if (RowNames)   pProblem->lenRowNamesBuf = coinGetLenNameListBuf(RowNames, RowCount);
     494        if (ObjectName) pProblem->lenObjNameBuf  = (int)strlen(ObjectName) + 1;
     495
     496        if (ObjectCoeffs) pProblem->ObjectCoeffs = (double*) malloc(pProblem->ColCount     * sizeof(double));
     497        if (RHSValues)    pProblem->RHSValues    = (double*) malloc(pProblem->RowCount     * sizeof(double));
     498        if (RangeValues)  pProblem->RangeValues  = (double*) malloc(pProblem->RowCount     * sizeof(double));
     499        if (RowType)      pProblem->RowType      = (char*)   malloc(pProblem->RowCount     * sizeof(char));
     500        if (MatrixBegin)  pProblem->MatrixBegin  = (int*)    malloc((pProblem->ColCount+1) * sizeof(int));
     501        if (MatrixCount)  pProblem->MatrixCount  = (int*)    malloc(pProblem->ColCount     * sizeof(int));
     502        if (MatrixIndex)  pProblem->MatrixIndex  = (int*)    malloc(pProblem->NZCount      * sizeof(int));
     503        if (MatrixValues) pProblem->MatrixValues = (double*) malloc(pProblem->NZCount      * sizeof(double));
     504        if (LowerBounds)  pProblem->LowerBounds  = (double*) malloc(pProblem->ColCount     * sizeof(double));
     505        if (UpperBounds)  pProblem->UpperBounds  = (double*) malloc(pProblem->ColCount     * sizeof(double));
     506        if (ColNames)     pProblem->ColNamesList = (char**)  malloc(pProblem->ColCount     * sizeof(char* ));
     507        if (RowNames)     pProblem->RowNamesList = (char**)  malloc(pProblem->RowCount     * sizeof(char* ));
     508        if (ColNames)     pProblem->ColNamesBuf  = (char*)   malloc(pProblem->lenColNamesBuf * sizeof(char));
     509        if (RowNames)     pProblem->RowNamesBuf  = (char*)   malloc(pProblem->lenRowNamesBuf * sizeof(char));
     510        if (ObjectName)   pProblem->ObjectName   = (char*)   malloc(pProblem->lenObjNameBuf  * sizeof(char));
     511
     512        if (pProblem->RowCount > 0) {
     513                pProblem->RowLower = (double* )malloc(pProblem->RowCount*sizeof(double));
     514                pProblem->RowUpper = (double* )malloc(pProblem->RowCount*sizeof(double));
     515                if (!pProblem->RowLower || !pProblem->RowUpper) {
    821516                        return SOLV_CALL_FAILED;
    822517                }
    823518        }
    824519
    825         if (pCoin->ObjectCoeffs) memcpy(pCoin->ObjectCoeffs, ObjectCoeffs, pCoin->ColCount     * sizeof(double));
    826         if (pCoin->RHSValues)    memcpy(pCoin->RHSValues,    RHSValues,    pCoin->RowCount     * sizeof(double));
    827         if (pCoin->RangeValues)  memcpy(pCoin->RangeValues,  RangeValues,  pCoin->RowCount     * sizeof(double));
    828         if (pCoin->RowType)      memcpy(pCoin->RowType,      RowType,      pCoin->RowCount     * sizeof(char));
    829         if (pCoin->MatrixBegin)  memcpy(pCoin->MatrixBegin,  MatrixBegin,  (pCoin->ColCount+1) * sizeof(int));
    830         if (pCoin->MatrixCount)  memcpy(pCoin->MatrixCount,  MatrixCount,  pCoin->ColCount     * sizeof(int));
    831         if (pCoin->MatrixIndex)  memcpy(pCoin->MatrixIndex,  MatrixIndex,  pCoin->NZCount      * sizeof(int));
    832         if (pCoin->MatrixValues) memcpy(pCoin->MatrixValues, MatrixValues, pCoin->NZCount      * sizeof(double));
    833         if (pCoin->LowerBounds)  memcpy(pCoin->LowerBounds,  LowerBounds,  pCoin->ColCount     * sizeof(double));
    834         if (pCoin->UpperBounds)  memcpy(pCoin->UpperBounds,  UpperBounds,  pCoin->ColCount     * sizeof(double));
    835         if (pCoin->ObjectName)   memcpy(pCoin->ObjectName,   ObjectName,   pCoin->lenObjNameBuf  * sizeof(char));
    836 
    837         if (pCoin->LoadNamesType == SOLV_LOADNAMES_BUFFER) {
    838                 if (pCoin->ColNamesBuf)  memcpy(pCoin->ColNamesBuf,  (char* )ColNames,     pCoin->lenColNamesBuf * sizeof(char));
    839                 if (pCoin->RowNamesBuf)  memcpy(pCoin->RowNamesBuf,  (char* )RowNames,     pCoin->lenRowNamesBuf * sizeof(char));
    840         }
    841         coinSetupNamesList(pCoin->ColNamesList, pCoin->ColNamesBuf, ColNames, ColCount, pCoin->LoadNamesType);
    842         coinSetupNamesList(pCoin->RowNamesList, pCoin->RowNamesBuf, RowNames, RowCount, pCoin->LoadNamesType);
     520        if (pProblem->ObjectCoeffs) memcpy(pProblem->ObjectCoeffs, ObjectCoeffs, pProblem->ColCount     * sizeof(double));
     521        if (pProblem->RHSValues)    memcpy(pProblem->RHSValues,    RHSValues,    pProblem->RowCount     * sizeof(double));
     522        if (pProblem->RangeValues)  memcpy(pProblem->RangeValues,  RangeValues,  pProblem->RowCount     * sizeof(double));
     523        if (pProblem->RowType)      memcpy(pProblem->RowType,      RowType,      pProblem->RowCount     * sizeof(char));
     524        if (pProblem->MatrixBegin)  memcpy(pProblem->MatrixBegin,  MatrixBegin,  (pProblem->ColCount+1) * sizeof(int));
     525        if (pProblem->MatrixCount)  memcpy(pProblem->MatrixCount,  MatrixCount,  pProblem->ColCount     * sizeof(int));
     526        if (pProblem->MatrixIndex)  memcpy(pProblem->MatrixIndex,  MatrixIndex,  pProblem->NZCount      * sizeof(int));
     527        if (pProblem->MatrixValues) memcpy(pProblem->MatrixValues, MatrixValues, pProblem->NZCount      * sizeof(double));
     528        if (pProblem->LowerBounds)  memcpy(pProblem->LowerBounds,  LowerBounds,  pProblem->ColCount     * sizeof(double));
     529        if (pProblem->UpperBounds)  memcpy(pProblem->UpperBounds,  UpperBounds,  pProblem->ColCount     * sizeof(double));
     530        if (pProblem->ObjectName)   memcpy(pProblem->ObjectName,   ObjectName,   pProblem->lenObjNameBuf  * sizeof(char));
     531
     532        coinCopyNamesList(pProblem->ColNamesList, pProblem->ColNamesBuf, ColNames, ColCount);
     533        coinCopyNamesList(pProblem->RowNamesList, pProblem->RowNamesBuf, RowNames, RowCount);
    843534
    844535        pCoin->clp->setOptimizationDirection(ObjectSense);
    845536
    846         if (!coinComputeRowLowerUpper(pCoin, RowType, RHSValues, RangeValues)) {
     537        if (!coinComputeRowLowerUpper(pProblem, COIN_DBL_MAX)) {
    847538                return SOLV_CALL_FAILED;
    848539        }
    849540
    850541        pCoin->clp->loadProblem(ColCount, RowCount, MatrixBegin, MatrixIndex, MatrixValues,
    851                                                         LowerBounds, UpperBounds, ObjectCoeffs, pCoin->RowLower, pCoin->RowUpper);
    852 
    853         coinLoadNamesList(pCoin, pCoin->ColNamesList, pCoin->RowNamesList, ObjectName);
     542                                                        LowerBounds, UpperBounds, ObjectCoeffs, pProblem->RowLower, pProblem->RowUpper);
     543
     544        coinCopyNamesList(pProblem, pCoin);
    854545
    855546        return SOLV_CALL_SUCCESS;
     
    864555                                double* RHSValues, double* RangeValues, int* MatrixBegin,
    865556                                int* MatrixCount, int* MatrixIndex, double* MatrixValues,
    866                                 char* ColNames, char* RowNames, char* ObjectName)
    867 {
    868         PCOIN pCoin = (PCOIN)hProb;
    869         int StoreLoadNamesType;
     557                                char* ColNamesBuf, char* RowNamesBuf, char* ObjectName)
     558{
     559        PCOIN pCoin = (PCOIN)hProb;
     560        char** ColNamesList;
     561        char** RowNamesList;
    870562        int result;
    871563
    872         StoreLoadNamesType = pCoin->LoadNamesType;
    873         pCoin->LoadNamesType = SOLV_LOADNAMES_BUFFER;
     564        ColNamesList = (char**)malloc(ColCount * sizeof(char*));
     565        RowNamesList = (char**)malloc(RowCount * sizeof(char*));
     566        coinSetupNamesList(ColNamesList, ColNamesBuf, ColCount);
     567        coinSetupNamesList(RowNamesList, RowNamesBuf, RowCount);
    874568        result = CoinLoadProblem(hProb, ColCount, RowCount, NZCount, RangeCount,
    875569                                ObjectSense, ObjectConst, ObjectCoeffs, LowerBounds, UpperBounds, RowType,
    876570                                RHSValues, RangeValues, MatrixBegin, MatrixCount, MatrixIndex, MatrixValues,
    877                                 (char**)ColNames, (char**)RowNames, ObjectName);
    878         pCoin->LoadNamesType = StoreLoadNamesType;
     571                                ColNamesList, RowNamesList, ObjectName);
     572        if (ColNamesList) free(ColNamesList);
     573        if (RowNamesList) free(RowNamesList);
    879574        return result;
    880575}
     
    884579{
    885580        PCOIN pCoin = (PCOIN)hProb;
    886 
    887         if (InitValues)   pCoin->InitValues   = (double* ) malloc(pCoin->ColCount     * sizeof(double));
    888 
    889         if (pCoin->InitValues)   memcpy(pCoin->InitValues,   InitValues,   pCoin->ColCount     * sizeof(double));
     581        PPROBLEM pProblem = pCoin->pProblem;
     582
     583        if (InitValues)   pProblem->InitValues   = (double* ) malloc(pProblem->ColCount     * sizeof(double));
     584
     585        if (pProblem->InitValues)   memcpy(pProblem->InitValues,   InitValues,   pProblem->ColCount     * sizeof(double));
    890586        return SOLV_CALL_SUCCESS;
    891587}
     
    895591{   
    896592        PCOIN pCoin = (PCOIN)hProb;
     593        PPROBLEM pProblem = pCoin->pProblem;
    897594        int i;
    898595
    899         if (pCoin->ColCount == 0) {
     596        if (pProblem->ColCount == 0) {
    900597                return SOLV_CALL_FAILED;
    901598        }
    902599        if (ColType) {
    903                 pCoin->ColType = (char* )malloc(pCoin->ColCount * sizeof(char));
    904                 if (!pCoin->ColType) {
     600                pProblem->ColType = (char* )malloc(pProblem->ColCount * sizeof(char));
     601                if (!pProblem->ColType) {
    905602                        return SOLV_CALL_FAILED;
    906603                }
    907                 memcpy(pCoin->ColType, ColType, pCoin->ColCount * sizeof(char));
    908         }
    909         pCoin->IsInt = (char* )malloc(pCoin->ColCount*sizeof(char));
    910         if (!pCoin->IsInt) {
     604                memcpy(pProblem->ColType, ColType, pProblem->ColCount * sizeof(char));
     605        }
     606        pProblem->IsInt = (char* )malloc(pProblem->ColCount*sizeof(char));
     607        if (!pProblem->IsInt) {
    911608                return SOLV_CALL_FAILED;
    912609        }
    913         for (i = 0; i < pCoin->ColCount; i++ ) {
     610        for (i = 0; i < pProblem->ColCount; i++ ) {
    914611                switch (ColType[i]) {
    915612                        case 'B':
    916                                 pCoin->BinCount++;
    917                                 pCoin->IsInt[i] = 1;
    918                                 pCoin->SolveAsMIP = 1;
     613                                pProblem->BinCount++;
     614                                pProblem->IsInt[i] = 1;
     615                                pProblem->SolveAsMIP = 1;
    919616                                break;
    920617
    921618                        case 'I':
    922                                 pCoin->IntCount++;
    923                                 pCoin->IsInt[i] = 1;
    924                                 pCoin->SolveAsMIP = 1;
     619                                pProblem->IntCount++;
     620                                pProblem->IsInt[i] = 1;
     621                                pProblem->SolveAsMIP = 1;
    925622                                break;
    926623
    927624                        case 'C':
    928                                 pCoin->IsInt[i] = 0;
     625                                pProblem->IsInt[i] = 0;
    929626                                break;
    930627
    931628                        default:
    932                                 pCoin->IsInt[i] = 0;
     629                                pProblem->IsInt[i] = 0;
    933630                                return SOLV_CALL_FAILED;
    934631                }
    935632        }
    936         if (pCoin->SolveAsMIP) {
     633        if (pProblem->SolveAsMIP) {
    937634                if (!pCoin->cbc) {
    938635                        pCoin->cbc = new CbcModel(*pCoin->osi);
    939636                }
    940                 for (i = 0; i < pCoin->ColCount; i++) {
    941                         if (pCoin->IsInt[i]) {
     637                for (i = 0; i < pProblem->ColCount; i++) {
     638                        if (pProblem->IsInt[i]) {
    942639                                pCoin->cbc->solver()->setInteger(i);
    943640                                pCoin->osi->setInteger(i);
    944                                 pCoin->numInts++;
     641                                pProblem->numInts++;
    945642                        }
    946643                }
     
    963660{
    964661        PCOIN pCoin = (PCOIN)hProb;
     662        PPROBLEM pProblem = pCoin->pProblem;
    965663        int *priorVar;
    966664        int *priorCbc;
    967665        int i,k;
    968666
    969         pCoin->PriorCount = PriorCount;
    970         if (PriorIndex)  pCoin->PriorIndex  = (int* )malloc(PriorCount * sizeof(int));
    971         if (PriorValues) pCoin->PriorValues = (int* )malloc(PriorCount * sizeof(int));
    972         if (BranchDir)   pCoin->BranchDir   = (int* )malloc(PriorCount * sizeof(int));
    973         if (pCoin->PriorIndex)  memcpy(pCoin->PriorIndex,  PriorIndex,  PriorCount * sizeof(int));
    974         if (pCoin->PriorValues) memcpy(pCoin->PriorValues, PriorValues, PriorCount * sizeof(int));
    975         if (pCoin->BranchDir)   memcpy(pCoin->BranchDir,   BranchDir,   PriorCount * sizeof(int));
    976 
    977         if (!pCoin->SolveAsMIP) {
     667        pProblem->PriorCount = PriorCount;
     668        if (PriorIndex)  pProblem->PriorIndex  = (int* )malloc(PriorCount * sizeof(int));
     669        if (PriorValues) pProblem->PriorValues = (int* )malloc(PriorCount * sizeof(int));
     670        if (BranchDir)   pProblem->BranchDir   = (int* )malloc(PriorCount * sizeof(int));
     671        if (pProblem->PriorIndex)  memcpy(pProblem->PriorIndex,  PriorIndex,  PriorCount * sizeof(int));
     672        if (pProblem->PriorValues) memcpy(pProblem->PriorValues, PriorValues, PriorCount * sizeof(int));
     673        if (pProblem->BranchDir)   memcpy(pProblem->BranchDir,   BranchDir,   PriorCount * sizeof(int));
     674
     675        if (!pProblem->SolveAsMIP) {
    978676                return SOLV_CALL_FAILED;
    979677        }
    980         if (!pCoin->IsInt) {
     678        if (!pProblem->IsInt) {
    981679                return SOLV_CALL_FAILED;
    982680        }
    983681
    984         priorVar = (int *)malloc(pCoin->ColCount * sizeof(int));
     682        priorVar = (int *)malloc(pProblem->ColCount * sizeof(int));
    985683        if (!priorVar) {
    986684                return SOLV_CALL_FAILED;
    987685        }
    988686        //reset the priorVar
    989         for (i = 0; i < pCoin->ColCount; i++) {
     687        for (i = 0; i < pProblem->ColCount; i++) {
    990688                priorVar[i] = 1000;
    991689        }
    992690        for (i = 0; i < PriorCount; i++) {
    993                 if ((PriorIndex[i] < 0) || (PriorIndex[i] >= pCoin->ColCount)) {
     691                if ((PriorIndex[i] < 0) || (PriorIndex[i] >= pProblem->ColCount)) {
    994692                        free(priorVar);
    995693                        return SOLV_CALL_FAILED;
     
    998696        }
    999697        //Create an array to give to cbc
    1000         priorCbc = (int *)malloc(pCoin->numInts * sizeof(int));
     698        priorCbc = (int *)malloc(pProblem->numInts * sizeof(int));
    1001699        if (!priorCbc) {
    1002700                free(priorVar);
     
    1004702        }
    1005703        k = 0;
    1006         for (i = 0; i < pCoin->ColCount; i++) {
    1007                 if (pCoin->IsInt[i]) {
     704        for (i = 0; i < pProblem->ColCount; i++) {
     705                if (pProblem->IsInt[i]) {
    1008706                        priorCbc[k++] = priorVar[i];
    1009707                }
     
    1027725{
    1028726        PCOIN pCoin = (PCOIN)hProb;
     727        PPROBLEM pProblem = pCoin->pProblem;
    1029728        int sos, count;
    1030729        int* which;
     
    1034733                return SOLV_CALL_FAILED;
    1035734        }
    1036         pCoin->SosCount = SosCount;
    1037         pCoin->SosNZCount = SosNZCount;
    1038 
    1039         if (SosType)  pCoin->SosType  = (int* )malloc(SosCount     * sizeof(int));
    1040         if (SosPrior) pCoin->SosPrior = (int* )malloc(SosCount     * sizeof(int));
    1041         if (SosBegin) pCoin->SosBegin = (int* )malloc((SosCount+1) * sizeof(int));
    1042         if (SosIndex) pCoin->SosIndex = (int* )malloc(SosNZCount   * sizeof(int));
    1043         if (SosRef)   pCoin->SosRef   = (double* )malloc(SosNZCount* sizeof(double));
    1044 
    1045         if (pCoin->SosType)  memcpy(pCoin->SosType,  SosType,  SosCount     * sizeof(int));
    1046         if (pCoin->SosPrior) memcpy(pCoin->SosPrior, SosPrior, SosCount     * sizeof(int));
    1047         if (pCoin->SosBegin) memcpy(pCoin->SosBegin, SosBegin, (SosCount+1) * sizeof(int));
    1048         if (pCoin->SosIndex) memcpy(pCoin->SosIndex, SosIndex, SosNZCount   * sizeof(int));
    1049         if (pCoin->SosRef)   memcpy(pCoin->SosRef,   SosRef,   SosNZCount   * sizeof(double));
    1050 
    1051         pCoin->SolveAsMIP = 1;
     735        pProblem->SosCount = SosCount;
     736        pProblem->SosNZCount = SosNZCount;
     737
     738        if (SosType)  pProblem->SosType  = (int* )malloc(SosCount     * sizeof(int));
     739        if (SosPrior) pProblem->SosPrior = (int* )malloc(SosCount     * sizeof(int));
     740        if (SosBegin) pProblem->SosBegin = (int* )malloc((SosCount+1) * sizeof(int));
     741        if (SosIndex) pProblem->SosIndex = (int* )malloc(SosNZCount   * sizeof(int));
     742        if (SosRef)   pProblem->SosRef   = (double* )malloc(SosNZCount* sizeof(double));
     743
     744        if (pProblem->SosType)  memcpy(pProblem->SosType,  SosType,  SosCount     * sizeof(int));
     745        if (pProblem->SosPrior) memcpy(pProblem->SosPrior, SosPrior, SosCount     * sizeof(int));
     746        if (pProblem->SosBegin) memcpy(pProblem->SosBegin, SosBegin, (SosCount+1) * sizeof(int));
     747        if (pProblem->SosIndex) memcpy(pProblem->SosIndex, SosIndex, SosNZCount   * sizeof(int));
     748        if (pProblem->SosRef)   memcpy(pProblem->SosRef,   SosRef,   SosNZCount   * sizeof(double));
     749
     750        pProblem->SolveAsMIP = 1;
    1052751        if (!pCoin->cbc) {
    1053752                pCoin->cbc = new CbcModel(*pCoin->osi);
     
    1102801                delete pCoin->cbc;
    1103802
    1104                 if (pCoin->ObjectCoeffs) free(pCoin->ObjectCoeffs);
    1105                 if (pCoin->RHSValues)    free(pCoin->RHSValues);
    1106                 if (pCoin->RangeValues)  free(pCoin->RangeValues);
    1107                 if (pCoin->RowType)      free(pCoin->RowType);
    1108                 if (pCoin->MatrixBegin)  free(pCoin->MatrixBegin);
    1109                 if (pCoin->MatrixCount)  free(pCoin->MatrixCount);
    1110                 if (pCoin->MatrixIndex)  free(pCoin->MatrixIndex);
    1111                 if (pCoin->MatrixValues) free(pCoin->MatrixValues);
    1112                 if (pCoin->LowerBounds)  free(pCoin->LowerBounds);
    1113                 if (pCoin->UpperBounds)  free(pCoin->UpperBounds);
    1114 
    1115                 if (pCoin->ColNamesBuf)  free(pCoin->ColNamesBuf);
    1116                 if (pCoin->RowNamesBuf)  free(pCoin->RowNamesBuf);
    1117                 if (pCoin->ColNamesList) free(pCoin->ColNamesList);
    1118                 if (pCoin->RowNamesList) free(pCoin->RowNamesList);
    1119                 if (pCoin->ObjectName)   free(pCoin->ObjectName);
    1120 
    1121                 if (pCoin->InitValues)   free(pCoin->InitValues);
    1122 
    1123                 if (pCoin->RowLower)     free(pCoin->RowLower);
    1124                 if (pCoin->RowUpper)     free(pCoin->RowUpper);
    1125 
    1126                 if (pCoin->ColType)              free(pCoin->ColType);
    1127                 if (pCoin->IsInt)                free(pCoin->IsInt);
    1128 
    1129                 if (pCoin->SosType)              free(pCoin->SosType);
    1130                 if (pCoin->SosPrior)     free(pCoin->SosPrior);
    1131                 if (pCoin->SosBegin)     free(pCoin->SosBegin);
    1132                 if (pCoin->SosIndex)     free(pCoin->SosIndex);
    1133                 if (pCoin->SosRef)               free(pCoin->SosRef);
    1134 
    1135                 if (pCoin->PriorIndex)   free(pCoin->PriorIndex);
    1136                 if (pCoin->PriorValues)  free(pCoin->PriorValues);
    1137                 if (pCoin->BranchDir)    free(pCoin->BranchDir);
     803                coinClearProblemObject(pCoin->pProblem);
    1138804                coinClearResultObject(pCoin->pResult);
    1139805        }
     
    1151817{
    1152818        PCOIN pCoin = (PCOIN)hProb;
     819        PPROBLEM pProblem = pCoin->pProblem;
    1153820        int i;
    1154821
    1155         if (pCoin->ColCount == 0) {
     822        if (pProblem->ColCount == 0) {
    1156823                return SOLV_CHECK_COLCOUNT;
    1157824        }
    1158         if ((pCoin->RowCount < 0) ||
    1159                 (pCoin->NZCount < 0) ||
    1160                 (pCoin->RangeCount < 0)) {
     825        if ((pProblem->RowCount < 0) ||
     826                (pProblem->NZCount < 0) ||
     827                (pProblem->RangeCount < 0)) {
    1161828                return SOLV_CHECK_ROWCOUNT;
    1162829        }
    1163         if ((pCoin->RangeCount > pCoin->RowCount)) {
     830        if ((pProblem->RangeCount > pProblem->RowCount)) {
    1164831                return SOLV_CHECK_RANGECOUNT;
    1165832        }
    1166         if ((pCoin->ObjectSense < -1) ||
    1167                 (pCoin->ObjectSense > 1)) {
     833        if ((pProblem->ObjectSense < -1) ||
     834                (pProblem->ObjectSense > 1)) {
    1168835                return SOLV_CHECK_OBJSENSE;
    1169836        }
    1170         if (pCoin->RowType && (pCoin->RowCount > 0)) {
    1171                 for (i = 0; i < pCoin->RowCount; i++) {
    1172                         if ((pCoin->RowType[i] != 'L') &&
    1173                                 (pCoin->RowType[i] != 'E') &&
    1174                                 (pCoin->RowType[i] != 'G') &&
    1175                                 (pCoin->RowType[i] != 'R') &&
    1176                                 (pCoin->RowType[i] != 'N')) {
     837        if (pProblem->RowType && (pProblem->RowCount > 0)) {
     838                for (i = 0; i < pProblem->RowCount; i++) {
     839                        if ((pProblem->RowType[i] != 'L') &&
     840                                (pProblem->RowType[i] != 'E') &&
     841                                (pProblem->RowType[i] != 'G') &&
     842                                (pProblem->RowType[i] != 'R') &&
     843                                (pProblem->RowType[i] != 'N')) {
    1177844                                return SOLV_CHECK_ROWTYPE;
    1178845                        }
    1179846                }
    1180847        }
    1181         if (pCoin->NZCount > 0) {
    1182                 for (i = 0; i < pCoin->ColCount; i++) {
    1183                         if (pCoin->MatrixBegin[i] < 0) {
     848        if (pProblem->NZCount > 0) {
     849                for (i = 0; i < pProblem->ColCount; i++) {
     850                        if (pProblem->MatrixBegin[i] < 0) {
    1184851                                return SOLV_CHECK_MATBEGIN;
    1185852                        }
    1186                         if (pCoin->MatrixCount[i] < 0) {
     853                        if (pProblem->MatrixCount[i] < 0) {
    1187854                                return SOLV_CHECK_MATCOUNT;
    1188855                        }
    1189                         if (pCoin->MatrixBegin[i+1] - pCoin->MatrixBegin[i] != pCoin->MatrixCount[i]) {
     856                        if (pProblem->MatrixBegin[i+1] - pProblem->MatrixBegin[i] != pProblem->MatrixCount[i]) {
    1190857                                return SOLV_CHECK_MATBEGCNT;
    1191858                        }
    1192859                }
    1193                 if (pCoin->MatrixBegin[pCoin->ColCount] != pCoin->NZCount) {
    1194                         return 100+pCoin->MatrixBegin[pCoin->ColCount];
    1195                 }
    1196                 for (i = 0; i < pCoin->NZCount; i++) {
    1197                         if (pCoin->MatrixIndex[i] < 0) {
     860                if (pProblem->MatrixBegin[pProblem->ColCount] != pProblem->NZCount) {
     861                        return 100+pProblem->MatrixBegin[pProblem->ColCount];
     862                }
     863                for (i = 0; i < pProblem->NZCount; i++) {
     864                        if (pProblem->MatrixIndex[i] < 0) {
    1198865                                return SOLV_CHECK_MATINDEX;
    1199866                        }
    1200                         if (pCoin->MatrixIndex[i] >= pCoin->RowCount) {
     867                        if (pProblem->MatrixIndex[i] >= pProblem->RowCount) {
    1201868                                return SOLV_CHECK_MATINDEXROW;
    1202869                        }
    1203870                }
    1204871        }
    1205         if (pCoin->LowerBounds && pCoin->UpperBounds) {
    1206                 for (i = 0; i < pCoin->ColCount; i++) {
    1207                         if (pCoin->LowerBounds[i] > pCoin->UpperBounds[i]) {
     872        if (pProblem->LowerBounds && pProblem->UpperBounds) {
     873                for (i = 0; i < pProblem->ColCount; i++) {
     874                        if (pProblem->LowerBounds[i] > pProblem->UpperBounds[i]) {
    1208875                                return SOLV_CHECK_BOUNDS;
    1209876                        }
    1210877                }
    1211878        }
    1212         if (pCoin->ColType) {
    1213                 for (i = 0; i < pCoin->ColCount; i++) {
    1214                         if ((pCoin->ColType[i] != 'C') &&
    1215                                 (pCoin->ColType[i] != 'B') &&
    1216                                 (pCoin->ColType[i] != 'I')) {
     879        if (pProblem->ColType) {
     880                for (i = 0; i < pProblem->ColCount; i++) {
     881                        if ((pProblem->ColType[i] != 'C') &&
     882                                (pProblem->ColType[i] != 'B') &&
     883                                (pProblem->ColType[i] != 'I')) {
    1217884                                return SOLV_CHECK_COLTYPE;
    1218885                        }
    1219886                }
    1220887        }
    1221         if (pCoin->ColNamesBuf) {
    1222                 if (pCoin->lenColNamesBuf <= 0) {
     888        if (pProblem->ColNamesBuf) {
     889                if (pProblem->lenColNamesBuf <= 0) {
    1223890                        return SOLV_CHECK_COLNAMES;
    1224891                }
    1225                 if (pCoin->lenColNamesBuf > pCoin->ColCount * CHECK_MAXNAMELEN) {
     892                if (pProblem->lenColNamesBuf > pProblem->ColCount * CHECK_MAXNAMELEN) {
    1226893                        return SOLV_CHECK_COLNAMESLEN;
    1227894                }
    1228895        }
    1229         if (pCoin->RowNamesBuf) {
    1230                 if (pCoin->lenRowNamesBuf <= 0) {
     896        if (pProblem->RowNamesBuf) {
     897                if (pProblem->lenRowNamesBuf <= 0) {
    1231898                        return SOLV_CHECK_ROWNAMES;
    1232899                }
    1233                 if (pCoin->lenRowNamesBuf > pCoin->RowCount * CHECK_MAXNAMELEN) {
     900                if (pProblem->lenRowNamesBuf > pProblem->RowCount * CHECK_MAXNAMELEN) {
    1234901                        return SOLV_CHECK_ROWNAMSLEN;
    1235902                }
     
    1240907
    1241908
    1242 SOLVAPI int SOLVCALL CoinSetLoadNamesType(HPROB hProb, int LoadNamesType)
    1243 {
    1244         PCOIN pCoin = (PCOIN)hProb;
    1245 
    1246         if ((LoadNamesType < SOLV_LOADNAMES_DEFAULT) && 
    1247                 (LoadNamesType > SOLV_LOADNAMES_BUFFER)) {
    1248                 return SOLV_CALL_FAILED;
    1249         }
    1250         if (LoadNamesType == SOLV_LOADNAMES_DEFAULT)
    1251                 pCoin->LoadNamesType = SOLV_LOADNAMES_LIST;
    1252         else {
    1253                 pCoin->LoadNamesType = LoadNamesType;
    1254         }
    1255         return SOLV_CALL_SUCCESS;
    1256 }
    1257 
    1258 
    1259 
    1260909/************************************************************************/
    1261910/*  Problem Queries                                                     */
     
    1267916        PCOIN pCoin = (PCOIN)hProb;
    1268917
    1269         return pCoin->ProblemName;
     918        return pCoin->pProblem->ProblemName;
    1270919}
    1271920
     
    1284933        PCOIN pCoin = (PCOIN)hProb;
    1285934
    1286         return pCoin->ColCount;
     935        return pCoin->pProblem->ColCount;
    1287936}
    1288937
     
    1292941        PCOIN pCoin = (PCOIN)hProb;
    1293942
    1294         return pCoin->RowCount;
     943        return pCoin->pProblem->RowCount;
    1295944}
    1296945
     
    1301950        PCOIN pCoin = (PCOIN)hProb;
    1302951
    1303         return pCoin->ColNamesList[col];
     952        return pCoin->pProblem->ColNamesList[col];
    1304953}
    1305954
     
    1317966        PCOIN pCoin = (PCOIN)hProb;
    1318967
    1319         return pCoin->RowNamesList[row];
     968        return pCoin->pProblem->RowNamesList[row];
    1320969}
    1321970
     
    1350999int coinIterLogCallback(int IterCount, double ObjectValue, int IsFeasible, double InfeasValue)
    13511000{
    1352         if (!global_pCoin->SolveAsMIP) {
     1001        if (!global_pCoin->pProblem->SolveAsMIP) {
    13531002                if (((IterCount < 100) && ((IterCount % 10) == 0)) ||
    13541003                         ((IterCount % 100) == 0)) {
     
    16051254{
    16061255        PCOIN pCoin = (PCOIN)hProb;
     1256        PPROBLEM pProblem = pCoin->pProblem;
    16071257        int sos, count;
    16081258        int* which;
    16091259        int type;
    16101260
    1611         for (sos = 0; sos < pCoin->SosCount; sos++) {
    1612                 count = pCoin->SosBegin[sos+1] - pCoin->SosBegin[sos];
    1613                 which = &pCoin->SosIndex[pCoin->SosBegin[sos]];
    1614                 type = pCoin->SosType[sos];
     1261        for (sos = 0; sos < pProblem->SosCount; sos++) {
     1262                count = pProblem->SosBegin[sos+1] - pProblem->SosBegin[sos];
     1263                which = &pProblem->SosIndex[pProblem->SosBegin[sos]];
     1264                type = pProblem->SosType[sos];
    16151265                CbcObject *sosObject = new CbcSOS(pCoin->cbc, count, which, NULL, 0, type);
    16161266                pCoin->cbc->addObjects(1, &sosObject);
     
    16251275/************************************************************************/
    16261276
    1627 int CbcRetrieveSolutionResults(HPROB hProb, PRESULT pResult)
    1628 {
     1277int CbcRetrieveSolutionResults(PPROBLEM pProblem, HPROB hProb, PRESULT pResult)
     1278{
     1279        PCOIN pCoin = (PCOIN)hProb;
    16291280        const double* columnPrimal;
    16301281        const double* columnDual;
    16311282        const double* rowPrimal;
    16321283        const double* rowDual;
    1633         PCOIN pCoin = (PCOIN)hProb;
    1634 
    1635         if (!pCoin->SolveAsMIP) {
     1284
     1285        if (!pProblem->SolveAsMIP) {
    16361286                pResult->SolutionStatus = pCoin->clp->status();
    16371287                pResult->ObjectValue    = pCoin->clp->objectiveValue();
     
    16601310        }
    16611311
    1662         if (!pCoin->SolveAsMIP) {
     1312        if (!pProblem->SolveAsMIP) {
    16631313                columnPrimal = pCoin->clp->primalColumnSolution();
    16641314                columnDual = pCoin->clp->dualColumnSolution();
    16651315                rowPrimal = pCoin->clp->primalRowSolution();
    16661316                rowDual = pCoin->clp->dualRowSolution();
    1667                 pResult->ColActivity = (double*) malloc(pCoin->ColCount * sizeof(double));
    1668                 pResult->ReducedCost = (double*) malloc(pCoin->ColCount * sizeof(double));
    1669                 pResult->SlackValues = (double*) malloc(pCoin->RowCount * sizeof(double));
    1670                 pResult->ShadowPrice = (double*) malloc(pCoin->RowCount * sizeof(double));
     1317                pResult->ColActivity = (double*) malloc(pProblem->ColCount * sizeof(double));
     1318                pResult->ReducedCost = (double*) malloc(pProblem->ColCount * sizeof(double));
     1319                pResult->SlackValues = (double*) malloc(pProblem->RowCount * sizeof(double));
     1320                pResult->ShadowPrice = (double*) malloc(pProblem->RowCount * sizeof(double));
    16711321                if (!pResult->ColActivity ||
    16721322                        !pResult->ReducedCost ||
     
    16751325                        return SOLV_CALL_FAILED;
    16761326                }
    1677                 memcpy(pResult->ColActivity, columnPrimal, pCoin->ColCount * sizeof(double));
    1678                 memcpy(pResult->ReducedCost, columnDual, pCoin->ColCount * sizeof(double));
    1679                 memcpy(pResult->SlackValues, rowPrimal, pCoin->RowCount * sizeof(double));
    1680                 memcpy(pResult->ShadowPrice, rowDual, pCoin->RowCount * sizeof(double));
     1327                memcpy(pResult->ColActivity, columnPrimal, pProblem->ColCount * sizeof(double));
     1328                memcpy(pResult->ReducedCost, columnDual, pProblem->ColCount * sizeof(double));
     1329                memcpy(pResult->SlackValues, rowPrimal, pProblem->RowCount * sizeof(double));
     1330                memcpy(pResult->ShadowPrice, rowDual, pProblem->RowCount * sizeof(double));
    16811331                }
    16821332        else {
    16831333                columnPrimal = pCoin->cbc->solver()->getColSolution();
    1684                 pResult->ColActivity = (double*) malloc(pCoin->ColCount * sizeof(double));
     1334                pResult->ColActivity = (double*) malloc(pProblem->ColCount * sizeof(double));
    16851335                if (!pResult->ColActivity) {
    16861336                        return SOLV_CALL_FAILED;
    16871337                }
    1688                 memcpy(pResult->ColActivity, columnPrimal, pCoin->ColCount * sizeof(double));
     1338                memcpy(pResult->ColActivity, columnPrimal, pProblem->ColCount * sizeof(double));
    16891339        }
    16901340        return SOLV_CALL_SUCCESS;
     
    16981348{               
    16991349        PCOIN pCoin = (PCOIN)hProb;
    1700 
    1701         if (!pCoin->SolveAsMIP) {
     1350        PPROBLEM pProblem = pCoin->pProblem;
     1351
     1352        if (!pProblem->SolveAsMIP) {
    17021353                coinSetClpOptions(hProb);
    17031354                if (CoinGetOptionChanged(hProb, COIN_INT_PRESOLVETYPE))
     
    17361387                }
    17371388        }       
    1738         CbcRetrieveSolutionResults(hProb, pCoin->pResult);
     1389        CbcRetrieveSolutionResults(pProblem, hProb, pCoin->pResult);
    17391390        return pCoin->pResult->SolutionStatus;
    17401391}
     
    17781429        PCOIN pCoin = (PCOIN)hProb;
    17791430
    1780         return pCoin->pResult->ObjectValue + pCoin->ObjectConst;
     1431        return pCoin->pResult->ObjectValue + pCoin->pProblem->ObjectConst;
    17811432}
    17821433
     
    18171468{
    18181469        PCOIN pCoin = (PCOIN)hProb;
     1470        PPROBLEM pProblem = pCoin->pProblem;
    18191471        PRESULT pResult = pCoin->pResult;
    18201472
    18211473        if (Activity && pResult->ColActivity) {
    1822                 memcpy(Activity, pResult->ColActivity, pCoin->ColCount * sizeof(double));
     1474                memcpy(Activity, pResult->ColActivity, pProblem->ColCount * sizeof(double));
    18231475        }
    18241476        if (ReducedCost && pResult->ReducedCost) {
    1825                 memcpy(ReducedCost, pResult->ReducedCost, pCoin->ColCount * sizeof(double));
     1477                memcpy(ReducedCost, pResult->ReducedCost, pProblem->ColCount * sizeof(double));
    18261478        }
    18271479        if (SlackValues && pResult->SlackValues) {
    1828                 memcpy(SlackValues, pResult->SlackValues, pCoin->RowCount * sizeof(double));
     1480                memcpy(SlackValues, pResult->SlackValues, pProblem->RowCount * sizeof(double));
    18291481        }
    18301482        if (ShadowPrice && pResult->ShadowPrice) {
    1831                 memcpy(ShadowPrice, pResult->ShadowPrice, pCoin->RowCount * sizeof(double));
     1483                memcpy(ShadowPrice, pResult->ShadowPrice, pProblem->RowCount * sizeof(double));
    18321484        }
    18331485        return SOLV_CALL_SUCCESS;
     
    18401492{
    18411493        PCOIN pCoin = (PCOIN)hProb;
     1494        PPROBLEM pProblem = pCoin->pProblem;
    18421495        PRESULT pResult = pCoin->pResult;
    18431496
    18441497        if (ObjLoRange && pResult->ObjLoRange) {
    1845                 memcpy(ObjLoRange, pResult->ObjLoRange, pCoin->ColCount * sizeof(double));
     1498                memcpy(ObjLoRange, pResult->ObjLoRange, pProblem->ColCount * sizeof(double));
    18461499        }
    18471500        if (ObjUpRange && pResult->ObjUpRange) {
    1848                 memcpy(ObjUpRange, pResult->ObjUpRange, pCoin->ColCount * sizeof(double));
     1501                memcpy(ObjUpRange, pResult->ObjUpRange, pProblem->ColCount * sizeof(double));
    18491502        }
    18501503        if (RhsLoRange && pResult->RhsLoRange) {
    1851                 memcpy(RhsLoRange, pResult->RhsLoRange, pCoin->RowCount * sizeof(double));
     1504                memcpy(RhsLoRange, pResult->RhsLoRange, pProblem->RowCount * sizeof(double));
    18521505        }
    18531506        if (RhsUpRange && pResult->RhsUpRange) {
    1854                 memcpy(RhsUpRange, pResult->RhsUpRange, pCoin->RowCount * sizeof(double));
     1507                memcpy(RhsUpRange, pResult->RhsUpRange, pProblem->RowCount * sizeof(double));
    18551508        }
    18561509        return SOLV_CALL_SUCCESS;
     
    18621515{
    18631516        PCOIN pCoin = (PCOIN)hProb;
     1517        PPROBLEM pProblem = pCoin->pProblem;
    18641518        PRESULT pResult = pCoin->pResult;
    18651519
    18661520        if (ColStatus && pResult->ColStatus) {
    1867                 memcpy(ColStatus, pResult->ColStatus, pCoin->ColCount * sizeof(int));
     1521                memcpy(ColStatus, pResult->ColStatus, pProblem->ColCount * sizeof(int));
    18681522        }
    18691523        if (RowStatus && pResult->RowStatus) {
    1870                 memcpy(RowStatus, pResult->RowStatus, pCoin->RowCount * sizeof(int));
     1524                memcpy(RowStatus, pResult->RowStatus, pProblem->RowCount * sizeof(int));
    18711525        }
    18721526        return SOLV_CALL_SUCCESS;
     
    19071561        switch (FileType) {
    19081562                case SOLV_FILE_MPS:             
    1909                         pCoin->osi->writeMps(WriteFilename, "", pCoin->ObjectSense);   
     1563                        pCoin->osi->writeMps(WriteFilename, "", pCoin->pProblem->ObjectSense);   
    19101564                        break;
    19111565
  • trunk/CoinMP/src/CoinMP.def

    r245 r341  
    2525        CoinUnloadProblem
    2626        CoinCheckProblem
    27         CoinSetLoadNamesType
    2827        CoinGetProblemName
    2928        CoinGetProblemNameBuf
  • trunk/CoinMP/src/CoinMP.h

    r331 r341  
    189189
    190190// Depreciated, use CoinLoadProblemBuf instead
    191 SOLVAPI int    SOLVCALL CoinSetLoadNamesType(HPROB hProb, int LoadNamesType);
     191//SOLVAPI int    SOLVCALL CoinSetLoadNamesType(HPROB hProb, int LoadNamesType);
    192192
    193193SOLVAPI const char*  SOLVCALL CoinGetProblemName(HPROB hProb);
     
    316316int    (SOLVCALL *CoinCheckProblem)(HPROB hProb);
    317317
    318 int    (SOLVCALL *CoinSetLoadNamesType)(HPROB hProb, int LoadNamesType);
     318//int    (SOLVCALL *CoinSetLoadNamesType)(HPROB hProb, int LoadNamesType);
    319319
    320320void   (SOLVCALL *CoinSetMsgLogCallback)(HPROB hProb, MSGLOGCALLBACK MsgLogCallback);
Note: See TracChangeset for help on using the changeset viewer.