Changeset 2090

Dec 30, 2009 2:22:38 AM (10 years ago)

Merged revisions 2070-2089 via svnmerge from


r2089 | wehart | 2009-12-30 00:22:19 -0700 (Wed, 30 Dec 2009) | 2 lines

Update to changelog.


2 edited


  • coopr.pyomo/stable/2.1

  • coopr.pyomo/stable/2.1/CHANGELOG.txt

    r1806 r2090  
    9 - Under development.
     9- Removed some TBD notes in the Benders example, and checked in the full
     10  benders script (a debug version was committed initially, that only
     11  dealt with iteration 1). This version replicates, to within precision,
     12  the AMPL execution. Should terminate in 5 master iterations.
     14- Misc rework of variable presolving. Now, model statistics are
     15  stored in a more obvious location, and using more verbose names.
     17- Added functions that can (1) extract a canonical representation
     18  from an expressions, and (2) generate an expression from a canonical
     19  representation.
     21- Adding ability to load a list or tuple of values into a Pyomo
     22  model. These are loaded into the variables in the order in which the
     23  variables are identified.
     25- Updated variable naming. Special symbols are mapped to
     26  a name that contains _Q#_, where # the ASCII decimal representation
     27  for that symbol.
     29- Added support for denoting constraint inequalities as 'strict'. Added
     30  tests to verify that strict inequalities are recognized.
     32- Resolved #3970. When a parameter is specified with a default
     33  value, we should be able to refer to its index set directly, since
     34  all values are tacitly defined.
     36- Added a 'random' solver for the p-median example.
     38- Added ".solver-mipgap" option to the pyomo script, mirroring recent useful
     39  updates to the PH script.
     41- Simplified the syntax for adding a constraint to a Constraint object.
     43- Reworking how components interact with models. Now, components can
     44  only be initialized using data from the model that they are associated
     45  with.  Thus, models and components are tightly coupled. This allows
     46  the following syntax:
     48    model.x = Param(model.A)
     49    model.construct()
     51  The construction process uses the model data that is associated with
     52  the parameter. Also, this commmit allows models to be components of
     53  another model:
     55    m1=Model()
     56    m2=Model()
     57    m2.m1 = m1
     59  Note, however, that model construct is required to be done
     60  separately. When model m2 is constructed, the m1 component is not
     61  constructed.
     63- Added check to avoid printing an objective with an empty linear sum.
     65- Rework of the amplbook2 examples, and other Pyomo examples.
     67- A change in semantics for setting up dimen and dim. This change requires
     68  that users specify dimen in situtations where it is not obvious from the
     69  component declaration. For example, if you initialize from a function,
     70  then you'll need to specify dimen if the function returns n-tuples.
     72- Added an extension point for plugins that suport model transformations.
     73  Two transformations have been defined:  a transformation for eliminating
     74  fixed variables, and a transformation for relaxing integrality.  These
     75  can be generically accessed with the apply_transformation() function.
     77- Extended API of the PyomoModel class to add a variety of helper
     78  functions (e.g. accessing constraints, variables and objectives).
     79  Adding a method for getting the model solution, as a vector.
     81- Added tests to exercise the Pyomo command-line.
     83- Updates to Pyomo command-line options:
     85  Added --model-name option, which allows the specification of an object
     86  other than 'model' for the model that is optimized.
     88  Added support for create_model(), which accepts a dictionary or
     89  pyutilib.misc.Container object containing the options specified with the
     90  --model-options option. This function returns a model that is optimized.
     92  Added the 'errors' debugging mode. When specified, exceptions dump
     93  a traceback. Otherwise, exceptions are caught and only the exception
     94  string is printed.
     96- Adding support for component index deactivation.  This supports the
     97  following semantics:
     99    model.C = Constraint(model.A)
     100    model.C[index].deactivate()
     102  Note that the current implementation requires the user to query whether
     103  each index is active:
     105    if model.C[index].active:
     106        # Do something
     108  I could have alternatively changed the iterator for the constraint,
     109  but then that could mask the existence of a constraint, making it
     110  difficult to reactivate.
     112  Finally, note that this activation mechanism is independent
     113  of the component level activation/deactivation:
     115    model.C.deactivate()
     116    # All C constraints are deactivated
     117    model.C[index].deactivate
     118    # You can still manipulate the C constraint
     119    model.C.activate()
     120    # Now, the C constraint is active, except for the '
     121    # 'index' constraint
     123- A rework of component management in Pyomo.  Component types are now
     124  managed with the natural class types (e.g.  Var for variables, rather
     125  than _VarBase). Further, the components should now be accessed with
     126  model methods: components() or active_components().  For example,
     128    model.components(Var)
     130  returns a dictionary of the Var components.
     132- Created the ComponentBase class, which manages the initialization of
     133  components. This consolidates the mechanism needed to generalize
     134  the component indexing operations.
     136- Reworking SetArray constructor to create temporary set objects for non-set
     137  index arguments. These arguments are passed into a Set object
     138  with the 'initialize' argument.
     140- Extended the constraint generation logic to evaluate whether the
     141  constraint expression contains constant values. This extension allows
     142  the following types of constraints to be specified:
     144    def f(model)
     145        return 0 < model.x
     147    def g(model)
     148        return model.x == model.y
     150    def h(model)
     151        return model.y > model.z
     153  However, it's pretty clear now that the following cannot be supported in
     154  Python:
     156    def j(model)
     157        return 0 < model.x < 1
     159  To add upper and lower bounds, a user will need to return a tuple value:
     161    def j(model)
     162        return (0, model.x, 1)
     164  or return an expression that is generated incrementally:
     166    def j(model)
     167        e = 0 < model.x
     168        return e < 1
     170- Significantly changed - and improved - the handling of variable lower
     171  and upper bounds.  In the old version of pyomo, if parameters were
     172  supplied as bounds, the lb/ub were silently ignored when writing
     173  LP/NL/etc files.
     175  In the new version of pyomo, these parameters are stored and handled
     176  to avoid this issue. In particular, the "lb" and "ub" attributes
     177  of a variable are either (1) None, (2) a NumericConstant?, or (3) a
     178  _ParamBase. The latter two objects share the common () operator. Thus,
     179  to access the lb and ub attributes of a variable, one should either
     180  test for None, or use lb() or ub() to extract the value.
     182- Added constraint symbol maps when writing NL files, so the constraint names
     183  can be mapped back (e.g., when dealing with dual variables in SOL files)
     184  into the user-recognized names.
Note: See TracChangeset for help on using the changeset viewer.