Changeset 846 for stable/0.4


Ignore:
Timestamp:
May 7, 2012 10:10:50 AM (8 years ago)
Author:
pbelotti
Message:

revisited simplification

Location:
stable/0.4/Couenne/src
Files:
22 edited

Legend:

Unmodified
Added
Removed
  • stable/0.4/Couenne/src/expression/CouenneExprUnary.hpp

    r614 r846  
    5454
    5555  /// Destructor
    56   ~exprUnary ()
     56  virtual ~exprUnary ()
    5757  {if (argument_) delete argument_;}
    5858
     
    6161  {return 1;}
    6262
    63   /// return argument (when applicable, i.e., with univariate functions)
     63  /// return argument
    6464  virtual inline expression *Argument () const
    6565  {return argument_;}
    6666
    67   /// return pointer to argument (when applicable, i.e., with univariate functions)
     67  /// return pointer to argument
    6868  virtual inline expression **ArgPtr ()
    6969  {return &argument_;}
  • stable/0.4/Couenne/src/expression/CouenneExpression.hpp

    r490 r846  
    319319}
    320320
     321/// Macro to return already simplified expression without having to do
     322/// the if part every time simplify () is called
     323inline expression *Simplified (expression *complicated) {
     324
     325  expression *simpler = complicated -> simplify ();
     326
     327  if (simpler) {
     328    delete complicated;
     329    return simpler;
     330  } else return complicated;
    321331}
    322332
     333}
     334
    323335#endif
  • stable/0.4/Couenne/src/expression/exprOp.cpp

    r506 r846  
    142142  exprVar *subst;
    143143
    144   for (int i = nargs_; i--;)
     144  for (int i = 0; i < nargs_; ++i)
    145145    if ((subst = arglist_ [i] -> standardize (p))) {
     146
    146147      if ((subst -> Type () == VAR) ||
    147148          (subst -> Type () == AUX))
    148149        arglist_ [i]    = new exprClone (subst);
    149       else arglist_ [i] = subst;
     150      else arglist_ [i] = subst; // possibly a constant, should be nothing else
    150151    }
    151152  return NULL;
  • stable/0.4/Couenne/src/expression/exprUnary.cpp

    r490 r846  
    5353
    5454  if ((subst = argument_ -> standardize (p))) {
     55
    5556    if ((subst -> Type () == AUX) ||
    5657        (subst -> Type () == VAR))
     
    7677
    7778/// is this expression integer?
    78 bool exprUnary::isInteger () {
     79inline bool exprUnary::isInteger () {
    7980
    8081  // only check if argument is, *at this point in the algorithm*,
  • stable/0.4/Couenne/src/expression/operators/CouenneExprMax.hpp

    r490 r846  
    33 * Name:    exprMax.hpp
    44 * Author:  Pietro Belotti
    5  * Purpose: definition of $\f(x_{\argmax_{i\in I} y_i})$
     5 * Purpose: definition of $\f{\textrm{argmax}_{i\in I} y_i}$
    66 *
    77 * (C) Carnegie-Mellon University, 2006-09.
  • stable/0.4/Couenne/src/expression/operators/CouenneExprMin.hpp

    r490 r846  
    33 * Name:    exprMin.hpp
    44 * Author:  Pietro Belotti
    5  * Purpose: definition of $\f(x_{\argmin_{i\in I} y_i})$
     5 * Purpose: definition of $\f{\textrm{argmin}_{i\in I} y_i}$
    66 *
    77 * (C) Carnegie-Mellon University, 2006-09.
  • stable/0.4/Couenne/src/expression/operators/exprDiv.cpp

    r617 r846  
    1111#include "assert.h"
    1212
     13#include <stdio.h>
     14
    1315#include "CouenneExprDiv.hpp"
    1416#include "CouenneExprConst.hpp"
     
    3234
    3335  exprOp:: simplify ();
     36  expression *ret = NULL;
    3437
    3538  if ((*arglist_) -> Type () == CONST) { // expr = a / y
     
    4144      CouNumber c1 = arglist_ [1] -> Value ();
    4245
    43       delete arglist_ [0];
    44       delete arglist_ [1];
    45       arglist_ [0] = arglist_ [1] = NULL;
    46 
    47       return new exprConst (c0 / c1);
     46      if (fabs (c1) == 0.) {
     47        printf ("Couenne: Warning, division by zero -- "); print (); printf ("\n");
     48      }
     49      else {
     50        // delete arglist_ [0];
     51        // delete arglist_ [1];
     52        ret = new exprConst (c0 / c1);
     53        //arglist_ [0] = arglist_ [1] = NULL;
     54      }
    4855    }
    4956    else {
    50       if (fabs (c0) < COUENNE_EPS_SIMPL) // expr = 0/y
     57      if (fabs (c0) == 0.) // expr = 0/y
    5158        return new exprConst (0.);
    5259
    5360      // otherwise, expression = k/y, return k*inv(y)
    5461
    55       expression *ret;
    56 
    57       if (fabs (arglist_ [0] -> Value () - 1.) < COUENNE_EPS) {
    58         delete *arglist_;
    59         *arglist_ = NULL;
     62      //expression *ret;
     63
     64      if (fabs (arglist_ [0] -> Value () - 1.) == 0.) {
     65        //delete *arglist_;
     66        //*arglist_ = NULL;
    6067        ret = new exprInv (arglist_ [1]);
     68        arglist_ [1] = NULL;
    6169      }
    62       else ret = new exprMul (arglist_ [0], new exprInv (arglist_ [1]));
    63 
    64       arglist_ = NULL;
    65       return ret;
     70      else {
     71       
     72        ret = new exprMul (arglist_ [0], new exprInv (arglist_ [1]));
     73        arglist_ [0] = arglist_ [1] = NULL; // unlinking both arguments of useless expressions
     74      }
     75
     76      //arglist_ = NULL;
     77      //return ret;
    6678    }
    6779  }
     
    7183                                            // transform into (1/h)*x
    7284
    73       expression *ret = new exprMul (new exprConst (1. / (arglist_ [1] -> Value ())),
    74                                      arglist_ [0]);
    75       delete arglist_ [1];
    76       arglist_ = NULL;
    77       return ret;
    78     }
    79 
    80   return NULL;
     85      ret = new exprMul (new exprConst (1. / (arglist_ [1] -> Value ())), arglist_ [0]);
     86
     87      //delete arglist_ [1];
     88      arglist_ [0] = NULL;
     89      //return ret;
     90    }
     91
     92  return ret;
    8193}
    8294
  • stable/0.4/Couenne/src/expression/operators/exprMul.cpp

    r615 r846  
    5959  }
    6060
    61   CouNumber prod = 1;
     61  CouNumber prod = 1.;
    6262
    6363  bool found_one = false;
     
    7474      prod *= c;
    7575
    76       if (fabs (c) < COUENNE_EPS_SIMPL) {
    77 
    78         for (int j=0; j<nargs_; j++)
    79           if (arglist_ [j]) {
    80             delete arglist_ [j];
    81             arglist_ [j] = NULL;
    82           }
     76      if (fabs (c) == 0.) {
     77
     78        // for (int j=0; j<nargs_; j++)
     79        //   if (arglist_ [j]) {
     80        //     delete arglist_ [j];
     81        //     arglist_ [j] = NULL;
     82        //   }
    8383
    8484        return new exprConst (0.);
     
    9595    return new exprConst (arglist_ [0] -> Value ());
    9696  */
    97   if (found_one && shrink_arglist (prod, 1)) {
     97  if (found_one && shrink_arglist (prod, 1.)) {
    9898    expression *ret = arglist_ [0];
    9999    arglist_ [0] = NULL;
  • stable/0.4/Couenne/src/expression/operators/exprOpp.cpp

    r614 r846  
    8484  if (argument_ -> code () == COU_EXPROPP) {
    8585    // leak. don't clone, use exprClone
    86     expression *ret = argument_ -> Argument () -> clone ();
    87     delete argument_;
    88     argument_ = NULL;
     86    expression *ret = argument_ -> Argument (); // -> clone ();
     87    *(argument_ -> ArgPtr ()) = NULL; // unlink two levels below, will
     88                                      // delete only exprOp and its
     89                                      // argument
     90    //delete argument_;
     91    //argument_ = NULL;
    8992    return ret;
    9093  }
     
    9396  if (argument_ -> Type () == CONST) {
    9497    expression *ret = new exprConst (- argument_ -> Value ());
    95     delete argument_;
    96     argument_ = NULL;
     98    //delete argument_;
     99    //argument_ = NULL;
    97100    return ret;
    98101  }
  • stable/0.4/Couenne/src/expression/operators/exprPow.cpp

    r698 r846  
    4141      CouNumber c1 = arglist_ [1] -> Value ();
    4242
    43       delete arglist_ [0];
    44       delete arglist_ [1];
    45 
    46       arglist_ [0] = arglist_ [1] = NULL;
     43      // delete arglist_ [0];
     44      // delete arglist_ [1];
     45
     46      // arglist_ [0] = arglist_ [1] = NULL;
    4747
    4848      return new exprConst (pow (c0, c1));
     
    6363      else if (fabs (expon - 1.) <= COUENNE_EPS_SIMPL) { // expr = x ^ 1 = x
    6464
    65         delete arglist_ [1];
     65        //delete arglist_ [1];
    6666        expression *ret = arglist_ [0];
    67         arglist_ [0] = arglist_ [1] = NULL;
     67        arglist_ [0] = NULL;
     68
    6869        return ret;
    6970      }
     
    7172      else if (fabs (expon + 1.) <= COUENNE_EPS_SIMPL) { // expr = x ^ -1 = 1/x
    7273
    73         delete arglist_ [1];
     74        //delete arglist_ [1];
    7475        expression *ret = new exprInv (arglist_ [0]);
    75         arglist_ [0] = arglist_ [1] = NULL;
     76        arglist_ [0] = NULL;
    7677        return ret;
    7778      }
     
    7980      //
    8081      // x^k = x for x binary. Too bad we don't know bounds yet, so the code below will give segfault
     82
     83      // TODO: readnl first reads bounds. Then uncomment this.
    8184
    8285      //       // is it an integer variable with bounds [-1,0] or [0,1]
  • stable/0.4/Couenne/src/expression/operators/exprSub.cpp

    r560 r846  
    2727  if (arglist_ [0] -> compare (*(arglist_ [1])) == 0) {
    2828
    29     delete arglist_ [0]; arglist_ [0] = NULL;
    30     delete arglist_ [1]; arglist_ [1] = NULL;
     29    // delete arglist_ [0]; arglist_ [0] = NULL;
     30    // delete arglist_ [1]; arglist_ [1] = NULL;
    3131
    3232    return new exprConst (0.);
     
    4242      CouNumber c1 = arglist_ [1] -> Value ();
    4343
    44       delete arglist_ [0]; arglist_ [0] = NULL;
    45       delete arglist_ [1]; arglist_ [1] = NULL;
     44      // delete arglist_ [0]; arglist_ [0] = NULL;
     45      // delete arglist_ [1]; arglist_ [1] = NULL;
    4646
    4747      return new exprConst (c0 - c1);
    4848    }
    49     else if (fabs (c0) < COUENNE_EPS_SIMPL) { // expr = opp (f2)
     49    else if (fabs (c0) == 0.) { // expr = opp (f2)
    5050
    5151      expression *ret = new exprOpp (arglist_ [1]);
    52       delete arglist_ [0];
    53       arglist_ [0] = arglist_ [1] = NULL;
     52      //      delete arglist_ [0];
     53      arglist_ [1] = NULL;
    5454      return ret;
    5555    }
     
    6262
    6363      expression *ret = arglist_ [0];
    64       delete arglist_ [1];
    65       arglist_ [0] = arglist_ [1] = NULL;
     64      //delete arglist_ [1];
     65      arglist_ [0] = NULL;
    6666      return ret;
    6767    }
  • stable/0.4/Couenne/src/expression/operators/exprSum.cpp

    r490 r846  
    8484  */
    8585
    86   if (found_one && shrink_arglist (total, 0)) {
     86  if (found_one && shrink_arglist (total, 0.)) {
    8787    expression *ret = arglist_ [0];
    8888    arglist_ [0] = NULL;
  • stable/0.4/Couenne/src/expression/simplify/simplifiers.cpp

    r490 r846  
    1 /* $Id$ */
    2 /*
     1/* $Id$
     2 *
    33 * Name:    simplifiers.cpp
    44 * Author:  Pietro Belotti
     
    6161
    6262  // find first NULL spot (left by some constant)
    63   while ((i < nargs_) && (arglist_ [i])) 
    64     i++;
     63  while ((i < nargs_) && (arglist_ [i]))
     64    ++i;
    6565
    6666  // no spots, leave
    67   if (i==nargs_) 
     67  if (i==nargs_)
    6868    return 0;
    6969
     
    8686
    8787    while ((i < nargs_) && !(arglist_ [i]))
    88       i++;
     88      ++i;
    8989
    9090    if (i < nargs_)
    9191      one_fun = true;
    9292
    93     while ((i < nargs_) && (arglist_ [i]))
    94       arglist_ [j++] = arglist_ [i++];
     93    while ((i < nargs_) && (arglist_ [i])) {
     94
     95      //if (i != j) {
     96      arglist_ [j++] = arglist_ [i++];
     97        // arglist_ [i] = NULL; // useless
     98        //}
     99
     100      //++i; ++j;
     101    }
    95102  }
    96103
    97   nargs_ = j;
     104  nargs_ = j; // doesn't change the size of the malloc'd array
    98105
    99106  // only say shrinking simplified arg list if there is just the
  • stable/0.4/Couenne/src/interfaces/CouenneTNLP.cpp

    r719 r846  
    591591  for (std::set <int>::iterator i = objDep.begin (); i != objDep. end (); ++i) {
    592592
    593     expression
    594       *gradcomp = newObj -> differentiate (*i),
    595       *gsimp    = gradcomp -> simplify ();
    596 
    597     if (gsimp) {
    598       delete gradcomp;
    599       gradcomp = gsimp;
    600     }
     593    expression *gradcomp = Simplified (newObj -> differentiate (*i));
     594    //*gsimp    = gradcomp -> simplify ();
     595
     596    // if (gsimp) {
     597    //   delete gradcomp;
     598    //   gradcomp = gsimp;
     599    // }
    601600
    602601    gradcomp -> realign (problem_);
  • stable/0.4/Couenne/src/problem/CouenneProblem.cpp

    r752 r846  
    114114  domain_. current () -> resize (var_ind + 1);
    115115
    116   symbolic -> getBounds (domain_. lb (var_ind), 
     116  symbolic -> getBounds (domain_. lb (var_ind),
    117117                         domain_. ub (var_ind));
    118118
     
    120120  exprAux *w = new exprAux (symbolic,
    121121                            var_ind,
    122                             1 + symbolic -> rank (), 
     122                            1 + symbolic -> rank (),
    123123                            exprAux::Unset,
    124124                            &domain_);
     
    137137  } else {  // otherwise, just return the entry's pointer
    138138
    139     w -> Image(NULL); // otherwise "delete w" will also delete user given expression "symbolic"
     139    w -> Image (NULL); // otherwise "delete w" will also delete user given expression "symbolic"
    140140    delete w;
    141141    w = *i;
  • stable/0.4/Couenne/src/readnl/CouenneAmplInterface.cpp

    r694 r846  
    424424    ///////////////////////////////////////////////////
    425425
    426     expression *subst = body -> simplify ();
    427 
    428     if (subst) {
    429       delete body; // VALGRIND
    430       body = subst;
    431     }
     426    expression *subst = Simplified (body);// -> simplify ();
     427
     428    // if (subst) {
     429    //   delete body; // VALGRIND
     430    //   body = subst;
     431    // }
    432432
    433433    // ThirdParty/ASL/solvers/asl.h, line 336: 0 is minimization, 1 is maximization
     
    578578    }
    579579
    580     expression *subst = body -> simplify ();
    581     if (subst) {
    582       delete body; // VALGRIND
    583       body = subst;
    584     }
     580    expression *subst = Simplified (body);
     581
     582    // -> simplify ();
     583    // if (subst) {
     584    //   delete body; // VALGRIND
     585    //   body = subst;
     586    // }
    585587
    586588    // add them (and set lower-upper bound)
  • stable/0.4/Couenne/src/readnl/readnl.cpp

    r841 r846  
    149149    expression
    150150      *body,
    151       *nl = nl2e (OBJ_DE [i] . e, asl),
    152       *nls = nl -> simplify ();
    153 
    154     if (nls) {
    155       delete nl;
    156       nl = nls;
    157     }
     151      *nl = Simplified (nl2e (OBJ_DE [i] . e, asl));
     152    //   *nls = nl -> simplify ();
     153
     154    // if (nls) {
     155    //   delete nl;
     156    //   nl = nls;
     157    // }
    158158
    159159    if (nterms) { // have linear terms
     
    206206    ///////////////////////////////////////////////////
    207207
    208     expression *subst = body -> simplify ();
    209 
    210     if (subst) {
    211       delete body; // VALGRIND
    212       body = subst;
    213     }
     208    expression *subst = Simplified (body); // -> simplify ();
     209
     210    // if (subst) {
     211    //   delete body; // VALGRIND
     212    //   body = subst;
     213    // }
    214214
    215215    // ThirdParty/ASL/solvers/asl.h, line 336: 0 is minimization, 1 is maximization
     
    333333       *nls;
    334334
    335     *nll = nl2e (CON_DE [i] . e, asl);
    336 
    337     nls = (*nll) -> simplify ();
    338 
    339     if (nls) {
    340       delete *nll;
    341       *nll = nls;
    342     }
     335    *nll = Simplified (nl2e (CON_DE [i] . e, asl));
     336
     337    // nls = (*nll) -> simplify ();
     338
     339    // if (nls) {
     340    //   delete *nll;
     341    //   *nll = nls;
     342    // }
    343343
    344344    if (indexL [i] && (*(indexL [i]) >= 0)) {
     
    369369    }
    370370
    371     expression *subst = body -> simplify ();
    372     if (subst) {
    373       delete body; // VALGRIND
    374       body = subst;
    375     }
     371    expression *subst = Simplified (body);
     372
     373    //  -> simplify ();
     374    // if (subst) {
     375    //   delete body; // VALGRIND
     376    //   body = subst;
     377    // }
    376378
    377379    // add them (and set lower-upper bound)
     
    482484
    483485  expression
    484     *nle = p -> nl2e (which ? common1 -> e : common -> e, asl),
    485     *nls = nle -> simplify ();
    486 
    487   if (nls) {
    488     delete nle;
    489     nle = nls;
    490   }
     486    *nle = Simplified (p -> nl2e (which ? common1 -> e : common -> e, asl));
     487
     488  //   *nls = nle -> simplify ();
     489
     490  // if (nls) {
     491  //   delete nle;
     492  //   nle = nls;
     493  // }
    491494
    492495#ifdef DEBUG
  • stable/0.4/Couenne/src/standardize/constrStandardize.cpp

    r750 r846  
    4040  if (p -> Jnlst () -> ProduceOutput (Ipopt::J_ALL, J_REFORMULATE)) {
    4141    printf ("Reformulating constraint: "); print ();
    42 
    4342    printf (" ["); fflush (stdout); lb_ -> print ();
    4443    printf (","); fflush (stdout);  ub_ -> print (); fflush (stdout);
    4544    /*  printf ("] {with auxset = ");
    46         for (std::set <exprAux *, compExpr>::iterator i = p -> AuxSet () -> begin ();
    47         i != p -> AuxSet () -> end (); i++) {
    48         printf ("<"); (*i) -> print ();
    49         printf (","); (*i) -> Image () -> print (); printf ("> ");
    50         }*/
     45        for (std::set <exprAux *, compExpr>::iterator i = p -> AuxSet () -> begin (); i != p -> AuxSet () -> end (); i++) {
     46        printf ("<"); (*i) -> print (); printf (","); (*i) -> Image () -> print (); printf ("> ");}*/
    5147    printf ("]\n");
    5248  }
     
    6662    use_semiaux;
    6763
    68   p -> bonBase () -> options () -> GetStringValue ("use_auxcons", use_auxcons, "couenne.") ;
    69   p -> bonBase () -> options () -> GetStringValue ("use_semiaux", use_semiaux, "couenne.") ;
     64  p -> bonBase () -> options () -> GetStringValue ("use_auxcons", use_auxcons, "couenne.");
     65  p -> bonBase () -> options () -> GetStringValue ("use_semiaux", use_semiaux, "couenne.");
    7066
    7167  if ((  use_auxcons == "yes") &&          // if aux generated by constraints are disabled, just bail out
     
    9591      // simplify expression (you never know)
    9692
    97       expression *restSimple = rest -> simplify ();
    98 
    99       if (restSimple) {
    100         delete rest;
    101         rest = restSimple;
    102       }
     93      expression *restSimple = Simplified (rest);
     94
     95      // -> simplify ();
     96
     97      // if (restSimple) {
     98      //        delete rest;
     99      //        rest = restSimple;
     100      // }
    103101
    104102      // if this is a constraint of the form x=k, reset x's bounds and
     
    159157
    160158//      if (p -> Jnlst () -> ProduceOutput (Ipopt::J_ALL, J_REFORMULATE)) {
    161 
    162159//        printf ("AuxSet:\n");
    163160//        for (std::set <exprAux *, compExpr>::iterator i = p -> AuxSet () -> begin ();
  • stable/0.4/Couenne/src/standardize/decomposeTerm.cpp

    r500 r846  
    224224      int ind = aux -> Index ();
    225225
    226       if      (fabs (expon - 1) < COUENNE_EPS) lmap.insert (ind, initCoe);
    227       else if (fabs (expon - 2) < COUENNE_EPS) qmap.insert (ind, ind, initCoe);
     226      if      (fabs (expon - 1.) == 0.) lmap.insert (ind,      initCoe);
     227      else if (fabs (expon - 2.) == 0.) qmap.insert (ind, ind, initCoe);
    228228      else {
    229229        exprAux *aux2 = addAuxiliary
  • stable/0.4/Couenne/src/standardize/splitAux.cpp

    r607 r846  
    487487  exprAux *aux = rest -> standardize (this, false);
    488488
    489   if (jnlst_ -> ProduceOutput (Ipopt::J_ALL, J_REFORMULATE)) {
    490 
    491     if (aux) {
     489  if (aux && jnlst_ -> ProduceOutput (Ipopt::J_ALL, J_REFORMULATE)) {
    492490      printf ("  Aux: "); aux -> print ();
    493491      printf (" := ");    aux -> Image () -> print ();
    494     }
    495492  }
    496493
     
    500497    rest = aux -> Image (); // -> clone (&domain_);
    501498    aux -> Image (NULL);
    502     delete aux;
     499    //delete aux; // segfaults on simplified expressions? (see test/simple.nl)
    503500  }
    504501
    505   if (jnlst_ -> ProduceOutput (Ipopt::J_ALL, J_REFORMULATE)) {
    506     printf (" ==> ");
    507     rest -> print ();
    508     printf ("\n");
    509   }
     502  if (jnlst_ -> ProduceOutput (Ipopt::J_ALL, J_REFORMULATE))
     503    {printf (" ==> "); rest -> print (); printf ("\n");}
    510504
    511505  return auxInd;
  • stable/0.4/Couenne/src/standardize/standardize.cpp

    r769 r846  
    211211  }
    212212
    213   // Constraints ----------------------------------------------------------------------------
     213  // CONSTRAINTS ----------------------------------------------------------------------------
    214214
    215215  // commuted_ is an array with a flag for each original variable,
     
    332332    //(*i) -> Body () -> realign (this);
    333333
    334     if (jnlst_ -> ProduceOutput (J_ALL, J_REFORMULATE)) {
    335       printf (" --> "); (*i) -> print (); printf ("\n\n");
    336     }
     334    if (jnlst_ -> ProduceOutput (J_ALL, J_REFORMULATE)) {printf (" --> "); (*i) -> print (); printf ("\n\n");}
    337335
    338336    /*printf ("=== "); fflush (stdout);
  • stable/0.4/Couenne/src/standardize/sumStandardize.cpp

    r490 r846  
    8686      printf ("<%d,%g>", i -> first, i -> second);
    8787    printf ("] -- quad [");
    88     for (std::map <std::pair <int, int>, CouNumber>::iterator i = qmap.Map ().begin ();
    89          i != qmap.Map ().end (); ++i)
     88    for (std::map <std::pair <int, int>, CouNumber>::iterator i = qmap.Map ().begin (); i != qmap.Map ().end (); ++i)
    9089      printf ("<%d,%d,%g>", i -> first.first, i -> first.second, i -> second);
    9190    printf ("] (%g)\n", c0);
     
    137136  // quadratic form
    138137
    139   p -> decomposeTerm (arglist_ [0],  1, c0, lmap, qmap);
    140   p -> decomposeTerm (arglist_ [1], -1, c0, lmap, qmap);
     138  p -> decomposeTerm (arglist_ [0],  1., c0, lmap, qmap);
     139  p -> decomposeTerm (arglist_ [1], -1., c0, lmap, qmap);
    141140
    142141  return p -> linStandardize (addAux, c0, lmap, qmap);
Note: See TracChangeset for help on using the changeset viewer.