Changeset 336


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

Adding PRESULT structure to CoinMP.cpp and storing all results there

File:
1 edited

Legend:

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

    r331 r336  
    370370/************************************************************************/
    371371
     372
     373
     374typedef struct {
     375                                int SolutionStatus;
     376                                char SolutionText[200];
     377
     378                                double ObjectValue;
     379                                double MipBestBound;
     380                                int IterCount;
     381                                int MipNodeCount;
     382
     383                                double* ColActivity;
     384                                double* ReducedCost;
     385                                double* SlackValues;
     386                                double* ShadowPrice;
     387
     388                                double* ObjLoRange;
     389                                double* ObjUpRange;
     390                                double* RhsLoRange;
     391                                double* RhsUpRange;
     392
     393                                int* ColStatus;
     394                                int* RowStatus;
     395                                } RESULTINFO, *PRESULT;
     396
     397
     398PRESULT coinCreateResultObject(void)
     399{
     400        PRESULT pResult;
     401
     402        pResult = (PRESULT)malloc(sizeof(RESULTINFO));
     403        memset(pResult, 0, sizeof(RESULTINFO));
     404
     405        pResult->SolutionStatus = 0;
     406        strcpy(pResult->SolutionText, "");
     407
     408        pResult->ObjectValue  = 0.0;
     409        pResult->MipBestBound = 0.0;
     410        pResult->IterCount    = 0;
     411        pResult->MipNodeCount = 0;
     412
     413        pResult->ColActivity = NULL;
     414        pResult->ReducedCost = NULL;
     415        pResult->SlackValues = NULL;
     416        pResult->ShadowPrice = NULL;
     417
     418        pResult->ObjLoRange = NULL;
     419        pResult->ObjUpRange = NULL;
     420        pResult->RhsLoRange = NULL;
     421        pResult->RhsUpRange = NULL;
     422
     423        pResult->ColStatus = NULL;
     424        pResult->RowStatus = NULL;
     425
     426        return pResult;
     427}
     428
     429
     430void coinClearResultObject(PRESULT pResult)
     431{
     432        if (!pResult) {
     433                return;
     434        }
     435        if (pResult->ColActivity)   free(pResult->ColActivity);
     436        if (pResult->ReducedCost)   free(pResult->ReducedCost);
     437        if (pResult->SlackValues)   free(pResult->SlackValues);
     438        if (pResult->ShadowPrice)   free(pResult->ShadowPrice);
     439
     440        if (pResult->ObjLoRange)    free(pResult->ObjLoRange);
     441        if (pResult->ObjUpRange)    free(pResult->ObjUpRange);
     442        if (pResult->ObjUpRange)    free(pResult->ObjUpRange);
     443        if (pResult->RhsUpRange)    free(pResult->RhsUpRange);
     444
     445        if (pResult->ColStatus)     free(pResult->ColStatus);
     446        if (pResult->ColStatus)     free(pResult->ColStatus);
     447        free(pResult);
     448}
    372449
    373450typedef struct {
     
    447524                                int* BranchDir;
    448525
    449                                 int SolutionStatus;
    450                                 char SolutionText[200];
     526                                PRESULT   pResult;
     527                                //int SolutionStatus;
     528                                //char SolutionText[200];
    451529
    452530                                MSGLOGCALLBACK  MessageLogCallback;
     
    539617        pCoin->BranchDir        = NULL;
    540618
    541         pCoin->SolutionStatus = 0;
    542         strcpy(pCoin->SolutionText, "");
     619        pCoin->pResult = coinCreateResultObject();
     620        //pCoin->SolutionStatus = 0;
     621        //strcpy(pCoin->SolutionText, "");
    543622
    544623        pCoin->MessageLogCallback = NULL;
     
    10541133                if (pCoin->PriorValues)  free(pCoin->PriorValues);
    10551134                if (pCoin->BranchDir)    free(pCoin->BranchDir);
     1135                coinClearResultObject(pCoin->pResult);
    10561136        }
    10571137        free(pCoin);
     
    15421622/************************************************************************/
    15431623
     1624int CbcRetrieveSolutionResults(HPROB hProb, PRESULT pResult)
     1625{
     1626        const double* columnPrimal;
     1627        const double* columnDual;
     1628        const double* rowPrimal;
     1629        const double* rowDual;
     1630        PCOIN pCoin = (PCOIN)hProb;
     1631
     1632        if (!pCoin->SolveAsMIP) {
     1633                pResult->SolutionStatus = pCoin->clp->status();
     1634                pResult->ObjectValue    = pCoin->clp->objectiveValue();
     1635                pResult->MipBestBound   = 0.0;
     1636                pResult->IterCount      = pCoin->clp->numberIterations();
     1637                pResult->MipNodeCount     = 0;
     1638                }
     1639        else {
     1640                pResult->SolutionStatus = pCoin->cbc->status();
     1641                pResult->ObjectValue    = pCoin->cbc->getObjValue();
     1642                pResult->MipBestBound   = pCoin->cbc->getBestPossibleObjValue();
     1643                pResult->IterCount      = pCoin->cbc->getIterationCount();
     1644                pResult->MipNodeCount   = pCoin->cbc->getNodeCount();
     1645        }
     1646
     1647        switch (pResult->SolutionStatus) {
     1648                case 0: strcpy(pResult->SolutionText, "Optimal solution found");                break;
     1649                case 1: strcpy(pResult->SolutionText, "Problem primal infeasible");     break;
     1650                case 2: strcpy(pResult->SolutionText, "Problem dual infeasible");               break;
     1651                case 3: strcpy(pResult->SolutionText, "Stopped on iterations");                 break;
     1652                case 4: strcpy(pResult->SolutionText, "Stopped due to errors");                 break;
     1653                case 5: strcpy(pResult->SolutionText, "Stopped by user");               break;
     1654                default:
     1655                        sprintf(pResult->SolutionText, "Unknown CBC solution status (%d)", pResult->SolutionStatus);
     1656                        break;
     1657        }
     1658
     1659        if (!pCoin->SolveAsMIP) {
     1660                columnPrimal = pCoin->clp->primalColumnSolution();
     1661                columnDual = pCoin->clp->dualColumnSolution();
     1662                rowPrimal = pCoin->clp->primalRowSolution();
     1663                rowDual = pCoin->clp->dualRowSolution();
     1664                pResult->ColActivity = (double*) malloc(pCoin->ColCount * sizeof(double));
     1665                pResult->ReducedCost = (double*) malloc(pCoin->ColCount * sizeof(double));
     1666                pResult->SlackValues = (double*) malloc(pCoin->RowCount * sizeof(double));
     1667                pResult->ShadowPrice = (double*) malloc(pCoin->RowCount * sizeof(double));
     1668                if (!pResult->ColActivity ||
     1669                        !pResult->ReducedCost ||
     1670                        !pResult->SlackValues ||
     1671                        !pResult->ShadowPrice) {
     1672                        return SOLV_CALL_FAILED;
     1673                }
     1674                memcpy(pResult->ColActivity, columnPrimal, pCoin->ColCount * sizeof(double));
     1675                memcpy(pResult->ReducedCost, columnDual, pCoin->ColCount * sizeof(double));
     1676                memcpy(pResult->SlackValues, rowPrimal, pCoin->RowCount * sizeof(double));
     1677                memcpy(pResult->ShadowPrice, rowDual, pCoin->RowCount * sizeof(double));
     1678                }
     1679        else {
     1680                columnPrimal = pCoin->cbc->solver()->getColSolution();
     1681                pResult->ColActivity = (double*) malloc(pCoin->ColCount * sizeof(double));
     1682                if (!pResult->ColActivity) {
     1683                        return SOLV_CALL_FAILED;
     1684                }
     1685                memcpy(pResult->ColActivity, columnPrimal, pCoin->ColCount * sizeof(double));
     1686        }
     1687        return SOLV_CALL_SUCCESS;
     1688}
     1689
    15441690
    15451691extern int CbcOrClpRead_mode;
     
    15571703                        pCoin->clp->initialSolve();
    15581704                }
    1559                 pCoin->SolutionStatus = pCoin->clp->status();
     1705                pCoin->pResult->SolutionStatus = pCoin->clp->status();
    15601706                }
    15611707        else {
     
    15731719                        const char* argv[] = {"CoinMP", "-solve", "-quit"};
    15741720                        CbcMain1(argc,argv,*pCoin->cbc);
    1575                         pCoin->SolutionStatus = pCoin->cbc->status();
     1721                        pCoin->pResult->SolutionStatus = pCoin->cbc->status();
    15761722                        }
    15771723                else
     
    15841730                        pCoin->cbc->initialSolve();
    15851731                        pCoin->cbc->branchAndBound();
    1586                         pCoin->SolutionStatus = pCoin->cbc->status();
     1732                        pCoin->pResult->SolutionStatus = pCoin->cbc->status();
    15871733                }
    15881734        }       
    1589         return pCoin->SolutionStatus;
     1735        CbcRetrieveSolutionResults(hProb, pCoin->pResult);
     1736        return pCoin->pResult->SolutionStatus;
    15901737}
    15911738
     
    16011748        PCOIN pCoin = (PCOIN)hProb;
    16021749
    1603         return pCoin->SolutionStatus;
     1750        return pCoin->pResult->SolutionStatus;
    16041751}
    16051752
     
    16111758        PCOIN pCoin = (PCOIN)hProb;
    16121759
    1613         switch (SolutionStatus) {
    1614                 case 0: strcpy(pCoin->SolutionText, "Optimal solution found");          break;
    1615                 case 1: strcpy(pCoin->SolutionText, "Problem primal infeasible");       break;
    1616                 case 2: strcpy(pCoin->SolutionText, "Problem dual infeasible");         break;
    1617                 case 3: strcpy(pCoin->SolutionText, "Stopped on iterations");                   break;
    1618                 case 4: strcpy(pCoin->SolutionText, "Stopped due to errors");                   break;
    1619                 case 5: strcpy(pCoin->SolutionText, "Stopped by user");         break;
    1620                 default:
    1621                         sprintf(pCoin->SolutionText, "Unknown solution status (%d)", SolutionStatus);
    1622                         break;
    1623         }
    1624         return pCoin->SolutionText;
     1760        return pCoin->pResult->SolutionText;
    16251761}
    16261762
     
    16371773SOLVAPI double SOLVCALL CoinGetObjectValue(HPROB hProb)
    16381774{
    1639    PCOIN pCoin = (PCOIN)hProb;
    1640 
    1641         if (!pCoin->SolveAsMIP)
    1642                 return pCoin->clp->objectiveValue() + pCoin->ObjectConst;
    1643         else {
    1644                 return pCoin->cbc->getObjValue() + pCoin->ObjectConst;
    1645         }
     1775        PCOIN pCoin = (PCOIN)hProb;
     1776
     1777        return pCoin->pResult->ObjectValue + pCoin->ObjectConst;
    16461778}
    16471779
     
    16491781SOLVAPI double SOLVCALL CoinGetMipBestBound(HPROB hProb)
    16501782{
    1651    PCOIN pCoin = (PCOIN)hProb;
    1652 
    1653         if (!pCoin->SolveAsMIP)
    1654                 return 0;
    1655         else {
    1656                 return pCoin->cbc->getBestPossibleObjValue();
    1657         }
     1783        PCOIN pCoin = (PCOIN)hProb;
     1784
     1785        return pCoin->pResult->MipBestBound;
    16581786}
    16591787
     
    16621790SOLVAPI int SOLVCALL CoinGetIterCount(HPROB hProb)
    16631791{
    1664    PCOIN pCoin = (PCOIN)hProb;
    1665 
    1666         if (!pCoin->SolveAsMIP)
    1667                 return pCoin->clp->numberIterations();
    1668         else {
    1669                 return pCoin->cbc->getIterationCount();
    1670         }
     1792        PCOIN pCoin = (PCOIN)hProb;
     1793
     1794        return pCoin->pResult->IterCount;
    16711795}
    16721796
     
    16741798SOLVAPI int SOLVCALL CoinGetMipNodeCount(HPROB hProb)
    16751799{
    1676    PCOIN pCoin = (PCOIN)hProb;
    1677 
    1678         if (!pCoin->SolveAsMIP)
    1679                 return 0;
    1680         else {
    1681                 return pCoin->cbc->getNodeCount();
    1682         }
     1800        PCOIN pCoin = (PCOIN)hProb;
     1801
     1802        return pCoin->pResult->MipNodeCount;
    16831803}
    16841804
     
    16931813                                                                                         double* SlackValues, double* ShadowPrice)
    16941814{
    1695    PCOIN pCoin = (PCOIN)hProb;
    1696         const double* columnPrimal;
    1697         const double* columnDual;
    1698         const double* rowPrimal;
    1699         const double* rowDual;
    1700         int i;
    1701 
    1702         if (pCoin->SolveAsMIP) {
    1703                 if (Activity) {
    1704                         columnPrimal = pCoin->cbc->solver()->getColSolution();
    1705                         for (i = 0; i < pCoin->ColCount; i++) {
    1706                                 Activity[i] = columnPrimal[i];
    1707                         }
    1708                         return SOLV_CALL_SUCCESS;
    1709                 }
    1710                 return SOLV_CALL_FAILED;
    1711         }
    1712 
    1713         if (Activity) {
    1714                 columnPrimal = pCoin->clp->primalColumnSolution();
    1715                 for (i = 0; i < pCoin->ColCount; i++) {
    1716                         Activity[i] = columnPrimal[i];
    1717                 }
    1718         }
    1719         if (ReducedCost) {
    1720                 columnDual = pCoin->clp->dualColumnSolution();
    1721                 for (i = 0; i < pCoin->ColCount; i++) {
    1722                         ReducedCost[i] = columnDual[i];
    1723                 }
    1724         }
    1725         if (SlackValues) {
    1726                 rowPrimal = pCoin->clp->primalRowSolution();
    1727                 for (i = 0; i < pCoin->RowCount; i++) {
    1728                         SlackValues[i] = rowPrimal[i];
    1729                 }
    1730         }
    1731         if (ShadowPrice) {
    1732                 rowDual = pCoin->clp->dualRowSolution();
    1733                 for (i = 0; i < pCoin->RowCount; i++) {
    1734                         ShadowPrice[i] = rowDual[i];
    1735                 }
     1815        PCOIN pCoin = (PCOIN)hProb;
     1816        PRESULT pResult = pCoin->pResult;
     1817
     1818        if (Activity && pResult->ColActivity) {
     1819                memcpy(Activity, pResult->ColActivity, pCoin->ColCount * sizeof(double));
     1820        }
     1821        if (ReducedCost && pResult->ReducedCost) {
     1822                memcpy(ReducedCost, pResult->ReducedCost, pCoin->ColCount * sizeof(double));
     1823        }
     1824        if (SlackValues && pResult->SlackValues) {
     1825                memcpy(SlackValues, pResult->SlackValues, pCoin->RowCount * sizeof(double));
     1826        }
     1827        if (ShadowPrice && pResult->ShadowPrice) {
     1828                memcpy(ShadowPrice, pResult->ShadowPrice, pCoin->RowCount * sizeof(double));
    17361829        }
    17371830        return SOLV_CALL_SUCCESS;
     
    17431836                                                                                         double* RhsLoRange, double* RhsUpRange)
    17441837{
    1745         return SOLV_CALL_FAILED;
     1838        PCOIN pCoin = (PCOIN)hProb;
     1839        PRESULT pResult = pCoin->pResult;
     1840
     1841        if (ObjLoRange && pResult->ObjLoRange) {
     1842                memcpy(ObjLoRange, pResult->ObjLoRange, pCoin->ColCount * sizeof(double));
     1843        }
     1844        if (ObjUpRange && pResult->ObjUpRange) {
     1845                memcpy(ObjUpRange, pResult->ObjUpRange, pCoin->ColCount * sizeof(double));
     1846        }
     1847        if (RhsLoRange && pResult->RhsLoRange) {
     1848                memcpy(RhsLoRange, pResult->RhsLoRange, pCoin->RowCount * sizeof(double));
     1849        }
     1850        if (RhsUpRange && pResult->RhsUpRange) {
     1851                memcpy(RhsUpRange, pResult->RhsUpRange, pCoin->RowCount * sizeof(double));
     1852        }
     1853        return SOLV_CALL_SUCCESS;
    17461854}
    17471855
     
    17501858SOLVAPI int SOLVCALL CoinGetSolutionBasis(HPROB hProb, int* ColStatus, double* RowStatus)
    17511859{
    1752         return SOLV_CALL_FAILED;
     1860        PCOIN pCoin = (PCOIN)hProb;
     1861        PRESULT pResult = pCoin->pResult;
     1862
     1863        if (ColStatus && pResult->ColStatus) {
     1864                memcpy(ColStatus, pResult->ColStatus, pCoin->ColCount * sizeof(int));
     1865        }
     1866        if (RowStatus && pResult->RowStatus) {
     1867                memcpy(RowStatus, pResult->RowStatus, pCoin->RowCount * sizeof(int));
     1868        }
     1869        return SOLV_CALL_SUCCESS;
    17531870}
    17541871
Note: See TracChangeset for help on using the changeset viewer.