Changeset 123


Ignore:
Timestamp:
Nov 21, 2006 11:49:06 AM (13 years ago)
Author:
pbonami
Message:

This time filter works.
Also upgraded nodeSolver

Location:
branches/devel/Bonmin/src
Files:
3 deleted
14 edited
1 moved

Legend:

Unmodified
Added
Removed
  • branches/devel/Bonmin/src/Apps/BonMin.cpp

    r90 r123  
    2828
    2929using namespace Bonmin;
    30 
    31 /** Procedure to ouptut relevant informations in the case of a failure.
    32     si1 should be the problem solved at a node of the b&b tree, and si2 the original problem.
    33     Compare the two problems stored in si1 and si2
    34     and writes files with bounds which have changed.
    35     Also outputs a file with the starting point of si1.
    36 
    37 */
    38 void writeNodeFiles(const OsiSolverInterface& si1,const OsiTMINLPInterface& si2)
    39 {
    40   const int numcols = si1.getNumCols();
    41   const int numrows = si1.getNumRows();
    42   assert( numcols==si2.getNumCols());
    43  
    44   const double * currentLower = si1.getColLower();
    45   const double * currentUpper = si1.getColUpper();
    46 
    47   const double * originalLower = si2.problem()->orig_x_l();
    48   const double * originalUpper = si2.problem()->orig_x_u();
    49   CoinRelFltEq eq;
    50   std::string fBoundsName;
    51   si2.getStrParam(OsiProbName,fBoundsName);
    52   fBoundsName+="_bounds";
    53  
    54   std::string fModName = fBoundsName + ".mod";
    55   std::ofstream fBounds;
    56   std::ofstream fMod;
    57   bool hasVarNames = 0;
    58  
    59   if(si2.getVarNames()!=NULL )
    60       hasVarNames=1;
    61   if(hasVarNames)
    62     fMod.open(fModName.c_str());
    63   fBounds.open(fBoundsName.c_str());
    64    
    65   for(int i = 0 ; i < numcols ; i++)
    66     {   
    67     if(!eq(currentLower[i],originalLower[i]))
    68       {
    69         if(hasVarNames)
    70           fMod<<"bounds"<<i<<": "
    71               <<si2.getVarNames()[i]<<" >= "
    72               <<currentLower[i]<<";\n";
    73 
    74 
    75         fBounds<<"LO"<<"\t"<<i<<"\t"<<currentLower[i]<<std::endl;
    76     }
    77     if(!eq(currentUpper[i],originalUpper[i]))
    78       {
    79         if(hasVarNames)
    80           fMod<<"bounds"<<i<<": "
    81               <<si2.getVarNames()[i]<<" <= "
    82               <<currentUpper[i]<<";\n";
    83        
    84         fBounds<<"UP"<<"\t"<<i<<"\t"<<currentUpper[i]<<std::endl;
    85       }
    86     }
    87  
    88     //write a file with starting point
    89     std::string fStartPointName;
    90     si2.getStrParam(OsiProbName,fStartPointName);
    91     fStartPointName+="_start";
    92 
    93 
    94 
    95     const OsiTMINLPInterface* nlpSolver = dynamic_cast<const OsiTMINLPInterface *>(&si1);
    96     assert(nlpSolver);
    97 
    98     const double * primals = nlpSolver->problem()->x_init();
    99     const double * duals = nlpSolver->problem()->duals_init();
    100 
    101     if(!primals)//No starting point no output
    102       {
    103         std::cerr<<"A failure has occured but no starting point exists"<<std::endl;
    104         return;
    105       }
    106 
    107     std::ofstream fStartPoint(fStartPointName.c_str());
    108     fStartPoint.precision(17);
    109     fStartPoint<<numcols<<"\t"<<2*numcols+numrows<<std::endl;
    110     for(int i = 0 ; i < numcols ; i++)
    111     fStartPoint<<primals[i]<<std::endl;
    112     int end = 2*numcols + numrows;
    113     if(duals)
    114       {
    115         for(int i = 0 ; i < end; i++)
    116           fStartPoint<<duals[i]<<std::endl;
    117       }
    118 
    119 }
    12030
    12131int main (int argc, char *argv[])
     
    207117  }
    208118  catch(TNLPSolver::UnsolvedError *E) {
     119     E->writeDiffFiles();
    209120     E->printError(std::cerr);
    210121    //There has been a failure to solve a problem with Ipopt.
     
    212123    //Now depending on what algorithm has been called (B-BB or other) the failed problem may be at different place.
    213124    //    const OsiSolverInterface &si1 = (algo > 0) ? nlpSolver : *model.solver();
    214     writeNodeFiles(*nlp_and_solver, *nlp_and_solver);
    215125  }
    216126  catch(OsiTMINLPInterface::SimpleError &E) {
  • branches/devel/Bonmin/src/Apps/BonNodeSolver.cpp

    r119 r123  
    1818#include <iomanip>
    1919
     20#include "BonminConfig.h"
    2021
    2122#include "BonAmplInterface.hpp"
     
    2324#include "BonBoundsReader.hpp"
    2425#include "BonStartPointReader.hpp"
    25 
     26#ifdef COIN_HAS_FSQP
     27#include "BonFilterSolver.cpp"
     28#endif
    2629#include "CoinTime.hpp"
    2730
     
    5659  myArgv[2]= NULL;//new char[1];
    5760
     61  //We need to build dummy solver objects to get the options, determine which is the solver to use and register all the options
     62  Ipopt::SmartPtr<IpoptSolver> dummy_ipopt = new IpoptSolver;
     63  OsiTMINLPInterface forOption(GetRawPtr(dummy_ipopt));
    5864
    59   Bonmin::AmplInterface nlpSolver(myArgv, new IpoptSolver);
     65
     66  int solverUsed = 0; // 0 is Ipopt, 1 is Filter
     67  forOption.solver()->Options()->GetEnumValue("nlp_solver", solverUsed,"bonmin.");
     68
     69
     70  Ipopt::SmartPtr<TNLPSolver> solver;
     71  if(solverUsed == 0)
     72    solver = new IpoptSolver;
     73  else if(solverUsed == 1)
     74#ifdef COIN_HAS_FSQP
     75    solver = new FilterSolver;
     76#else
     77    {
     78      std::cerr<<"filterSQP is not propoerly configured for using into Bonmin"<<std::endl
     79               <<"be sure to run the configure script with options:"<<std::endl
     80               <<"--with-filtersqp_lib=\"<path_to_filter_library>\""<<std::endl
     81               <<"--with-filtersqp_incdir=\"\""<<std::endl;
     82               throw -1;
     83      }
     84#endif
     85  else
     86    {
     87      std::cerr<<"Trying to use unknown solver."<<std::endl;
     88    }
     89
     90  Bonmin::AmplInterface nlpSolver(myArgv, solver);
    6091
    6192  Ipopt::SmartPtr<Ipopt::OptionsList> Options =
  • branches/devel/Bonmin/src/Apps/Makefile.am

    r105 r123  
    121121########################################################################
    122122
    123 nodeSolver_SOURCES = nodeSolver.cpp
     123nodeSolver_SOURCES = BonNodeSolver.cpp
    124124
    125125nodeSolver_LDADD = \
  • branches/devel/Bonmin/src/Apps/Makefile.in

    r105 r123  
    105105        $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_2) \
    106106        $(am__DEPENDENCIES_5) $(am__DEPENDENCIES_2)
    107 am_nodeSolver_OBJECTS = nodeSolver.$(OBJEXT)
     107am_nodeSolver_OBJECTS = BonNodeSolver.$(OBJEXT)
    108108nodeSolver_OBJECTS = $(am_nodeSolver_OBJECTS)
    109109nodeSolver_DEPENDENCIES = ../Interfaces/Ampl/libamplinterface.la \
     
    405405#                              nodeSolver                              #
    406406########################################################################
    407 nodeSolver_SOURCES = nodeSolver.cpp
     407nodeSolver_SOURCES = BonNodeSolver.cpp
    408408nodeSolver_LDADD = \
    409409        ../Interfaces/Ampl/libamplinterface.la \
     
    532532
    533533@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BonMin.Po@am__quote@
     534@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BonNodeSolver.Po@am__quote@
    534535@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcBranchUser.Plo@am__quote@
    535536@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcCompareUser.Plo@am__quote@
    536 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nodeSolver.Po@am__quote@
    537537
    538538.cpp.o:
  • branches/devel/Bonmin/src/CbcBonmin/BonCbc.hpp

    r67 r123  
    7171    virtual void replaceIntegers(OsiObject ** objects, int numberObjects)
    7272    {};
     73
    7374  private:
    7475    /** Stores the solution of MIP. */
  • branches/devel/Bonmin/src/CbcBonmin/BonCbcNlpStrategy.cpp

    r62 r123  
    133133      std::cout<<"Branching on unsolved node, sequence of unsolved size "<<seqOfUnsolvedSize<<std::endl;
    134134      // Have to make sure that we will branch
    135       OsiTMINLPInterface * ipopt = dynamic_cast<OsiTMINLPInterface *>(solver);
    136       ipopt->forceBranchable();     //      feasible=1;
     135      OsiTMINLPInterface * osiMinlp = dynamic_cast<OsiTMINLPInterface *>(solver);
     136      osiMinlp->forceBranchable();     //      feasible=1;
    137137      returnStatus = 0;
    138138    }
     
    141141        seqOfUnsolvedSize > maxFailure_) {
    142142      hasFailed_ = true;
    143       OsiTMINLPInterface * ipopt =
     143      OsiTMINLPInterface * osiMinlp =
    144144        dynamic_cast<OsiTMINLPInterface *>(solver);
    145145      if (pretendFailIsInfeasible_) {
    146146        //force infeasible
    147         ipopt->forceInfeasible();
     147        osiMinlp->forceInfeasible();
    148148        returnStatus = 2;
    149149      }
    150       else
    151         throw ipopt->newUnsolvedError(0);
     150      else {
     151        std::string probName;
     152        osiMinlp->getStrParam(OsiProbName,probName);
     153        throw osiMinlp->newUnsolvedError(0, osiMinlp->problem(), probName);
     154      }
    152155    }
    153156    return returnStatus;
  • branches/devel/Bonmin/src/Interfaces/BonColReader.cpp

    r55 r123  
    1212
    1313namespace Bonmin{
    14 /** Keywords of the .int file */
    15 static std::string keywords[]= { "priorities", "PRIORITIES",
    16     "special_ordered_set_1",
    17     "SPECIAL_ORDERED_SET_1"};
     14
    1815ColReader::ColReader(const char * fileName)
    1916    :
  • branches/devel/Bonmin/src/Interfaces/BonColReader.hpp

    r55 r123  
    2020
    2121namespace Bonmin{
    22 /** A class for reading a .col file containing name for variable (ampl generated file).
     22/** A class for reading a .col file containing name for variables (usually ampl generated file).
    2323   */
    2424class ColReader
     
    3838  }
    3939
    40   /** Copy the names to varNames */
     40  /** Copy the names to varNames. */
    4141  void copyNames(std::string *varNames, int n_var);
     42
     43  /** Access Names of variable i. */
     44  const std::string& varName(int i){
     45   return varNames_[i];
     46  }
     47
     48  /** Access index of variable str */
     49  int varIndex(const char * str){
     50    return varIndices_[str];
     51  }
    4252private:
    4353  /// Name of the file to read.
  • branches/devel/Bonmin/src/Interfaces/BonOsiTMINLPInterface.cpp

    r114 r123  
    10101010  }
    10111011  else {
    1012     throw newUnsolvedError(optimization_status_);
     1012    std::string probName;
     1013    getStrParam(OsiProbName,probName);
     1014    throw newUnsolvedError(optimization_status_, problem_,
     1015                           probName);
    10131016  }
    10141017}
     
    10441047}
    10451048
     1049#if 0
    10461050void
    10471051OsiTMINLPInterface::readVarNames() const
     
    10701074  return varNames_;
    10711075}
     1076#endif
     1077
    10721078
    10731079void OsiTMINLPInterface::extractSenseRhsAndRange() const
     
    21552161      if(numcols - numberFixed > numberEqualities)
    21562162        {
    2157           throw newUnsolvedError(optimization_status_);
     2163          std::string probName;
     2164          getStrParam(OsiProbName, probName);
     2165          throw newUnsolvedError(optimization_status_, problem_, probName);
    21582166        }
    21592167      double * saveColLow = CoinCopyOfArray(getColLower(), getNumCols());
     
    21822190  else
    21832191#endif
    2184     if(optimization_status_ < -1)//Ipopt failed and the error can not be recovered, throw it
     2192    if(optimization_status_ < -1)//Solver failed and the error can not be recovered, throw it
    21852193  {
    2186     throw newUnsolvedError(optimization_status_);
     2194    std::string probName;
     2195    getStrParam(OsiProbName, probName);
     2196    throw newUnsolvedError(optimization_status_, problem_, probName);
    21872197  }
    21882198  try{
  • branches/devel/Bonmin/src/Interfaces/BonOsiTMINLPInterface.hpp

    r110 r123  
    7171
    7272  // Error when problem is not solved
    73   TNLPSolver::UnsolvedError * newUnsolvedError(int num){
    74     return app_->newUnsolvedError(num);
     73  TNLPSolver::UnsolvedError * newUnsolvedError(int num, Ipopt::SmartPtr<TMINLP2TNLP> problem, std::string name){
     74    return app_->newUnsolvedError(num, problem, name);
    7575  }
    7676  //#############################################################################
     
    859859  }
    860860
    861   /** Read the name of the variables in an ampl .col file. */
    862   void readVarNames() const;
     861//  /** Read the name of the variables in an ampl .col file. */
     862//  void readVarNames() const;
    863863
    864864  //@}
  • branches/devel/Bonmin/src/Interfaces/BonTNLPSolver.cpp

    r103 r123  
     1// (C) Copyright International Business Machines Corporation, 2006
     2// All Rights Reserved.
     3// This code is published under the Common Public License.
     4//
     5// Authors :
     6// Pierre Bonami, International Business Machines Corporation
     7//
     8// Date : 10/02/2006
     9
     10//Bonmin includes
    111#include "BonTNLPSolver.hpp"
     12#include "BonColReader.hpp"
     13
     14//Ipopt includes
    215#include "IpBlas.hpp"
     16
     17//Standard includes
     18#include <fstream>
     19
    320namespace Bonmin{
    421  using namespace Ipopt;
     
    101118}
    102119
    103 
     120void
     121TNLPSolver::UnsolvedError::writeDiffFiles() const{
     122  const int numcols = model_->num_variables();
     123  const int numrows = model_->num_constraints();
     124 
     125  const double * currentLower = model_->x_l();
     126  const double * currentUpper = model_->x_u();
     127
     128  const double * originalLower = model_->orig_x_l();
     129  const double * originalUpper = model_->orig_x_u();
     130  CoinRelFltEq eq;
     131  std::string fBoundsName = name_;
     132  fBoundsName+="_bounds";
     133 
     134  std::string fModName = fBoundsName + ".mod";
     135  std::ofstream fBounds;
     136  std::ofstream fMod;
     137
     138  /** Reader variables names.*/
     139  bool hasVarNames = 0;
     140  ColReader reader(name_);
     141 
     142  if(reader.readFile())
     143      hasVarNames=1;
     144  if(hasVarNames)
     145    fMod.open(fModName.c_str());
     146  fBounds.open(fBoundsName.c_str());
     147   
     148  for(int i = 0 ; i < numcols ; i++)
     149    {   
     150    if(!eq(currentLower[i],originalLower[i]))
     151      {
     152        if(hasVarNames)
     153          fMod<<"bounds"<<i<<": "
     154              <<reader.varName(i)<<" >= "
     155              <<currentLower[i]<<";\n";
     156
     157
     158        fBounds<<"LO"<<"\t"<<i<<"\t"<<currentLower[i]<<std::endl;
     159    }
     160    if(!eq(currentUpper[i],originalUpper[i]))
     161      {
     162        if(hasVarNames)
     163          fMod<<"bounds"<<i<<": "
     164              <<reader.varName(i)<<" <= "
     165              <<currentUpper[i]<<";\n";
     166       
     167        fBounds<<"UP"<<"\t"<<i<<"\t"<<currentUpper[i]<<std::endl;
     168      }
     169    }
     170 
     171    //write a file with starting point
     172    std::string fStartPointName = name_;
     173    fStartPointName+="_start";
     174
     175
     176
     177    const double * primals = model_->x_init();
     178    const double * duals = model_->duals_init();
     179
     180    if(!primals)//No starting point no output
     181      {
     182        std::cerr<<"A failure has occured but no starting point exists"<<std::endl;
     183        return;
     184      }
     185
     186    std::ofstream fStartPoint(fStartPointName.c_str());
     187    fStartPoint.precision(17);
     188    fStartPoint<<numcols<<"\t"<<2*numcols+numrows<<std::endl;
     189    for(int i = 0 ; i < numcols ; i++)
     190    fStartPoint<<primals[i]<<std::endl;
     191    int end = 2*numcols + numrows;
     192    if(duals)
     193      {
     194        for(int i = 0 ; i < end; i++)
     195          fStartPoint<<duals[i]<<std::endl;
     196      }
     197
     198 
     199}
    104200}//end namespace Bonmin
    105201
  • branches/devel/Bonmin/src/Interfaces/BonTNLPSolver.hpp

    r104 r123  
    1 // (C) Copyright International Business Machines (IBM) 2005
     1// (C) Copyright International Business Machines (IBM) 2006
    22// All Rights Reserved.
    33// This code is published under the Common Public License.
     
    5151  public:
    5252    /** Constructor */
    53     UnsolvedError(int errorNum):errorNum_(errorNum)
    54     {}
     53    UnsolvedError(int errorNum = -10000,
     54                  Ipopt::SmartPtr<TMINLP2TNLP> model = NULL,
     55                  std::string name="")
     56    :
     57     errorNum_(errorNum),
     58     model_(model),
     59     name_(name)
     60    {if(name_=="")
     61{
     62        std::cout<<"FIXME"<<std::endl;
     63}}
    5564    /** Print error message.*/
    5665    void printError(std::ostream & os);
     
    6473    /** destructor. */
    6574    virtual ~UnsolvedError(){}
     75    /** write files with differences between input model and
     76        this one */
     77    void writeDiffFiles() const;
    6678  private:
     79    /** Error code (solver dependent). */
    6780    int errorNum_;
     81
     82    /** model_ on which error occured*/
     83    Ipopt::SmartPtr< TMINLP2TNLP > model_;
     84
     85    /** name of the model on which error occured. */
     86    std::string name_;
    6887  }
    6988  ;
    7089
    71   virtual UnsolvedError * newUnsolvedError(int num) = 0;
     90  virtual UnsolvedError * newUnsolvedError(int num,
     91                                           Ipopt::SmartPtr<TMINLP2TNLP> problem,
     92                                           std::string name) = 0;
    7293 
    7394
  • branches/devel/Bonmin/src/Interfaces/Filter/BonFilterSolver.cpp

    r102 r123  
     1// (C) Copyright International Business Machines Corporation, Carnegie Mellon University 2006
     2// All Rights Reserved.
     3// This code is published under the Common Public License.
     4//
     5// Authors :
     6// Pierre Bonami, International Business Machines Corporation
     7//
     8// Date : 10/02/2006
     9
    110#include "BonFilterSolver.hpp"
    211#include <fstream>
     
    7584void objfun_(real *x, fint *n, real * f, real *user, fint * iuser, fint * errflag)
    7685{
    77   tnlpSolved->eval_f(*n, x, 1, *f);
     86  (*errflag) = !tnlpSolved->eval_f(*n, x, 1, *f);
    7887}
    7988
     
    8190void
    8291confun_(real * x, fint * n , fint *m, real *c, real *a, fint * la, real * user, fint * iuser,
    83         fint * errflags){
    84   tnlpSolved->eval_g(*n, x, 1, *m, c);
     92        fint * errflag){
     93  (*errflag) = !tnlpSolved->eval_g(*n, x, 1, *m, c);
    8594}
    8695
     
    8897gradient_(fint *n, fint *m, fint * mxa, real * x, real *a, fint * la,
    8998          fint * maxa, real * user, fint * iuser, fint * errflag){
    90   tnlpSolved->eval_grad_f(*n, x, 1, a);
     99  (*errflag) = !tnlpSolved->eval_grad_f(*n, x, 1, a);
    91100  /// ATTENTION: Filter expect the jacobian to be ordered by row
    92101  int nnz = la[0] - *n - 1;
    93102  double * values = new double [nnz];
    94   tnlpSolved->eval_jac_g(*n, x, 1, *m, nnz, NULL, NULL, values);
     103  (*errflag) = !tnlpSolved->eval_jac_g(*n, x, 1, *m, nnz, NULL, NULL, values) || (*errflag);
    95104  a+= *n;
    96105  for(int i = 0 ; i < nnz ; i++)
     
    113122             fint *l_hess, fint *li_hess, fint *errflag)
    114123{
    115   real obj_factor = (*phase == 1)? 0. : 1.;
     124  Number obj_factor = (*phase == 1)? 0. : 1.;
    116125  fint  end = nnz_h + (*n)  + 2;
    117126
     
    123132  *li_hess = nnz_h + *n + 3;
    124133  end = *n + *m;
    125   //std::cout<<"lambda"<<std::endl;
    126134  for(int i = *n ; i < end ; i++){
    127135    g[i] = - lam[i];
    128    // std::cout<<lam[i]<<"\t";
    129136   }
    130   //std::cout<<std::endl;
    131   real * values = new real [nnz_h];
    132   tnlpSolved->eval_h(*n, x, 1, obj_factor, *m, g + *n ,1, hStruct[0] - 1, NULL, NULL, values);
     137  Number * values = new Number [nnz_h];
     138  (*errflag) = !tnlpSolved->eval_h(*n, x, 1, obj_factor, *m, g + *n ,1, hStruct[0] - 1, NULL, NULL, values);
    133139   for(int i = 0 ; i < nnz_h ; i++) ws[i] = values[permutationHess[i]];
    134140   delete [] values;
  • branches/devel/Bonmin/src/Interfaces/Filter/BonFilterSolver.hpp

    r102 r123  
    1 // (C) Copyright International Business Machines Corporation, Carnegie Mellon University 2006
     1// (C) Copyright International Business Machines Corporation, 2006
    22// All Rights Reserved.
    33// This code is published under the Common Public License.
     
    1717class FilterSolver : public TNLPSolver{
    1818public:
     19
     20
    1921  class UnsolvedFilterError: public TNLPSolver::UnsolvedError
    20 {
    21  public:
    22   UnsolvedFilterError(int errorNum = 10000):
    23   TNLPSolver::UnsolvedError(errorNum)
    24   {}
    25   virtual const std::string& errorName() const;
    26  
    27   virtual const std::string& solverName() const;
    28   virtual ~UnsolvedFilterError(){}
     22  {
     23  public:
     24    UnsolvedFilterError(int errorNum,
     25                        Ipopt::SmartPtr<TMINLP2TNLP> model,
     26                        const std::string &name):
     27      TNLPSolver::UnsolvedError(errorNum, model, name)
     28    {}
     29    virtual const std::string& errorName() const;
     30   
     31    virtual const std::string& solverName() const;
     32    virtual ~UnsolvedFilterError(){}
     33
    2934  private:
    30   static std::string errorNames_[1];
    31   static std::string solverName_;
     35    static std::string errorNames_[1];
     36    static std::string solverName_;
    3237};
    3338
    34   virtual UnsolvedError * newUnsolvedError(int num){
    35     return new UnsolvedFilterError(num);}
     39  virtual UnsolvedError * newUnsolvedError(int num,
     40                                           Ipopt::SmartPtr<TMINLP2TNLP> problem,
     41                                           std::string name){
     42    return new UnsolvedFilterError(num, problem, name);}
    3643
    3744
  • branches/devel/Bonmin/src/Interfaces/Ipopt/BonIpoptSolver.hpp

    r90 r123  
    2020{
    2121 public:
    22   UnsolvedIpoptError(int errorNum = 10000):
    23   TNLPSolver::UnsolvedError(errorNum)
     22  UnsolvedIpoptError(int errorNum,
     23                     Ipopt::SmartPtr<TMINLP2TNLP> problem,
     24                     std::string name):
     25  TNLPSolver::UnsolvedError(errorNum, problem, name)
    2426  {}
    2527  virtual const std::string& errorName() const;
     
    3234};
    3335
    34   virtual UnsolvedError * newUnsolvedError(int num){
    35     return new UnsolvedIpoptError(num);}
     36  virtual UnsolvedError * newUnsolvedError(int num,
     37                                           Ipopt::SmartPtr<TMINLP2TNLP> problem,
     38                                           std::string name){
     39    return new UnsolvedIpoptError(num, problem, name);}
    3640
    3741
Note: See TracChangeset for help on using the changeset viewer.