Changeset 136


Ignore:
Timestamp:
Nov 28, 2006 4:25:16 PM (13 years ago)
Author:
ladanyi
Message:

fix linking for bonminbcp

Location:
branches/devel/Bonmin/experimental/Bcp
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • branches/devel/Bonmin/experimental/Bcp/BM.hpp

    r116 r136  
    6565        //
    6666        BranchingStrategy,
     67        FullStrongBranch,
    6768        NumNlpFailureMax,
    6869        WarmStartStrategy,
     
    259260                                BCP_vec<BCP_lp_branching_object*>& cans);
    260261
     262    BCP_branching_decision bbBranch(OsiBranchingInformation& brInfo,
     263                                    BCP_vec<BCP_lp_branching_object*>& cands);
     264    BCP_branching_decision hybridBranch();
     265
    261266    virtual void
    262267    set_user_data_for_children(BCP_presolved_lp_brobj* best,
  • branches/devel/Bonmin/experimental/Bcp/BM_lp_branch.cpp

    r117 r136  
    3131    }
    3232
    33     // FIXME: for now let's work on pure B&B, though most of this will work
    34     // FIXME: for general hybrid algo
     33    OsiBranchingInformation brInfo(&nlp, false);
     34    brInfo.cutoff_ = objLimit;
     35    brInfo.integerTolerance_ = intTol;
     36    brInfo.timeRemaining_ = get_param(BCP_lp_par::MaxRunTime) - CoinCpuTime();
     37    brInfo.numberSolutions_ = 0; /*FIXME*/
     38    brInfo.numberBranchingSolutions_ = 0; /*FIXME numBranchingSolutions_;*/
     39    brInfo.depth_ = current_level();
     40
     41    BCP_branching_decision brDecision;
    3542    if (par.entry(BM_par::PureBranchAndBound)) {
    36         BCP_branching_decision retCode;
    37         OsiBranchingObject* brObj = NULL;
    38         OsiBranchingInformation brInfo(&nlp, false);
    39 
    40         brInfo.cutoff_ = objLimit;
    41         brInfo.integerTolerance_ = intTol;
    42         brInfo.timeRemaining_ =
    43             get_param(BCP_lp_par::MaxRunTime) - CoinCpuTime();
    44 
    45         brInfo.numberSolutions_ = 0; /*FIXME*/
    46         brInfo.numberBranchingSolutions_ = 0; /*FIXME numBranchingSolutions_;*/
    47         brInfo.depth_ = current_level();
    48 
    49         const int numCols = nlp.getNumCols();
    50         double* clb_old = new double[numCols];
    51         double* cub_old = new double[numCols];
    52         CoinDisjointCopyN(nlp.getColLower(), numCols, clb_old);
    53         CoinDisjointCopyN(nlp.getColUpper(), numCols, cub_old);
    54 
    55         OsiChooseVariable* choose = NULL;
    56         switch (par.entry(BM_par::BranchingStrategy)) {
    57         case BM_OsiChooseVariable:
    58             choose = new OsiChooseVariable(&nlp);
    59             // choose->setNumberStrong(1);
    60             break;
    61         case BM_OsiChooseStrong:
    62             OsiChooseStrong* strong = new OsiChooseStrong(&nlp);
    63             strong->setNumberBeforeTrusted(5); // the default in Cbc
    64             choose->setNumberStrong(5); // the default in Cbc
    65             /** Pseudo Shadow Price mode
    66                 0 - off
    67                 1 - use and multiply by strong info
    68                 2 - use
    69             */
    70             strong->setShadowPriceMode(0);
    71             choose = strong;
    72             break;
    73         }
    74 
    75         const int brResult = try_to_branch(brInfo, &nlp, choose, brObj, true);
     43        brDecision = bbBranch(brInfo, cands);
     44    } else {
     45        brDecision = hybridBranch();
     46    }
     47
     48    return brDecision;
     49}
     50
     51//-----------------------------------------------------------------------------
     52
     53BCP_branching_decision
     54BM_lp::hybridBranch()
     55{
     56    // FIXME: most of the pureBB stuff should work here.
     57    throw BCP_fatal_error("BM_lp: FIXME: make hybrid work...");
     58}
     59
     60//-----------------------------------------------------------------------------
     61
     62BCP_branching_decision
     63BM_lp::bbBranch(OsiBranchingInformation& brInfo,
     64                BCP_vec<BCP_lp_branching_object*>& cands)
     65{
     66    BCP_branching_decision retCode;
     67    OsiBranchingObject* brObj = NULL;
     68
     69    const int numCols = nlp.getNumCols();
     70    double* clb_old = new double[numCols];
     71    double* cub_old = new double[numCols];
     72    CoinDisjointCopyN(nlp.getColLower(), numCols, clb_old);
     73    CoinDisjointCopyN(nlp.getColUpper(), numCols, cub_old);
     74
     75    OsiChooseVariable* choose = NULL;
     76    switch (par.entry(BM_par::BranchingStrategy)) {
     77    case BM_OsiChooseVariable:
     78        choose = new OsiChooseVariable(&nlp);
     79        // choose->setNumberStrong(1);
     80        break;
     81    case BM_OsiChooseStrong:
     82        OsiChooseStrong* strong = new OsiChooseStrong(&nlp);
     83        strong->setNumberBeforeTrusted(5); // the default in Cbc
     84        choose->setNumberStrong(5); // the default in Cbc
     85        /** Pseudo Shadow Price mode
     86            0 - off
     87            1 - use and multiply by strong info
     88            2 - use
     89        */
     90        strong->setShadowPriceMode(0);
     91        choose = strong;
     92        break;
     93    }
     94
     95    const int brResult = try_to_branch(brInfo, &nlp, choose, brObj, true);
    7696
    7797#if 0
    78         if (choose->goodSolution()) {
    79             /* yipee! a feasible solution! Check that it's really */
    80             const double* sol = choose->goodSolution();
    81             BM_solution* bmsol = new BM_solution;
    82             //Just copy the solution stored in solver to sol
    83             double ptol;
    84             nlp.getDblParam(OsiPrimalTolerance, ptol);
    85             for (int i = 0 ; i < numCols ; i++) {
    86                 if (fabs(sol[i]) > ptol)
    87                     bmsol->add_entry(i, sol[i]);
    88             }
    89             bmsol->setObjective(choose->goodObjectiveValue());
    90             choose->clearGoodSolution();
    91             send_feasible_solution(bmsol);
    92             delete bmsol;
    93         }
     98    if (choose->goodSolution()) {
     99        /* yipee! a feasible solution! Check that it's really */
     100        const double* sol = choose->goodSolution();
     101        BM_solution* bmsol = new BM_solution;
     102        //Just copy the solution stored in solver to sol
     103        double ptol;
     104        nlp.getDblParam(OsiPrimalTolerance, ptol);
     105        for (int i = 0 ; i < numCols ; i++) {
     106            if (fabs(sol[i]) > ptol)
     107                bmsol->add_entry(i, sol[i]);
     108        }
     109        bmsol->setObjective(choose->goodObjectiveValue());
     110        choose->clearGoodSolution();
     111        send_feasible_solution(bmsol);
     112        delete bmsol;
     113    }
    94114#endif
    95         switch (brResult) {
    96         case -2:
    97             // when doing strong branching a candidate has proved that the
    98             // problem is infeasible
    99             retCode = BCP_DoNotBranch_Fathomed;
    100             break;
    101         case -1:
    102             // OsiChooseVariable::chooseVariable() returned 2, 3, or 4
    103             if (!brObj) {
    104                 // just go back and resolve
    105                 retCode = BCP_DoNotBranch;
    106             } else {
    107                 // otherwise might as well branch. The forced variable is
    108                 // unlikely to jump up one more (though who knows...)
    109                 retCode = BCP_DoBranch;
    110             }
    111             break;
    112         case 0:
    113             if (!brObj) {
    114                 // nothing got fixed, yet couldn't find something to branch on
    115                 throw BCP_fatal_error("BM: Couldn't branch!\n");
    116             }
    117             // we've got a branching object
     115    switch (brResult) {
     116    case -2:
     117        // when doing strong branching a candidate has proved that the
     118        // problem is infeasible
     119        retCode = BCP_DoNotBranch_Fathomed;
     120        break;
     121    case -1:
     122        // OsiChooseVariable::chooseVariable() returned 2, 3, or 4
     123        if (!brObj) {
     124            // just go back and resolve
     125            retCode = BCP_DoNotBranch;
     126        } else {
     127            // otherwise might as well branch. The forced variable is
     128            // unlikely to jump up one more (though who knows...)
    118129            retCode = BCP_DoBranch;
    119             break;
    120         default:
    121             throw BCP_fatal_error("\
     130        }
     131        break;
     132    case 0:
     133        if (!brObj) {
     134            // nothing got fixed, yet couldn't find something to branch on
     135            throw BCP_fatal_error("BM: Couldn't branch!\n");
     136        }
     137        // we've got a branching object
     138        retCode = BCP_DoBranch;
     139        break;
     140    default:
     141        throw BCP_fatal_error("\
    122142BM: BCP_lp_user::try_to_branch returned with unknown return code.\n");
    123         }
    124 
    125         if (brResult < 0) {
    126             // If there were some fixings (brResult < 0) then propagate them
    127             // where needed
    128             if (brResult < 0) {
    129                 const double* clb = nlp.getColLower();
    130                 const double* cub = nlp.getColUpper();
    131                 BCP_lp_prob* p = getLpProblemPointer();
    132                 BCP_vec<BCP_var*>& vars = p->node->vars;
    133                 OsiSolverInterface* lp = p->lp_solver;
    134                 for (int i = 0; i < numCols; ++i) {
    135                     if (clb_old[i] != clb[i] || cub_old[i] != cub[i]) {
    136                         vars[i]->change_bounds(clb[i], cub[i]);
    137                         lp->setColBounds(i, clb[i], cub[i]);
    138                     }
    139                 }
    140             }
    141         }
    142 
    143         if (retCode == BCP_DoBranch) {
    144             // all possibilities are 2-way branches
    145             int order[2] = {0, 1};
    146             // Now interpret the result (at this point we must have a brObj
    147             OsiIntegerBranchingObject* intBrObj =
    148                 dynamic_cast<OsiIntegerBranchingObject*>(brObj);
    149             if (intBrObj) {
    150                 if (intBrObj->firstBranch() == 1) {
    151                     order[0] = 1;
    152                     order[1] = 0;
    153                 }
    154                 BCP_lp_integer_branching_object o(intBrObj);
    155                 cands.push_back(new BCP_lp_branching_object(o, order));
    156                 if (par.entry(BM_par::PrintBranchingInfo)) {
    157                     printf("BM_lp: branching on variable %i   value: %f\n",
    158                            intBrObj->originalObject()->columnNumber(),
    159                            intBrObj->value());
    160                 }
    161             }
    162             OsiSOSBranchingObject* sosBrObj =
    163                 dynamic_cast<OsiSOSBranchingObject*>(brObj);
    164             if (sosBrObj) {
    165                 if (sosBrObj->firstBranch() == 1) {
    166                     order[0] = 1;
    167                     order[1] = 0;
    168                 }
    169                 BCP_lp_sos_branching_object o(sosBrObj);
    170                 cands.push_back(new BCP_lp_branching_object(&nlp, o, order));
    171                 if (par.entry(BM_par::PrintBranchingInfo)) {
    172                     printf("BM_lp: branching on SOS %i   value: %f\n",
    173                            sosBrObj->originalObject()->columnNumber(),
    174                            sosBrObj->value());
    175                 }
    176             }
    177         }
    178 
    179         delete brObj;
    180         delete[] clb_old;
    181         delete[] cub_old;
    182         delete choose;
    183         return retCode;
    184 
    185     } else { // not pure B&B
    186         throw BCP_fatal_error("BM_lp: FIXME: make hybrid work...");
    187     }
    188 
    189     return BCP_DoBranch; // to quiet gcc
     143    }
     144
     145    bool distributedStrongBranching =
     146        (retCode == BCP_DoBranch) && (par.entry(BM_par::FullStrongBranch) > 0);
     147
     148    if (brResult < 0) {
     149        // If there were some fixings (brResult < 0) then propagate them
     150        // where needed
     151        const double* clb = nlp.getColLower();
     152        const double* cub = nlp.getColUpper();
     153        BCP_lp_prob* p = getLpProblemPointer();
     154        BCP_vec<BCP_var*>& vars = p->node->vars;
     155        OsiSolverInterface* lp = p->lp_solver;
     156        if (distributedStrongBranching) {
     157            retCode = retCode;
     158        }
     159        for (int i = 0; i < numCols; ++i) {
     160            if (clb_old[i] != clb[i] || cub_old[i] != cub[i]) {
     161                vars[i]->change_bounds(clb[i], cub[i]);
     162                lp->setColBounds(i, clb[i], cub[i]);
     163            }
     164        }
     165    }
     166
     167    if (retCode == BCP_DoBranch) {
     168        // all possibilities are 2-way branches
     169        int order[2] = {0, 1};
     170        // Now interpret the result (at this point we must have a brObj
     171        OsiIntegerBranchingObject* intBrObj =
     172            dynamic_cast<OsiIntegerBranchingObject*>(brObj);
     173        if (intBrObj) {
     174            if (intBrObj->firstBranch() == 1) {
     175                order[0] = 1;
     176                order[1] = 0;
     177            }
     178            BCP_lp_integer_branching_object o(intBrObj);
     179            cands.push_back(new BCP_lp_branching_object(o, order));
     180            if (par.entry(BM_par::PrintBranchingInfo)) {
     181                printf("BM_lp: branching on variable %i   value: %f\n",
     182                       intBrObj->originalObject()->columnNumber(),
     183                       intBrObj->value());
     184            }
     185        }
     186        OsiSOSBranchingObject* sosBrObj =
     187            dynamic_cast<OsiSOSBranchingObject*>(brObj);
     188        if (sosBrObj) {
     189            if (sosBrObj->firstBranch() == 1) {
     190                order[0] = 1;
     191                order[1] = 0;
     192            }
     193            BCP_lp_sos_branching_object o(sosBrObj);
     194            cands.push_back(new BCP_lp_branching_object(&nlp, o, order));
     195            if (par.entry(BM_par::PrintBranchingInfo)) {
     196                printf("BM_lp: branching on SOS %i   value: %f\n",
     197                       sosBrObj->originalObject()->columnNumber(),
     198                       sosBrObj->value());
     199            }
     200        }
     201    }
     202
     203    delete brObj;
     204    delete[] clb_old;
     205    delete[] cub_old;
     206    delete choose;
     207    return retCode;
    190208}
    191209
  • branches/devel/Bonmin/experimental/Bcp/Makefile.am

    r124 r136  
    3131        $(IPOPTOBJDIR)/src/Interfaces/libipopt.la
    3232
    33 LIBS += `cat $(IPOPTOBJDIR)/src/Interfaces/ipopt_addlibs_cpp.txt`
    34 LIBS += `cat $(COINUTILSOBJDIR)/coinutils_addlibs.txt`
     33LIBS += `cat $(IPOPTOBJDIR)/src/Interfaces/ipopt_addlibs_cpp.txt` \
     34        `cat $(BCPOBJDIR)/bcp_addlibs.txt` \
     35        `cat $(CBCOBJDIR)/cbc_addlibs.txt` \
     36        `cat $(CGLOBJDIR)/cgl_addlibs.txt` \
     37        `cat $(OSIOBJDIR)/osi_addlibs.txt` \
     38        `cat $(CLPOBJDIR)/clp_addlibs.txt` \
     39        `cat $(COINUTILSOBJDIR)/coinutils_addlibs.txt`
    3540
    3641########################################################################
  • branches/devel/Bonmin/experimental/Bcp/Makefile.in

    r124 r136  
    217217LIBS = @LIBS@ `cat \
    218218        $(IPOPTOBJDIR)/src/Interfaces/ipopt_addlibs_cpp.txt` `cat \
     219        $(BCPOBJDIR)/bcp_addlibs.txt` `cat \
     220        $(CBCOBJDIR)/cbc_addlibs.txt` `cat \
     221        $(CGLOBJDIR)/cgl_addlibs.txt` `cat \
     222        $(OSIOBJDIR)/osi_addlibs.txt` `cat \
     223        $(CLPOBJDIR)/clp_addlibs.txt` `cat \
    219224        $(COINUTILSOBJDIR)/coinutils_addlibs.txt`
    220225LIBTOOL = @LIBTOOL@
Note: See TracChangeset for help on using the changeset viewer.