Changeset 321


Ignore:
Timestamp:
Feb 14, 2007 5:00:09 PM (13 years ago)
Author:
pbelotti
Message:

delegating choice of index to simple expressions

Location:
branches/Couenne/Couenne
Files:
2 added
20 edited

Legend:

Unmodified
Added
Removed
  • branches/Couenne/Couenne/TODO

    r315 r321  
    1 a) add integrality to bound check
    2 b) order in convexifying x*y*z*...*(1/w)*(1/t)*...
    3 c) linear convexification has an acyclic structure where x are leaves
    4 d) linear combination plus aux. vars into one single aux
    5 e) recognition of quadratic forms
    6 f) q.f. partitioning into PD + nonconvex
     1- specialize getFixIndex() for exprPow, exprDiv, and exprMul
     2- add integrality to bound check
     3- order in convexifying x*y*z*...*(1/w)*(1/t)*...
     4- linear convexification has an acyclic structure where x are leaves
     5- linear combination plus aux. vars into one single aux
     6- recognition of quadratic forms
     7- q.f. partitioning into PD + nonconvex
  • branches/Couenne/Couenne/src/Makefile.am

    r315 r321  
    2020libCouenne_la_SOURCES = \
    2121        branch/CouenneBranchingObject.cpp \
     22        branch/CouenneObject.cpp \
    2223        branch/CouenneChooseVariable.cpp \
    2324        expression/operators/exprAbs.cpp \
     
    118119include_HEADERS = \
    119120        ../inc/config_couenne.h \
     121        branch/CouenneObject.hpp \
    120122        branch/CouenneBranchingObject.hpp \
    121123        branch/CouenneChooseVariable.hpp \
  • branches/Couenne/Couenne/src/Makefile.in

    r315 r321  
    7676libCouenne_la_LIBADD =
    7777am__libCouenne_la_SOURCES_DIST = branch/CouenneBranchingObject.cpp \
    78         branch/CouenneChooseVariable.cpp \
     78        branch/CouenneObject.cpp branch/CouenneChooseVariable.cpp \
    7979        expression/operators/exprAbs.cpp \
    8080        expression/operators/exprDiv.cpp \
     
    114114@COIN_HAS_ASL_TRUE@am__objects_1 = readnl.lo nl2e.lo invmap.lo \
    115115@COIN_HAS_ASL_TRUE@     fix_asl_group.lo
    116 am_libCouenne_la_OBJECTS = CouenneBranchingObject.lo \
     116am_libCouenne_la_OBJECTS = CouenneBranchingObject.lo CouenneObject.lo \
    117117        CouenneChooseVariable.lo exprAbs.lo exprDiv.lo exprExp.lo \
    118118        exprInv.lo exprLog.lo exprMul.lo exprOpp.lo exprPow.lo \
     
    320320# List all source files for this library, including headers
    321321libCouenne_la_SOURCES = branch/CouenneBranchingObject.cpp \
    322         branch/CouenneChooseVariable.cpp \
     322        branch/CouenneObject.cpp branch/CouenneChooseVariable.cpp \
    323323        expression/operators/exprAbs.cpp \
    324324        expression/operators/exprDiv.cpp \
     
    394394include_HEADERS = \
    395395        ../inc/config_couenne.h \
     396        branch/CouenneObject.hpp \
    396397        branch/CouenneBranchingObject.hpp \
    397398        branch/CouenneChooseVariable.hpp \
     
    508509@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CouenneChooseVariable.Plo@am__quote@
    509510@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CouenneCutGenerator.Plo@am__quote@
     511@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CouenneObject.Plo@am__quote@
    510512@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/addEnvelope.Plo@am__quote@
    511513@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/constraint.Plo@am__quote@
     
    624626@am__fastdepCXX_FALSE@  $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o CouenneBranchingObject.lo `test -f 'branch/CouenneBranchingObject.cpp' || echo '$(srcdir)/'`branch/CouenneBranchingObject.cpp
    625627
     628CouenneObject.lo: branch/CouenneObject.cpp
     629@am__fastdepCXX_TRUE@   if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT CouenneObject.lo -MD -MP -MF "$(DEPDIR)/CouenneObject.Tpo" -c -o CouenneObject.lo `test -f 'branch/CouenneObject.cpp' || echo '$(srcdir)/'`branch/CouenneObject.cpp; \
     630@am__fastdepCXX_TRUE@   then mv -f "$(DEPDIR)/CouenneObject.Tpo" "$(DEPDIR)/CouenneObject.Plo"; else rm -f "$(DEPDIR)/CouenneObject.Tpo"; exit 1; fi
     631@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='branch/CouenneObject.cpp' object='CouenneObject.lo' libtool=yes @AMDEPBACKSLASH@
     632@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     633@am__fastdepCXX_FALSE@  $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o CouenneObject.lo `test -f 'branch/CouenneObject.cpp' || echo '$(srcdir)/'`branch/CouenneObject.cpp
     634
    626635CouenneChooseVariable.lo: branch/CouenneChooseVariable.cpp
    627636@am__fastdepCXX_TRUE@   if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT CouenneChooseVariable.lo -MD -MP -MF "$(DEPDIR)/CouenneChooseVariable.Tpo" -c -o CouenneChooseVariable.lo `test -f 'branch/CouenneChooseVariable.cpp' || echo '$(srcdir)/'`branch/CouenneChooseVariable.cpp; \
  • branches/Couenne/Couenne/src/branch/CouenneBranchingObject.cpp

    r315 r321  
    1010
    1111
    12 /** \brief Constructor. Get an auxiliary variable as an argument and
    13            set value_ through a call to operator () of that exprAux.
     12/** \brief Constructor. Get a variable as an argument and set value_
     13           through a call to operator () of that exprAux.
    1414*/
    1515
    16 CouenneBranchingObject::CouenneBranchingObject (exprAux *aux):
    17   aux_ (aux) {
    18   // set the branching value at the current point
    19   value_ = (*aux_) ();
    20 }
     16CouenneBranchingObject::CouenneBranchingObject (exprVar *var):
     17  var_ (var)
     18  {value_ = (*var_) ();} // set the branching value at the current point
    2119
    2220
     
    3533
    3634  if (way) // ">=" node, set lower bound (round if this variable is integer)
    37        solver -> setColLower (aux_ -> Index(),
    38                               aux_ -> isInteger() ?
    39                                 ceil  (value_) :
    40                                 value_);
     35    solver -> setColLower (var_ -> Index(),
     36                           var_ -> isInteger() ? ceil  (value_) : value_);
    4137
    42            // "<=" node, set upper bound (ditto)
    43   else solver -> setColUpper (aux_ -> Index(),
    44                               aux_ -> isInteger() ?
    45                                 floor (value_) :
    46                                 value_);
     38
     39  else     // "<=" node, set upper bound (ditto)
     40    solver -> setColUpper (var_ -> Index(),
     41                           var_ -> isInteger() ? floor (value_) : value_);
    4742
    4843  return 0.; // estimated gain in objective function
  • branches/Couenne/Couenne/src/branch/CouenneBranchingObject.hpp

    r315 r321  
    2020
    2121  /// Constructor
    22   CouenneBranchingObject (exprAux *aux);
     22  CouenneBranchingObject (exprVar *);
    2323
    2424  /// Cloning method
    25   virtual CouenneBranchingObject * clone() const
    26   {return new CouenneBranchingObject (aux_);}
     25  virtual OsiBranchingObject * clone() const
     26  {return new CouenneBranchingObject (var_);}
    2727
    2828  /** \brief Execute the actions required to branch, as specified by the
     
    3535protected:
    3636
    37   /// the aux variable which this branching object refers to
    38   exprAux *aux_;
     37  /// the variable which this branching object refers to
     38  exprVar *var_;
    3939};
    4040
  • branches/Couenne/Couenne/src/branch/CouenneChooseVariable.cpp

    r318 r321  
    4444
    4545int CouenneChooseVariable::setupList (OsiBranchingInformation *info, bool initialize) {
     46
     47  problem_ -> update ((CouNumber *) (info -> solution_),
     48                      (CouNumber *) (info -> lower_),
     49                      (CouNumber *) (info -> upper_));
    4650  return 0;
    4751}
  • branches/Couenne/Couenne/src/branch/CouenneChooseVariable.hpp

    r315 r321  
    1111
    1212#include <OsiChooseVariable.hpp>
     13#include <CouenneProblem.h>
    1314
    1415
     
    6970  virtual void updateInformation( const OsiBranchingInformation *info,
    7071                                  int branch, OsiHotInfo * hotInfo);
     72
     73protected:
     74
     75  CouenneProblem *problem_;
    7176};
    7277
  • branches/Couenne/Couenne/src/include/exprCopy.h

    r298 r321  
    101101    {copy_ -> getBounds (lower, upper);}
    102102
    103   // construct linear under-estimator for expression within problem *p
    104   // (p is used to add convexification constraints)
    105   /*  inline int lowerLinearHull (exprAux *w, int *&nterms, expression ***&coeff,
    106                        int **&indices, expression **&rhs, enum con_sign *&sign)
    107     {return copy_ -> lowerLinearHull (w, nterms, coeff, indices, rhs, sign);}
    108   */
    109 
    110   // similarly, construct linear over-estimator for expression within
    111   // problem *p (p is used to add convexification constraints). It is
    112   // also used when this function appears with a minus sign in the
    113   // expression
    114   /*  inline int upperLinearHull (exprAux *w, int *&nterms, expression ***&coeff,
    115                               int **&indices, expression **&rhs, enum con_sign *&sign)
    116     {return copy_ -> upperLinearHull (w, nterms, coeff, indices, rhs, sign);}
    117   */
    118103  // Create standard formulation of this expression
    119104  inline exprAux *standardize (CouenneProblem *p)
     
    124109                            OsiCuts &cs, const CouenneCutGenerator *cg)
    125110    {copy_ -> generateCuts (w, si, cs, cg);}
     111
     112  // return an index to the variable's argument that is better fixed
     113  // in a branching rule for solving a nonconvexity gap
     114  virtual int getFixIndex () {return copy_ -> getFixIndex ();}
    126115};
    127116
  • branches/Couenne/Couenne/src/include/exprOp.h

    r298 r321  
    6464    {return arglist_;}
    6565
    66   inline int          nArgs  () const
     66  inline int nArgs () const
    6767    {return nargs_;}
    6868
     
    103103
    104104  exprAux *standardize (CouenneProblem *);
     105
     106  // return an index to the variable's argument that is better fixed
     107  // in a branching rule for solving a nonconvexity gap
     108  virtual int getFixIndex () {return arglist_ [0] -> Index ();}
    105109};
    106110
     
    122126}
    123127
    124 
    125 //
    126 
    127 //void convert_monomial (expression *, expression *&, int &);
    128 
    129128#endif
  • branches/Couenne/Couenne/src/include/exprUnary.h

    r298 r321  
    3131 public:
    3232
    33   // node type
     33  /// node type
    3434  virtual inline enum nodeType Type ()
    3535    {return UNARY;}
    3636
    37   // Constructors, destructor
     37  /// Constructor
    3838  exprUnary  (expression *argument, unary_function f):
    3939    argument_ (argument),        //< non-leaf expression, with argument list
    4040    f_        (f)         {}
    4141
     42  /// Destructor
    4243  ~exprUnary ()
    4344    {if (argument_) delete argument_;}
    44   /*
    45   // return a pointer to an object with the same type of operator f_
    46   // as this class, and with arg as argument_
    47   virtual inline expression *mirror (expression *arg)
    48     {return new exprUnary (arg, f_);}
    4945
    50   // return a pointer to an object with the same type as the
    51   // derivative of operator f_ as this class, and with arg as argument_
    52   virtual inline expression *mirror_d (expression *arg)
    53     {return new exprUnary (arg, f_);}
    54   */
    55   // return argument (when applicable, i.e., with univariate functions)
     46  /// return argument (when applicable, i.e., with univariate functions)
    5647  virtual inline expression *Argument () const
    5748    {return argument_;}
     
    8980  virtual exprAux *standardize (CouenneProblem *p);
    9081
    91   // for auxiliary variable w = f(x), returns coefficient of x and
    92   // right hand side of the expression
    93   //
    94   // w - (f(ub)-f(lb))/(ub-lb) * x  >=< f(lb) - (f(ub)-f(lb))/(ub-lb) * lb
    95   //
    96   // used as a convexification (lower bound) of a concave function
    97   // (and vice versa, as a concavification -- upper bound -- of a
    98   // convex function). The sign depends on the convexity of the
    99   // operator.
    100   void segment (expression *&, expression *&);
    101 
    102   // for auxiliary variable w = f(x), returns coefficients of x and
    103   // right hand sides of the expressions
    104   //
    105   // w - f'(x_k) * x  >=< f(x_k) - f'(x_k) * x_k
    106   //
    107   // where k is the set of sample points used to create convex
    108   // (concave) hull. Used as a convexification (lower bound) of a
    109   // concave function (and vice versa, as a concavification -- upper
    110   // bound -- of a convex function). The sign depends on the convexity
    111   // of the operator.
    112   void hull (expression **&, expression **&);
     82  // return an index to the variable's argument that is better fixed
     83  // in a branching rule for solving a nonconvexity gap
     84  virtual int getFixIndex () {return argument_ -> Index ();}
    11385};
    11486
  • branches/Couenne/Couenne/src/include/exprVar.h

    r310 r321  
    9898  void generateCuts (exprAux *w, const OsiSolverInterface &si,
    9999                     OsiCuts &cs, const CouenneCutGenerator *cg);
     100
     101  // return an index to the variable's argument that is better fixed
     102  // in a branching rule for solving a nonconvexity gap
     103  virtual int getFixIndex () {return varIndex_;}
    100104};
    101105
  • branches/Couenne/Couenne/src/include/expression.h

    r310 r321  
    172172  virtual void generateCuts (exprAux *, const OsiSolverInterface &,
    173173                             OsiCuts &, const CouenneCutGenerator *) {}
     174
     175  // return an index to the variable's argument that is better fixed
     176  // in a branching rule for solving a nonconvexity gap
     177  virtual int getFixIndex () {return -1;}
    174178};
    175179
  • branches/Couenne/Couenne/src/include/operators/exprDiv.h

    r298 r321  
    6565  void getBounds (expression *&lb, expression *&ub);
    6666
    67   // construct linear under-estimator for expression within problem *p
    68   // (p is used to add convexification constraints)
    69   //  int lowerLinearHull (exprAux *, int *&, expression ***&,
    70   //                   int **&, expression **&, enum con_sign *&);
    71 
    72   // construct linear over-estimator for expression within problem *p
    73   // (p is used to add convexification constraints)
    74   //  int upperLinearHull (exprAux *, int *&, expression ***&,
    75   //                   int **&, expression **&, enum con_sign *&);
    76 
    7767  // reduce expression in standard form, creating additional aux
    7868  // variables (and constraints)
     
    8272  void generateCuts (exprAux *w, const OsiSolverInterface &si,
    8373                     OsiCuts &cs, const CouenneCutGenerator *cg);
     74
     75  // return an index to the variable's argument that is better fixed
     76  // in a branching rule for solving a nonconvexity gap
     77  int getFixIndex () {return arglist_ [0] -> Index ();}
    8478};
    8579
  • branches/Couenne/Couenne/src/include/operators/exprExp.h

    r298 r321  
    4848  void getBounds (expression *&, expression *&);
    4949
    50   // construct linear under-estimator for expression within problem *p
    51   // (p is used to add convexification constraints)
    52   //  int lowerLinearHull (exprAux *, int *&, expression ***&,
    53   //                   int **&, expression **&, enum con_sign *&);
    54 
    55   // construct linear over-estimator for expression within problem *p
    56   // (p is used to add convexification constraints)
    57   //  int upperLinearHull (exprAux *, int *&, expression ***&,
    58   //                   int **&, expression **&, enum con_sign *&);
    59 
    6050  // generate equality between *this and *w
    6151  void generateCuts (exprAux *w, const OsiSolverInterface &si,
  • branches/Couenne/Couenne/src/include/operators/exprInv.h

    r298 r321  
    5757  void getBounds (expression *&, expression *&);
    5858
    59   // construct linear under-estimator for expression within problem *p
    60   // (p is used to add convexification constraints)
    61   //  int lowerLinearHull (exprAux *, int *&, expression ***&,
    62   //                   int **&, expression **&, enum con_sign *&);
    63 
    64   // construct linear over-estimator for expression within problem *p
    65   // (p is used to add convexification constraints)
    66   //  int upperLinearHull (exprAux *, int *&, expression ***&,
    67   //                   int **&, expression **&, enum con_sign *&);
    68 
    6959  // generate equality between *this and *w
    7060  void generateCuts (exprAux *w, const OsiSolverInterface &si,
  • branches/Couenne/Couenne/src/include/operators/exprLog.h

    r298 r321  
    5151    {return new exprInv (arg);}
    5252
    53   // construct linear under-estimator for expression within problem *p
    54   // (p is used to add convexification constraints)
    55   //  int lowerLinearHull (exprAux *, int *&, expression ***&,
    56   //                   int **&, expression **&, enum con_sign *&);
    57 
    58   // construct linear over-estimator for expression within problem *p
    59   // (p is used to add convexification constraints)
    60   //  int upperLinearHull (exprAux *, int *&, expression ***&,
    61   //                   int **&, expression **&, enum con_sign *&);
    62 
    6353  // generate equality between *this and *w
    6454  void generateCuts (exprAux *w, const OsiSolverInterface &si,
  • branches/Couenne/Couenne/src/include/operators/exprMul.h

    r298 r321  
    5454  void getBounds (expression *&, expression *&);
    5555
    56   // construct linear under-estimator for expression within problem *p
    57   // (p is used to add convexification constraints)
    58   //  int lowerLinearHull (exprAux *, int *&, expression ***&,
    59   //                   int **&, expression **&, enum con_sign *&);
    60 
    61   // construct linear over-estimator for expression within problem *p
    62   // (p is used to add convexification constraints)
    63   //  int upperLinearHull (exprAux *, int *&, expression ***&,
    64   //                   int **&, expression **&, enum con_sign *&);
    65 
    6656  // reduce expression in standard form, creating additional aux
    6757  // variables (and constraints)
     
    7161  void generateCuts (exprAux *w, const OsiSolverInterface &si,
    7262                     OsiCuts &cs, const CouenneCutGenerator *cg);
     63
     64  // return an index to the variable's argument that is better fixed
     65  // in a branching rule for solving a nonconvexity gap
     66  int getFixIndex () {return arglist_ [0] -> Index ();}
    7367};
    7468
  • branches/Couenne/Couenne/src/include/operators/exprOpp.h

    r298 r321  
    5555  void getBounds (expression *&, expression *&);
    5656
    57   // construct linear under-estimator for expression within problem *p
    58   // (p is used to add convexification constraints)
    59   //  int lowerLinearHull (exprAux *, int *&, expression ***&,
    60   //                   int **&, expression **&, enum con_sign *&);
    61 
    62   // construct linear under-estimator for expression within problem *p
    63   // (p is used to add convexification constraints)
    64   //  inline int upperLinearHull (exprAux *, int *&, expression ***&,
    65   //                          int **&, expression **&, enum con_sign *&)
    66   //    {return 0;}
    67 
    6857  // generate equality between *this and *w
    6958  void generateCuts (exprAux *w, const OsiSolverInterface &si,
  • branches/Couenne/Couenne/src/include/operators/exprPow.h

    r298 r321  
    3838
    3939  // String equivalent (for comparisons)
    40   const std::string name() const
     40  const std::string name () const
    4141    {return "^" + exprOp::name();}
    4242
     
    5959  void getBounds (expression *&, expression *&);
    6060
    61   // construct linear under-estimator for expression within problem *p
    62   // (p is used to add convexification constraints)
    63   int lowerLinearHull (exprAux *, int *&, expression ***&,
    64                        int **&, expression **&, enum con_sign *&);
    65 
    66   // construct linear over-estimator for expression within problem *p
    67   // (p is used to add convexification constraints)
    68   //  int upperLinearHull (exprAux *, int *&, expression ***&,
    69   //                   int **&, expression **&, enum con_sign *&);
    70 
    71   //  void segment (expression *&,  expression *&);
    72 
    73   //  void hull    (expression **, expression **);
    74   /*
    75   inline expression *mirror (expression *arg)
    76     {return new exprPow (arg, new exprClone (arglist_ [1]));}
    77 
    78   expression *mirror_d (expression *arg) {
    79     CouNumber expon = arglist_ [1] -> Value ();
    80 
    81     return new exprMul (new exprConst (expon),
    82                         new exprPow (arg, new exprConst (expon -1)));
    83   }
    84   */
    8561  // reduce expression in standard form, creating additional aux
    8662  // variables (and constraints)
     
    9066  void generateCuts (exprAux *w, const OsiSolverInterface &si,
    9167                     OsiCuts &cs, const CouenneCutGenerator *cg);
     68
     69  // return an index to the variable's argument that is better fixed
     70  // in a branching rule for solving a nonconvexity gap
     71  int getFixIndex () {return arglist_ [0] -> Index ();}
    9272};
    9373
  • branches/Couenne/Couenne/src/readnl/readnl.cpp

    r318 r321  
    3535
    3636
    37 // translates an ASL expression into an expression
    38 //expression *nl2e (expr *);
    39 
    40 
    4137// replaces group in original position within expression tree
    4238
     
    7369  for (int k=0; k<n_obj; k++)
    7470    if ((asl -> P. ops [k]. nb) || (asl -> P. ops [k]. ng)) {
    75       /*
    76       printf (">>> obj %d: %d basic, %d group\n", k,
    77               asl -> P. ops [k]. nb,
    78               asl -> P. ops [k]. ng);
    79       */
     71
    8072      int ngroups = asl -> P. ops [k]. ng;
    8173      for (int i=0; i<ngroups; i++)
     
    8779  for (int k=0; k<n_con; k++)
    8880    if ((asl -> P. cps [k]. nb) || (asl -> P. cps [k]. ng)) {
    89       /*
    90       printf (">>> con %d: %d basic, %d group\n", k,
    91               asl -> P. cps [k]. nb,
    92               asl -> P. cps [k]. ng);
    93       */
     81
    9482      int ngroups = asl -> P. cps [k]. ng;
    9583      for (int i=0; i<ngroups; i++)
    9684        fix_asl_group (&(asl -> P. cps [k]. g [i]));
    9785    }
    98 
    99   /*
    100   if (asl -> P. cps) {
    101 
    102     printf (">>> ps struct, con, %d basic, %d group\n",
    103             asl -> P. cps -> nb,
    104             asl -> P. cps -> ng);
    105 
    106     int ngroups = asl -> P. cps -> ng;
    107     for (int i=0; i<ngroups; i++)
    108       fix_asl_group (asl -> P. cps -> g + i);
    109   }
    110 
    111   if (asl -> P. cps) {
    112 
    113     printf (">>> ps struct, con, %d basic, %d group\n",
    114             asl -> P. cps [2]. nb,
    115             asl -> P. cps [2]. ng);
    116 
    117     int ngroups = asl -> P. cps [2]. ng;
    118     for (int i=0; i<ngroups; i++)
    119       fix_asl_group (asl -> P. cps [2]. g + i);
    120   }
    121   */
    122 
    12386
    12487  // objective functions /////////////////////////////////////////////////////////////
Note: See TracChangeset for help on using the changeset viewer.