Changeset 362


Ignore:
Timestamp:
Nov 16, 2009 10:46:31 AM (10 years ago)
Author:
bjarni
Message:

Move all malloc and memcpy code in LoadXXX into CoinProblem?.c routines

Location:
trunk/CoinMP/src
Files:
4 edited

Legend:

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

    r361 r362  
    185185                                double* RHSValues, double* RangeValues, int* MatrixBegin,
    186186                                int* MatrixCount, int* MatrixIndex, double* MatrixValues,
    187                                 char** ColNames, char** RowNames, char* ObjectName)
     187                                char** ColNamesList, char** RowNamesList, char* ObjectName)
    188188{
    189189        PCOIN pCoin = (PCOIN)hProb;
    190190        PPROBLEM pProblem = pCoin->pProblem;
    191191
    192         if (ColCount == 0) {
     192        if (!coinStoreMatrix(pProblem, ColCount, RowCount, NZCount, RangeCount, ObjectSense,
     193                                                 ObjectConst, ObjectCoeffs, LowerBounds, UpperBounds, RowType,
     194                                                 RHSValues, RangeValues, MatrixBegin, MatrixCount, MatrixIndex,
     195                                                 MatrixValues)) {
    193196                return SOLV_CALL_FAILED;
    194197        }
    195         pProblem->ColCount = ColCount;
    196         pProblem->RowCount = RowCount;
    197         pProblem->NZCount = NZCount;
    198         pProblem->RangeCount = RangeCount;
    199         pProblem->ObjectSense = ObjectSense;
    200         pProblem->ObjectConst = ObjectConst;
    201 
    202         if (ColNames)   pProblem->lenColNamesBuf = coinGetLenNameListBuf(ColNames, ColCount);
    203         if (RowNames)   pProblem->lenRowNamesBuf = coinGetLenNameListBuf(RowNames, RowCount);
    204         if (ObjectName) pProblem->lenObjNameBuf  = (int)strlen(ObjectName) + 1;
    205 
    206         if (ObjectCoeffs) pProblem->ObjectCoeffs = (double*) malloc(pProblem->ColCount     * sizeof(double));
    207         if (RHSValues)    pProblem->RHSValues    = (double*) malloc(pProblem->RowCount     * sizeof(double));
    208         if (RangeValues)  pProblem->RangeValues  = (double*) malloc(pProblem->RowCount     * sizeof(double));
    209         if (RowType)      pProblem->RowType      = (char*)   malloc(pProblem->RowCount     * sizeof(char));
    210         if (MatrixBegin)  pProblem->MatrixBegin  = (int*)    malloc((pProblem->ColCount+1) * sizeof(int));
    211         if (MatrixCount)  pProblem->MatrixCount  = (int*)    malloc(pProblem->ColCount     * sizeof(int));
    212         if (MatrixIndex)  pProblem->MatrixIndex  = (int*)    malloc(pProblem->NZCount      * sizeof(int));
    213         if (MatrixValues) pProblem->MatrixValues = (double*) malloc(pProblem->NZCount      * sizeof(double));
    214         if (LowerBounds)  pProblem->LowerBounds  = (double*) malloc(pProblem->ColCount     * sizeof(double));
    215         if (UpperBounds)  pProblem->UpperBounds  = (double*) malloc(pProblem->ColCount     * sizeof(double));
    216         if (ColNames)     pProblem->ColNamesList = (char**)  malloc(pProblem->ColCount     * sizeof(char* ));
    217         if (RowNames)     pProblem->RowNamesList = (char**)  malloc(pProblem->RowCount     * sizeof(char* ));
    218         if (ColNames)     pProblem->ColNamesBuf  = (char*)   malloc(pProblem->lenColNamesBuf * sizeof(char));
    219         if (RowNames)     pProblem->RowNamesBuf  = (char*)   malloc(pProblem->lenRowNamesBuf * sizeof(char));
    220         if (ObjectName)   pProblem->ObjectName   = (char*)   malloc(pProblem->lenObjNameBuf  * sizeof(char));
    221 
    222         if (pProblem->RowCount > 0) {
    223                 pProblem->RowLower = (double* )malloc(pProblem->RowCount*sizeof(double));
    224                 pProblem->RowUpper = (double* )malloc(pProblem->RowCount*sizeof(double));
    225                 if (!pProblem->RowLower || !pProblem->RowUpper) {
    226                         return SOLV_CALL_FAILED;
    227                 }
    228         }
    229 
    230         if (pProblem->ObjectCoeffs) memcpy(pProblem->ObjectCoeffs, ObjectCoeffs, pProblem->ColCount     * sizeof(double));
    231         if (pProblem->RHSValues)    memcpy(pProblem->RHSValues,    RHSValues,    pProblem->RowCount     * sizeof(double));
    232         if (pProblem->RangeValues)  memcpy(pProblem->RangeValues,  RangeValues,  pProblem->RowCount     * sizeof(double));
    233         if (pProblem->RowType)      memcpy(pProblem->RowType,      RowType,      pProblem->RowCount     * sizeof(char));
    234         if (pProblem->MatrixBegin)  memcpy(pProblem->MatrixBegin,  MatrixBegin,  (pProblem->ColCount+1) * sizeof(int));
    235         if (pProblem->MatrixCount)  memcpy(pProblem->MatrixCount,  MatrixCount,  pProblem->ColCount     * sizeof(int));
    236         if (pProblem->MatrixIndex)  memcpy(pProblem->MatrixIndex,  MatrixIndex,  pProblem->NZCount      * sizeof(int));
    237         if (pProblem->MatrixValues) memcpy(pProblem->MatrixValues, MatrixValues, pProblem->NZCount      * sizeof(double));
    238         if (pProblem->LowerBounds)  memcpy(pProblem->LowerBounds,  LowerBounds,  pProblem->ColCount     * sizeof(double));
    239         if (pProblem->UpperBounds)  memcpy(pProblem->UpperBounds,  UpperBounds,  pProblem->ColCount     * sizeof(double));
    240         if (pProblem->ObjectName)   memcpy(pProblem->ObjectName,   ObjectName,   pProblem->lenObjNameBuf  * sizeof(char));
    241 
    242         coinCopyNamesList(pProblem->ColNamesList, pProblem->ColNamesBuf, ColNames, ColCount);
    243         coinCopyNamesList(pProblem->RowNamesList, pProblem->RowNamesBuf, RowNames, RowCount);
    244 
    245         if (!coinComputeRowLowerUpper(pProblem, COIN_DBL_MAX)) {
     198        if (!coinStoreNamesList(pProblem, ColNamesList, RowNamesList, ObjectName)) {
    246199                return SOLV_CALL_FAILED;
    247200        }
     
    260213{
    261214        PCOIN pCoin = (PCOIN)hProb;
    262         char** ColNamesList;
    263         char** RowNamesList;
    264         int result;
    265 
    266         ColNamesList = (char**)malloc(ColCount * sizeof(char*));
    267         RowNamesList = (char**)malloc(RowCount * sizeof(char*));
    268         coinSetupNamesList(ColNamesList, ColNamesBuf, ColCount);
    269         coinSetupNamesList(RowNamesList, RowNamesBuf, RowCount);
    270         result = CoinLoadProblem(hProb, ColCount, RowCount, NZCount, RangeCount,
    271                                 ObjectSense, ObjectConst, ObjectCoeffs, LowerBounds, UpperBounds, RowType,
    272                                 RHSValues, RangeValues, MatrixBegin, MatrixCount, MatrixIndex, MatrixValues,
    273                                 ColNamesList, RowNamesList, ObjectName);
    274         if (ColNamesList) free(ColNamesList);
    275         if (RowNamesList) free(RowNamesList);
    276         return result;
    277 }
     215        PPROBLEM pProblem = pCoin->pProblem;
     216
     217        if (!coinStoreMatrix(pProblem, ColCount, RowCount, NZCount, RangeCount, ObjectSense,
     218                                                 ObjectConst, ObjectCoeffs, LowerBounds, UpperBounds, RowType,
     219                                                 RHSValues, RangeValues, MatrixBegin, MatrixCount, MatrixIndex,
     220                                                 MatrixValues)) {
     221                return SOLV_CALL_FAILED;
     222        }
     223        if (!coinStoreNamesBuf(pProblem, ColNamesBuf, RowNamesBuf, ObjectName)) {
     224                return SOLV_CALL_FAILED;
     225        }
     226        return SOLV_CALL_SUCCESS;
     227}
     228
     229
    278230
    279231
     
    281233{
    282234        PCOIN pCoin = (PCOIN)hProb;
    283         PPROBLEM pProblem = pCoin->pProblem;
    284 
    285         if (!InitValues) {
     235
     236        if (!coinStoreInitValues(pCoin->pProblem, InitValues)) {
    286237                return SOLV_CALL_FAILED;
    287         }       
    288         if (InitValues)   pProblem->InitValues   = (double* ) malloc(pProblem->ColCount     * sizeof(double));
    289 
    290         if (pProblem->InitValues)   memcpy(pProblem->InitValues,   InitValues,   pProblem->ColCount     * sizeof(double));
     238        }
    291239        return SOLV_CALL_SUCCESS;
    292240}
     
    298246        PPROBLEM pProblem = pCoin->pProblem;
    299247
    300         if (pProblem->ColCount == 0) {
     248        if (!coinStoreInteger(pProblem, ColType)) {
    301249                return SOLV_CALL_FAILED;
    302250        }
    303         if (!ColType) {
    304                 return SOLV_CALL_FAILED;
    305         }
    306         pProblem->ColType = (char* )malloc(pProblem->ColCount * sizeof(char));
    307         if (!pProblem->ColType) {
    308                 return SOLV_CALL_FAILED;
    309         }
    310         memcpy(pProblem->ColType, ColType, pProblem->ColCount * sizeof(char));
    311 
    312         if (!coinComputeIntVariables(pProblem)) {
    313                 return SOLV_CALL_FAILED;
    314         }
    315         pProblem->SolveAsMIP = 1;
    316251        return SOLV_CALL_SUCCESS;
    317252}
     
    323258{
    324259        PCOIN pCoin = (PCOIN)hProb;
    325         PPROBLEM pProblem = pCoin->pProblem;
    326 
    327         if (PriorCount == 0) {
     260
     261        if (!coinStorePriority(pCoin->pProblem, PriorCount, PriorIndex, PriorValues, PriorBranch)) {
    328262                return SOLV_CALL_FAILED;
    329263        }
    330         pProblem->PriorCount = PriorCount;
    331         if (PriorIndex)  pProblem->PriorIndex  = (int* )malloc(PriorCount * sizeof(int));
    332         if (PriorValues) pProblem->PriorValues = (int* )malloc(PriorCount * sizeof(int));
    333         if (PriorBranch) pProblem->PriorBranch = (int* )malloc(PriorCount * sizeof(int));
    334         if (pProblem->PriorIndex)  memcpy(pProblem->PriorIndex,  PriorIndex,  PriorCount * sizeof(int));
    335         if (pProblem->PriorValues) memcpy(pProblem->PriorValues, PriorValues, PriorCount * sizeof(int));
    336         if (pProblem->PriorBranch) memcpy(pProblem->PriorBranch, PriorBranch, PriorCount * sizeof(int));
    337 
    338264        return SOLV_CALL_SUCCESS;
    339265}
     
    345271{
    346272        PCOIN pCoin = (PCOIN)hProb;
     273
     274        if (!coinStoreSos(pCoin->pProblem, SosCount, SosNZCount, SosType, SosPrior,
     275                SosBegin, SosIndex, SosRef)) {
     276                        return SOLV_CALL_FAILED;
     277        }
     278        return SOLV_CALL_SUCCESS;
     279}
     280
     281
     282
     283SOLVAPI int SOLVCALL CoinLoadSemiCont(HPROB hProb, int SemiCount, int* SemiIndex)
     284{
     285        PCOIN pCoin = (PCOIN)hProb;
    347286        PPROBLEM pProblem = pCoin->pProblem;
    348287
    349         if ((SosCount == 0) || (SosNZCount == 0)) {
     288        if (!coinStoreSemiCont(pCoin->pProblem, SemiCount, SemiIndex)) {
    350289                return SOLV_CALL_FAILED;
    351290        }
    352         pProblem->SosCount = SosCount;
    353         pProblem->SosNZCount = SosNZCount;
    354 
    355         if (SosType)  pProblem->SosType  = (int* )malloc(SosCount     * sizeof(int));
    356         if (SosPrior) pProblem->SosPrior = (int* )malloc(SosCount     * sizeof(int));
    357         if (SosBegin) pProblem->SosBegin = (int* )malloc((SosCount+1) * sizeof(int));
    358         if (SosIndex) pProblem->SosIndex = (int* )malloc(SosNZCount   * sizeof(int));
    359         if (SosRef)   pProblem->SosRef   = (double* )malloc(SosNZCount* sizeof(double));
    360 
    361         if (pProblem->SosType)  memcpy(pProblem->SosType,  SosType,  SosCount     * sizeof(int));
    362         if (pProblem->SosPrior) memcpy(pProblem->SosPrior, SosPrior, SosCount     * sizeof(int));
    363         if (pProblem->SosBegin) memcpy(pProblem->SosBegin, SosBegin, (SosCount+1) * sizeof(int));
    364         if (pProblem->SosIndex) memcpy(pProblem->SosIndex, SosIndex, SosNZCount   * sizeof(int));
    365         if (pProblem->SosRef)   memcpy(pProblem->SosRef,   SosRef,   SosNZCount   * sizeof(double));
    366 
    367         pProblem->SolveAsMIP = 1;
    368         return SOLV_CALL_SUCCESS;
    369 }
    370 
    371 
    372 
    373 SOLVAPI int SOLVCALL CoinLoadSemiCont(HPROB hProb, int SemiCount, int* SemiIndex)
    374 {
    375         PCOIN pCoin = (PCOIN)hProb;
    376         PPROBLEM pProblem = pCoin->pProblem;
    377 
    378         if (SemiCount == 0) {
    379                 return SOLV_CALL_FAILED;
    380         }
    381         if (!SemiIndex) {
    382                 return SOLV_CALL_FAILED;
    383         }
    384         pProblem->SemiCount = SemiCount;
    385         pProblem->SemiIndex = (int* )malloc(pProblem->SemiCount * sizeof(int));
    386         if (!pProblem->SemiIndex) {
    387                 return SOLV_CALL_FAILED;
    388         }
    389         memcpy(pProblem->SemiIndex, SemiIndex, pProblem->SemiCount * sizeof(int));
    390 
    391         pProblem->SolveAsMIP = 1;
    392         return SOLV_CALL_SUCCESS;
    393 }
     291        return SOLV_CALL_SUCCESS;
     292}
     293
    394294
    395295
  • trunk/CoinMP/src/CoinMP.h

    r358 r362  
    150150                                        double* RHSValues, double* RangeValues, int* MatrixBegin, 
    151151                                        int* MatrixCount, int* MatrixIndex, double* MatrixValues,   
    152                                         char** ColNames, char** RowNames, char* objName);
     152                                        char** ColNamesList, char** RowNamesList, char* objName);
    153153
    154154SOLVAPI int    SOLVCALL CoinLoadProblemBuf(HPROB hProb,
  • trunk/CoinMP/src/CoinProblem.c

    r361 r362  
    55#include <stdlib.h>
    66#include <string.h>
     7#include <float.h>   // DBL_MAX
    78
    89#include "CoinProblem.h"
     
    7879
    7980
    80 void coinSetProblemName(PPROBLEM pProblem, const char *ProblemName)
    81 {
    82         size_t len;
    83 
    84         len = strlen(ProblemName);
    85         if (len >= sizeof(pProblem->ProblemName)) {
    86                 len = sizeof(pProblem->ProblemName) - 1;
    87         }
    88         strncpy(pProblem->ProblemName, ProblemName, len);
    89         pProblem->ProblemName[len] = '\0';
    90 }
    91 
    92 
    9381void coinClearProblemObject(PPROBLEM pProblem)
    9482{
     
    136124
    137125
     126
     127void coinSetProblemName(PPROBLEM pProblem, const char *ProblemName)
     128{
     129        size_t len;
     130
     131        len = strlen(ProblemName);
     132        if (len >= sizeof(pProblem->ProblemName)) {
     133                len = sizeof(pProblem->ProblemName) - 1;
     134        }
     135        strncpy(pProblem->ProblemName, ProblemName, len);
     136        pProblem->ProblemName[len] = '\0';
     137}
     138
     139
     140int coinStoreMatrix(PPROBLEM pProblem,  int ColCount, int RowCount, int NZCount, int RangeCount,
     141                                int ObjectSense, double ObjectConst, double* ObjectCoeffs, double* LowerBounds,
     142                                double* UpperBounds, char* RowType, double* RHSValues, double* RangeValues,
     143                                int* MatrixBegin, int* MatrixCount, int* MatrixIndex, double* MatrixValues)
     144{
     145        if (ColCount == 0) {
     146                return 0;
     147        }
     148        pProblem->ColCount = ColCount;
     149        pProblem->RowCount = RowCount;
     150        pProblem->NZCount = NZCount;
     151        pProblem->RangeCount = RangeCount;
     152        pProblem->ObjectSense = ObjectSense;
     153        pProblem->ObjectConst = ObjectConst;
     154
     155        if (ObjectCoeffs) pProblem->ObjectCoeffs = (double*) malloc(pProblem->ColCount     * sizeof(double));
     156        if (LowerBounds)  pProblem->LowerBounds  = (double*) malloc(pProblem->ColCount     * sizeof(double));
     157        if (UpperBounds)  pProblem->UpperBounds  = (double*) malloc(pProblem->ColCount     * sizeof(double));
     158        if (RowType)      pProblem->RowType      = (char*)   malloc(pProblem->RowCount     * sizeof(char));
     159        if (RHSValues)    pProblem->RHSValues    = (double*) malloc(pProblem->RowCount     * sizeof(double));
     160        if (RangeValues)  pProblem->RangeValues  = (double*) malloc(pProblem->RowCount     * sizeof(double));
     161        if (MatrixBegin)  pProblem->MatrixBegin  = (int*)    malloc((pProblem->ColCount+1) * sizeof(int));
     162        if (MatrixCount)  pProblem->MatrixCount  = (int*)    malloc(pProblem->ColCount     * sizeof(int));
     163        if (MatrixIndex)  pProblem->MatrixIndex  = (int*)    malloc(pProblem->NZCount      * sizeof(int));
     164        if (MatrixValues) pProblem->MatrixValues = (double*) malloc(pProblem->NZCount      * sizeof(double));
     165
     166        if ((ObjectCoeffs && !pProblem->ObjectCoeffs) ||
     167                (LowerBounds  && !pProblem->LowerBounds) || 
     168                (UpperBounds  && !pProblem->UpperBounds) ||
     169                (RowType      && !pProblem->RowType)     ||
     170                (RHSValues    && !pProblem->RHSValues)   || 
     171                (RangeValues  && !pProblem->RangeValues) ||
     172                (MatrixBegin  && !pProblem->MatrixBegin) ||
     173                (MatrixCount  && !pProblem->MatrixCount) || 
     174                (MatrixIndex  && !pProblem->MatrixIndex) ||
     175                (MatrixValues && !pProblem->MatrixValues)) {
     176                return 0;
     177        }
     178        if (ObjectCoeffs) memcpy(pProblem->ObjectCoeffs, ObjectCoeffs, pProblem->ColCount     * sizeof(double));
     179        if (LowerBounds)  memcpy(pProblem->LowerBounds,  LowerBounds,  pProblem->ColCount     * sizeof(double));
     180        if (UpperBounds)  memcpy(pProblem->UpperBounds,  UpperBounds,  pProblem->ColCount     * sizeof(double));
     181        if (RowType)      memcpy(pProblem->RowType,      RowType,      pProblem->RowCount     * sizeof(char));
     182        if (RHSValues)    memcpy(pProblem->RHSValues,    RHSValues,    pProblem->RowCount     * sizeof(double));
     183        if (RangeValues)  memcpy(pProblem->RangeValues,  RangeValues,  pProblem->RowCount     * sizeof(double));
     184        if (MatrixBegin)  memcpy(pProblem->MatrixBegin,  MatrixBegin,  (pProblem->ColCount+1) * sizeof(int));
     185        if (MatrixCount)  memcpy(pProblem->MatrixCount,  MatrixCount,  pProblem->ColCount     * sizeof(int));
     186        if (MatrixIndex)  memcpy(pProblem->MatrixIndex,  MatrixIndex,  pProblem->NZCount      * sizeof(int));
     187        if (MatrixValues) memcpy(pProblem->MatrixValues, MatrixValues, pProblem->NZCount      * sizeof(double));
     188
     189        if (!coinComputeRowLowerUpper(pProblem, DBL_MAX)) {
     190                return 0;
     191        }
     192        return 1;
     193}
     194
     195
     196int coinStoreNamesList(PPROBLEM pProblem, char** ColNamesList, char** RowNamesList, char* ObjectName)
     197{
     198        if (ObjectName) {
     199                pProblem->lenObjNameBuf  = (int)strlen(ObjectName) + 1;
     200            pProblem->ObjectName   = (char*)   malloc(pProblem->lenObjNameBuf  * sizeof(char));
     201                if (!pProblem->ObjectName) {
     202                        return 0;
     203                }
     204                memcpy(pProblem->ObjectName,   ObjectName,   pProblem->lenObjNameBuf  * sizeof(char));
     205        }
     206        if (ColNamesList) {
     207                pProblem->lenColNamesBuf = coinGetLenNameListBuf(ColNamesList, pProblem->ColCount);
     208                pProblem->ColNamesList = (char**)  malloc(pProblem->ColCount     * sizeof(char* ));
     209                pProblem->ColNamesBuf  = (char*)   malloc(pProblem->lenColNamesBuf * sizeof(char));
     210                if (!pProblem->ColNamesList && !pProblem->ColNamesBuf) {
     211                        return 0;
     212                }
     213                coinCopyNamesList(pProblem->ColNamesList, pProblem->ColNamesBuf, ColNamesList, pProblem->ColCount);
     214        }
     215        if (RowNamesList) {
     216                pProblem->lenRowNamesBuf = coinGetLenNameListBuf(RowNamesList, pProblem->RowCount);
     217                pProblem->RowNamesList = (char**)  malloc(pProblem->RowCount     * sizeof(char* ));
     218                pProblem->RowNamesBuf  = (char*)   malloc(pProblem->lenRowNamesBuf * sizeof(char));
     219                if (!pProblem->RowNamesList && !pProblem->RowNamesBuf) {
     220                        return 0;
     221                }
     222                coinCopyNamesList(pProblem->RowNamesList, pProblem->RowNamesBuf, RowNamesList, pProblem->RowCount);
     223        }
     224        return 1;
     225}
     226
     227
     228int coinStoreNamesBuf(PPROBLEM pProblem, char* ColNamesBuf, char* RowNamesBuf, char* ObjectName)
     229{
     230        char** ColNamesList;
     231        char** RowNamesList;
     232        int result;
     233
     234        ColNamesList = (char**)malloc(pProblem->ColCount * sizeof(char*));
     235        RowNamesList = (char**)malloc(pProblem->RowCount * sizeof(char*));
     236        if (!ColNamesList && !RowNamesList) {
     237                return 0;
     238        }
     239        coinSetupNamesList(ColNamesList, ColNamesBuf, pProblem->ColCount);
     240        coinSetupNamesList(RowNamesList, RowNamesBuf, pProblem->RowCount);
     241        result = coinStoreNamesList(pProblem, ColNamesList, RowNamesList, ObjectName);
     242        if (ColNamesList) free(ColNamesList);
     243        if (RowNamesList) free(RowNamesList);
     244        return result;
     245
     246}
     247
     248int coinStoreInitValues(PPROBLEM pProblem, double* InitValues)
     249{
     250        if (!InitValues) {
     251                return 0;
     252        }       
     253        pProblem->InitValues = (double* ) malloc(pProblem->ColCount * sizeof(double));
     254        if (!pProblem->InitValues) {
     255                return 0;
     256        }
     257        memcpy(pProblem->InitValues, InitValues, pProblem->ColCount * sizeof(double));
     258        return 1;
     259}
     260
     261
     262int coinStoreInteger(PPROBLEM pProblem, char* ColType)
     263{
     264        if (pProblem->ColCount == 0) {
     265                return 0;
     266        }
     267        if (!ColType) {
     268                return 0;
     269        }
     270        pProblem->ColType = (char* )malloc(pProblem->ColCount * sizeof(char));
     271        if (!pProblem->ColType) {
     272                return 0;
     273        }
     274        memcpy(pProblem->ColType, ColType, pProblem->ColCount * sizeof(char));
     275        pProblem->SolveAsMIP = 1;
     276        if (!coinComputeIntVariables(pProblem)) {
     277                return 0;
     278        }
     279        return 1;
     280}
     281
     282
     283int coinStorePriority(PPROBLEM pProblem, int PriorCount, int* PriorIndex,
     284                                int* PriorValues, int* PriorBranch)
     285{
     286        if (PriorCount == 0) {
     287                return 0;
     288        }
     289        pProblem->PriorCount = PriorCount;
     290        if (PriorIndex)  pProblem->PriorIndex  = (int* )malloc(PriorCount * sizeof(int));
     291        if (PriorValues) pProblem->PriorValues = (int* )malloc(PriorCount * sizeof(int));
     292        if (PriorBranch) pProblem->PriorBranch = (int* )malloc(PriorCount * sizeof(int));
     293
     294        if ((PriorIndex && !pProblem->PriorIndex) ||
     295                (PriorValues  && !pProblem->PriorValues) || 
     296                (PriorBranch  && !pProblem->PriorBranch)) {
     297                return 0;
     298        }
     299        if (PriorIndex)  memcpy(pProblem->PriorIndex,  PriorIndex,  PriorCount * sizeof(int));
     300        if (PriorValues) memcpy(pProblem->PriorValues, PriorValues, PriorCount * sizeof(int));
     301        if (PriorBranch) memcpy(pProblem->PriorBranch, PriorBranch, PriorCount * sizeof(int));
     302        return 0;
     303}
     304
     305
     306int coinStoreSos(PPROBLEM pProblem, int SosCount, int SosNZCount,
     307                                int* SosType, int* SosPrior, int* SosBegin,
     308                                int* SosIndex, double* SosRef)
     309{
     310        if ((SosCount == 0) || (SosNZCount == 0)) {
     311                return 0;
     312        }
     313        pProblem->SosCount = SosCount;
     314        pProblem->SosNZCount = SosNZCount;
     315
     316        if (SosType)  pProblem->SosType  = (int* )malloc(SosCount     * sizeof(int));
     317        if (SosPrior) pProblem->SosPrior = (int* )malloc(SosCount     * sizeof(int));
     318        if (SosBegin) pProblem->SosBegin = (int* )malloc((SosCount+1) * sizeof(int));
     319        if (SosIndex) pProblem->SosIndex = (int* )malloc(SosNZCount   * sizeof(int));
     320        if (SosRef)   pProblem->SosRef   = (double* )malloc(SosNZCount* sizeof(double));
     321
     322        if ((SosType && !pProblem->SosType) ||
     323                (SosPrior  && !pProblem->SosPrior) || 
     324                (SosBegin  && !pProblem->SosBegin) || 
     325                (SosIndex  && !pProblem->SosIndex) || 
     326                (SosRef  && !pProblem->SosRef)) {
     327                return 0;
     328        }
     329        if (SosType)  memcpy(pProblem->SosType,  SosType,  SosCount     * sizeof(int));
     330        if (SosPrior) memcpy(pProblem->SosPrior, SosPrior, SosCount     * sizeof(int));
     331        if (SosBegin) memcpy(pProblem->SosBegin, SosBegin, (SosCount+1) * sizeof(int));
     332        if (SosIndex) memcpy(pProblem->SosIndex, SosIndex, SosNZCount   * sizeof(int));
     333        if (SosRef)   memcpy(pProblem->SosRef,   SosRef,   SosNZCount   * sizeof(double));
     334
     335        pProblem->SolveAsMIP = 1;
     336        return 1;
     337}
     338
     339
     340int coinStoreSemiCont(PPROBLEM pProblem, int SemiCount, int* SemiIndex)
     341{
     342        if (SemiCount == 0) {
     343                return 0;
     344        }
     345        if (!SemiIndex) {
     346                return 0;
     347        }
     348        pProblem->SemiCount = SemiCount;
     349        pProblem->SemiIndex = (int* )malloc(pProblem->SemiCount * sizeof(int));
     350        if (!pProblem->SemiIndex) {
     351                return 0;
     352        }
     353        memcpy(pProblem->SemiIndex, SemiIndex, pProblem->SemiCount * sizeof(int));
     354
     355        pProblem->SolveAsMIP = 1;
     356        return 1;
     357}
     358
     359
    138360int coinComputeRowLowerUpper(PPROBLEM pProblem, double CoinDblMax)
    139361{
     
    141363        double RangeABS, RangeValue;
    142364
     365        if (pProblem->RowCount == 0) {
     366                return 0;
     367        }
     368        pProblem->RowLower = (double* )malloc(pProblem->RowCount*sizeof(double));
     369        pProblem->RowUpper = (double* )malloc(pProblem->RowCount*sizeof(double));
    143370        if (!pProblem->RowLower || !pProblem->RowUpper) {
    144371                return 0;
     
    193420        int i;
    194421
     422        if (pProblem->ColCount == 0) {
     423                return 0;
     424        }
    195425        pProblem->IsInt = (char* )malloc(pProblem->ColCount * sizeof(char));
    196426        if (!pProblem->IsInt) {
  • trunk/CoinMP/src/CoinProblem.h

    r361 r362  
    7979void coinSetProblemName(PPROBLEM pProblem, const char *ProblemName);
    8080
     81int coinStoreMatrix(PPROBLEM pProblem,  int ColCount, int RowCount, int NZCount, int RangeCount,
     82                                int ObjectSense, double ObjectConst, double* ObjectCoeffs, double* LowerBounds,
     83                                double* UpperBounds, char* RowType, double* RHSValues, double* RangeValues,
     84                                int* MatrixBegin, int* MatrixCount, int* MatrixIndex, double* MatrixValues);
     85
     86int coinStoreNamesList(PPROBLEM pProblem, char** ColNamesList, char** RowNamesList, char* OjbectName);
     87int coinStoreNamesBuf(PPROBLEM pProblem, char* ColNamesBuf, char* RowNamesBuf, char* ObjectName);
     88
     89int coinStoreInitValues(PPROBLEM pProblem, double* InitValues);
     90int coinStoreInteger(PPROBLEM pProblem, char* ColType);
     91
     92int coinStorePriority(PPROBLEM pProblem, int PriorCount, int* PriorIndex,
     93                                int* PriorValues, int* PriorBranch);
     94int coinStoreSos(PPROBLEM pProblem, int SosCount, int SosNZCount,
     95                                int* SosType, int* SosPrior, int* SosBegin,
     96                                int* SosIndex, double* SosRef);
     97int coinStoreSemiCont(PPROBLEM pProblem, int SemiCount, int* SemiIndex);
     98
    8199int coinComputeRowLowerUpper(PPROBLEM pProblem, double CoinDblMax);
    82100
Note: See TracChangeset for help on using the changeset viewer.