Ticket #7012: trac_7012-rebased.patch

File trac_7012-rebased.patch, 33.8 KB (added by mvngu, 11 years ago)

rebased against Sage 4.1.2.rc0

  • sage/numerical/knapsack.py

    # HG changeset patch
    # User Nathann Cohen <nathann.cohen@gmail.com>
    # Date 1254129856 25200
    # Node ID 87bf97ad64fbe4068336a565c60937adf443d58d
    # Parent  e334f15125a3faecdecfefc6079a7ba4536955e8
    Numerical.mip Class : functions renamed, typos, several docstring fixes, bugfixes...
    
    diff -r e334f15125a3 -r 87bf97ad64fb sage/numerical/knapsack.py
    a b  
    641641    if reals:
    642642        seq = [(x,1) for x in seq]
    643643
    644     from sage.numerical.mip import MIP
    645     p = MIP(sense=1)
    646     present = p.newvar()
    647     p.setobj(sum([present[i] * seq[i][1] for i in range(len(seq))]))
    648     p.addconstraint(sum([present[i] * seq[i][0] for i in range(len(seq))]), max=max)
     644    from sage.numerical.mip import MixedIntegerLinearProgram
     645    p = MixedIntegerLinearProgram(sense=1)
     646    present = p.new_variable()
     647    p.set_objective(sum([present[i] * seq[i][1] for i in range(len(seq))]))
     648    p.add_constraint(sum([present[i] * seq[i][0] for i in range(len(seq))]), max=max)
    649649
    650650    if binary:
    651         p.setbinary(present)
     651        p.set_binary(present)
    652652    else:
    653         p.setinteger(present)
     653        p.set_integer(present)
    654654
    655655    if value_only:
    656656        return p.solve(objective_only=True)
  • sage/numerical/mip.pyx

    diff -r e334f15125a3 -r 87bf97ad64fb sage/numerical/mip.pyx
    a b  
    11include '../ext/stdsage.pxi'
    22
    3 class MIP:
     3class MixedIntegerLinearProgram:
    44    r"""
    5     The MIP class is the link between SAGE and LP ( Linear Program ) and
     5    The ``MixedIntegerLinearProgram`` class is the link between SAGE and LP ( Linear Program ) and
    66    MIP ( Mixed Integer Program ) Solvers. Cf : http://en.wikipedia.org/wiki/Linear_programming
    77
    88    It consists of variables, linear constraints on these variables, and an objective
    99    function which is to be maximised or minimised under these constraints.
    1010
    11     An instance of ``MIP`` also requires the information
     11    An instance of ``MixedIntegerLinearProgram`` also requires the information
    1212    on the direction of the optimization :
    1313   
    14     A ``MIP`` ( or ``LP`` ) is defined as a maximization
     14    A ``MixedIntegerLinearProgram`` ( or ``LP`` ) is defined as a maximization
    1515    if ``sense=1``, and is a minimization if ``sense=-1``
    1616
    1717    INPUT:
    1818       
    19         - ``sense'' :
    20                  * When set to `1` (default), the ``MIP`` is defined as a Maximization
    21                  * When set to `-1`, the ``MIP`` is defined as a Minimization
     19        - ``sense`` :
     20                 * When set to `1` (default), the ``MixedIntegerLinearProgram`` is defined as a Maximization
     21                 * When set to `-1`, the ``MixedIntegerLinearProgram`` is defined as a Minimization
    2222   
    2323    EXAMPLES::
    2424
    2525         sage: ### Computation of a maximum stable set in Petersen's graph ###
    2626         sage: g=graphs.PetersenGraph()
    27          sage: p=MIP(sense=1)
    28          sage: b=p.newvar()
    29          sage: p.setobj(sum([b[v] for v in g]))
     27         sage: p=MixedIntegerLinearProgram(sense=1)
     28         sage: b=p.new_variable()
     29         sage: p.set_objective(sum([b[v] for v in g]))
    3030         sage: for (u,v) in g.edges(labels=None):
    31          ...       p.addconstraint(b[u]+b[v],max=1)
    32          sage: p.setbinary(b)
     31         ...       p.add_constraint(b[u]+b[v],max=1)
     32         sage: p.set_binary(b)
    3333         sage: p.solve(objective_only=True)     # optional - requires Glpk or COIN-OR/CBC
    3434         4.0
    3535    """       
    3636
    3737    def __init__(self,sense=1):
    3838        r"""
    39         Constructor for the MIP class
     39        Constructor for the ``MixedIntegerLinearProgram`` class
    4040
    4141        INPUT:
    4242       
    43         - ``sense'' :
    44                  When set to 1, the MIP is defined as a Maximization
    45                  When set to -1, the MIP is defined as a Minimization
     43        - ``sense`` :
     44                 When set to 1, the MixedIntegerLinearProgram is defined as a Maximization
     45                 When set to -1, the MixedIntegerLinearProgram is defined as a Minimization
    4646
    47         EXAMPLE:
     47        EXAMPLE::
    4848
    49             sage: p=MIP(sense=1)
     49            sage: p=MixedIntegerLinearProgram(sense=1)
    5050        """
    5151
    5252        try:
     
    6565        P = InfinitePolynomialRing(RR(), names=('x',));
    6666        (self.x,) = P._first_ngens(1)
    6767
    68         self.count=[0]
     68        # number of variables
     69        self.count=0
    6970        self.sense=sense
    7071        self.objective=None
     72
    7173        self.variables={}
    7274        self.constraints=[]
     75       
     76        #constains the min and max bounds on the variables
    7377        self.min={}
    7478        self.max={}
     79
     80        # constains the variables types
    7581        self.types={}
     82
     83        #constains the variables' values when solve(objective_only=False) is called
    7684        self.values={}
     85       
     86        # Several constants
    7787        self.__BINARY=1
    7888        self.__REAL=-1
    7989        self.__INTEGER=0
    8090
    8191    def __repr__(self):
    8292         r"""
    83          Returns a short description of the MIP
     93         Returns a short description of the MixedIntegerLinearProgram
    8494         
    85          EXAMPLE:
     95         EXAMPLE::
    8696         
    87          sage: p=MIP()
    88          sage: v=p.newvar()
    89          sage: p.addconstraint(v[1]+v[2],max=2)
     97         sage: p=MixedIntegerLinearProgram()
     98         sage: v=p.new_variable()
     99         sage: p.add_constraint(v[1]+v[2],max=2)
    90100         sage: print p
    91101         Mixed Integer Program ( maximization, 2 variables, 1 constraints )
    92102         """
    93103         return "Mixed Integer Program ( "+("maximization" if self.sense==1 else "minimization")+", "+str(len(self.variables))+" variables, "+str(len(self.constraints))+" constraints )"
    94104
    95     def newvar(self,dim=1):
     105    def new_variable(self,vtype=-1,dim=1):
    96106        r"""
    97107        Returns an instance of ``MIPVariable`` associated
    98         to the current instance of ``MIP``.
     108        to the current instance of ``MixedIntegerLinearProgram``.
    99109       
    100         A new ``MIP`` variable ``x`` defined by :::
     110        A new variable ``x`` is defined by :::
    101111
    102             sage: p=MIP()
    103             sage: x=p.newvar()
     112            sage: p=MixedIntegerLinearProgram()
     113            sage: x=p.new_variable()
    104114
    105         It behaves exactly as an usual dictionary would. It can use any key
     115        It behaves exactly as a usual dictionary would. It can use any key
    106116        argument you may like, as ``x[5]`` or ``x["b"]``, and has methods
    107117        ``items()`` and ``keys()``
    108118       
     
    113123        - ``dim`` ( integer ) : Defines the dimension of the dictionary
    114124                      If ``x`` has dimension `2`, its fields will
    115125                      be of the form ``x[key1][key2]``
     126        - ``vtype`` ( integer ) : Defines the type of the variables
     127                      ( default is Real )
     128
    116129
    117130        EXAMPLE::
    118131
    119             sage: p=MIP()
    120             sage: x=p.newvar()
    121             sage: y=p.newvar(dim=2)
    122             sage: p.addconstraint(x[2]+y[3][5],max=2)
     132            sage: p=MixedIntegerLinearProgram()
     133            sage: # available types are p.__REAL, p.__INTEGER and p.__BINARY
     134            sage: x=p.new_variable(vtype=p.__REAL)
     135            sage: y=p.new_variable(dim=2)
     136            sage: p.add_constraint(x[2]+y[3][5],max=2)
    123137        """
    124         return MIPVariable(self.x,self._addElementToRing,dim=dim)
     138        return MIPVariable(self,vtype,dim=dim)
    125139         
    126140
    127141    def export(self,format="text"):
    128142         r"""
    129          Exports the MIP to a string in different formats.
     143         Exports the ``MixedIntegerLinearProgram`` to a string in different formats.
    130144         
    131145         INPUT:
    132146         
    133          - ``format'' :
     147         - ``format`` :
    134148                   "text" : human-readable format
    135149
    136          sage: p=MIP()
    137          sage: x=p.newvar()
    138          sage: p.setobj(x[1]+x[2])
    139          sage: p.addconstraint(-3*x[1]+2*x[2],max=2)
     150         sage: p=MixedIntegerLinearProgram()
     151         sage: x=p.new_variable()
     152         sage: p.set_objective(x[1]+x[2])
     153         sage: p.add_constraint(-3*x[1]+2*x[2],max=2)
    140154         sage: print p.export(format="text")
    141155         Maximization :
    142156           x2 + x1
     
    155169              value=value+"\nVariables :"
    156170              for v in self.variables.keys():
    157171                   value=value+"\n  "+str(v)+" is"
    158                    if self.isinteger(v):
     172                   if self.is_integer(v):
    159173                       value=value+" an integer variable"
    160                    elif self.isbinary(v):
     174                   elif self.is_binary(v):
    161175                       value=value+" an boolean variable"                       
    162176                   else:
    163177                       value=value+" a real variable"
    164                    value+=" (min="+(str(self.getmin(v)) if self.getmin(v)!= None else "-oo")+",max="+(str(self.getmax(v)) if self.getmax(v)!= None else "+oo")+")"
     178                   value+=" (min="+(str(self.get_min(v)) if self.get_min(v)!= None else "-oo")+",max="+(str(self.get_max(v)) if self.get_max(v)!= None else "+oo")+")"
    165179              return value
    166180
    167181    def get_values(self,*lists):
     
    183197
    184198        EXAMPLE::
    185199
    186             sage: p=MIP()
    187             sage: x=p.newvar()
    188             sage: y=p.newvar(dim=2)
    189             sage: p.setobj(x[3]+y[2][9]+x[5])
    190             sage: p.addconstraint(x[3]+y[2][9]+2*x[5],max=2)
     200            sage: p=MixedIntegerLinearProgram()
     201            sage: x=p.new_variable()
     202            sage: y=p.new_variable(dim=2)
     203            sage: p.set_objective(x[3]+y[2][9]+x[5])
     204            sage: p.add_constraint(x[3]+y[2][9]+2*x[5],max=2)
    191205            sage: p.solve() # optional - requires Glpk or COIN-OR/CBC
    192206            2.0
    193207            sage: #
    194208            sage: # Returns the optimal value of x[3]
    195209            sage: p.get_values(x[3]) # optional - requires Glpk or COIN-OR/CBC
    196             0.0
     210            2.0
    197211            sage: #
    198212            sage: # Returns a dictionary identical to x
    199213            sage: # containing values for the corresponding
     
    243257
    244258    def show(self):
    245259        r"""
    246         Prints the MIP in a human-readable way
     260        Prints the ``MixedIntegerLinearProgram`` in a human-readable way
    247261
    248         EXAMPLE:
     262        EXAMPLE::
    249263
    250         sage: p=MIP()
    251         sage: x=p.newvar()
    252         sage: p.setobj(x[1]+x[2])
    253         sage: p.addconstraint(-3*x[1]+2*x[2],max=2)
     264        sage: p=MixedIntegerLinearProgram()
     265        sage: x=p.new_variable()
     266        sage: p.set_objective(x[1]+x[2])
     267        sage: p.add_constraint(-3*x[1]+2*x[2],max=2)
    254268        sage: p.show()
    255269        Maximization :
    256270          x2 + x1
     
    262276        """
    263277        print self.export(format="text")
    264278       
    265     #Ok
    266     def setobj(self,obj):
     279    def set_objective(self,obj):
    267280        r"""
    268         Sets the objective of the ``MIP``.
     281        Sets the objective of the ``MixedIntegerLinearProgram``.
    269282
    270283        INPUT:
    271284       
     
    284297              x is Real ( min = 0, max = None )
    285298              y is Real ( min = 0, max = None )
    286299
    287            sage: p=MIP(sense=1)
    288            sage: x=p.newvar()
    289            sage: p.setobj(x[1]+5*x[2])
    290            sage: p.addconstraint(x[1]+0.2*x[2],max=4)
    291            sage: p.addconstraint(1.5*x[1]+3*x[2],max=4)
     300           sage: p=MixedIntegerLinearProgram(sense=1)
     301           sage: x=p.new_variable()
     302           sage: p.set_objective(x[1]+5*x[2])
     303           sage: p.add_constraint(x[1]+0.2*x[2],max=4)
     304           sage: p.add_constraint(1.5*x[1]+3*x[2],max=4)
    292305           sage: p.solve()     # optional - requires Glpk or COIN-OR/CBC
    293306           6.6666666666666661
    294307           
    295308        """
    296309        self.objective=obj
    297310
    298     def addconstraint(self,linear_function,max=None,min=None):
     311    def add_constraint(self,linear_function,max=None,min=None):
    299312        r"""
    300         Adds a constraint to the MIP
     313        Adds a constraint to the ``MixedIntegerLinearProgram``
    301314       
    302315        INPUT :
    303316
     
    318331              x is Real ( min = 0, max = None )
    319332              y is Real ( min = 0, max = None )
    320333
    321            sage: p=MIP(sense=1)
    322            sage: x=p.newvar()
    323            sage: p.setobj(x[1]+5*x[2])
    324            sage: p.addconstraint(x[1]+0.2*x[2],max=4)
    325            sage: p.addconstraint(1.5*x[1]+3*x[2],max=4)
     334           sage: p=MixedIntegerLinearProgram(sense=1)
     335           sage: x=p.new_variable()
     336           sage: p.set_objective(x[1]+5*x[2])
     337           sage: p.add_constraint(x[1]+0.2*x[2],max=4)
     338           sage: p.add_constraint(1.5*x[1]+3*x[2],max=4)
    326339           sage: p.solve()     # optional - requires Glpk or COIN-OR/CBC
    327340           6.6666666666666661
    328341        """
     
    331344        min=float(min) if min!=None else None
    332345        self.constraints.append({"function":linear_function,"min":min, "max":max,"card":len(linear_function.variables())})
    333346
    334     def setbinary(self,e):
     347    def set_binary(self,e):
    335348        r"""
    336349        Sets a variable or a ``MIPVariable`` as binary
    337350
     
    340353        - ``e`` : An instance of ``MIPVariable`` or one of
    341354                  its elements
    342355
    343         NOTE:
     356        EXAMPLE::
    344357
    345         We recommend you to define the types of your variables after
    346         your problem has been completely defined ( see example )
    347 
    348         EXAMPLE:
    349 
    350           sage: p=MIP()
    351           sage: x=p.newvar()
     358          sage: p=MixedIntegerLinearProgram()
     359          sage: x=p.new_variable()
     360          sage: # With the following instruction, all the variables
     361          sage: # from x will be binary
     362          sage: p.set_binary(x)
     363          sage: p.set_objective(x[0]+x[1])
     364          sage: p.add_constraint(-3*x[0]+2*x[1],max=2)
    352365          sage: #
    353           sage: # The following instruction does absolutely nothing
    354           sage: # as none of the variables of x have been used yet
    355           sage: p.setbinary(x)
    356           sage: p.setobj(x[0]+x[1])
    357           sage: p.addconstraint(-3*x[0]+2*x[1],max=2)
    358           sage: #
    359           sage: # This instructions sets x[0] and x[1]
    360           sage: # as binary variables
    361           sage: p.setbinary(x)
    362           sage: p.addconstraint(x[3]+x[2],max=2)
    363           sage: #
    364           sage: # x[3] is not set as binary
    365           sage: # as no setbinary(x) has been called
    366           sage: # after its first definition
    367           sage: #
    368           sage: # Now it is done
    369           sage: p.setbinary(x[3])
     366          sage: # It is still possible, though, to set one of these
     367          sage: # variable as real while keeping the others as they are
     368          sage: p.set_real(x[3])
    370369        """
    371370        if isinstance(e,MIPVariable):
     371            e.vtype=self.__BINARY
    372372            if e.depth()==1:
    373373                for v in e.values():
    374374                    self.types[v]=self.__BINARY               
    375375            else:
    376376                for v in e.keys():
    377                     self.setbinary(e[v])
     377                    self.set_binary(e[v])
    378378        elif self.variables.has_key(e):       
    379379            self.types[e]=self.__BINARY
    380380        else:
    381381            raise Exception("Wrong kind of variable..")
    382382
    383     def isbinary(self,e):
     383    def is_binary(self,e):
    384384        r"""
    385385        Tests whether the variable is binary.
    386386
     
    394394
    395395        ``True`` if the variable is binary, ``False`` otherwise
    396396
    397         EXAMPLE:
     397        EXAMPLE::
    398398
    399             sage: p=MIP()
    400             sage: v=p.newvar()
    401             sage: p.setobj(v[1])
    402             sage: p.isbinary(v[1])
     399            sage: p=MixedIntegerLinearProgram()
     400            sage: v=p.new_variable()
     401            sage: p.set_objective(v[1])
     402            sage: p.is_binary(v[1])
    403403            False
    404             sage: p.setbinary(v[1])           
    405             sage: p.isbinary(v[1])
     404            sage: p.set_binary(v[1])           
     405            sage: p.is_binary(v[1])
    406406            True
    407407        """
    408408        # Returns an exception if the variable does not exist..
     
    414414            return True
    415415        return False
    416416
    417     def setinteger(self,e):
     417    def set_integer(self,e):
    418418        r"""
    419419        Sets a variable or a ``MIPVariable`` as integer
    420420
     
    423423        - ``e`` : An instance of ``MIPVariable`` or one of
    424424                  its elements
    425425
    426         NOTE:
    427426
    428         We recommend you to define the types of your variables after
    429         your problem has been completely defined ( see example )
     427        EXAMPLE::
    430428
    431         EXAMPLE:
     429          sage: p=MixedIntegerLinearProgram()
     430          sage: x=p.new_variable()
     431          sage: # With the following instruction, all the variables
     432          sage: # from x will be integers
     433          sage: p.set_integer(x)
     434          sage: p.set_objective(x[0]+x[1])
     435          sage: p.add_constraint(-3*x[0]+2*x[1],max=2)
     436          sage: #
     437          sage: # It is still possible, though, to set one of these
     438          sage: # variable as real while keeping the others as they are
     439          sage: p.set_real(x[3])
    432440
    433           sage: p=MIP()
    434           sage: x=p.newvar()
    435           sage: #
    436           sage: # The following instruction does absolutely nothing
    437           sage: # as none of the variables of x have been used yet
    438           sage: p.setinteger(x)
    439           sage: p.setobj(x[0]+x[1])
    440           sage: p.addconstraint(-3*x[0]+2*x[1],max=2)
    441           sage: #
    442           sage: # This instructions sets x[0] and x[1]
    443           sage: # as integer variables
    444           sage: p.setinteger(x)
    445           sage: p.addconstraint(x[3]+x[2],max=2)
    446           sage: #
    447           sage: # x[3] is not set as integer
    448           sage: # as no setinteger(x) has been called
    449           sage: # after its first definition
    450           sage: #
    451           sage: # Now it is done
    452           sage: p.setinteger(x[3])
    453441        """
    454442        if isinstance(e,MIPVariable):
     443            e.vtype=self.__INTEGER
    455444            if e.depth()==1:
    456445                for v in e.values():
    457446                    self.types[v]=self.__INTEGER               
    458447            else:
    459448                for v in e.keys():
    460                     self.setbinary(e[v])
     449                    self.set_integer(e[v])
    461450        elif self.variables.has_key(e):       
    462451            self.types[e]=self.__INTEGER
    463452        else:
    464453            raise Exception("Wrong kind of variable..")
    465454
    466     def isinteger(self,e):
     455    def is_integer(self,e):
    467456        r"""
    468457        Tests whether the variable is integer.
    469458
     
    477466
    478467        ``True`` if the variable is integer, ``False`` otherwise
    479468
    480         EXAMPLE:
     469        EXAMPLE::
    481470
    482             sage: p=MIP()
    483             sage: v=p.newvar()
    484             sage: p.setobj(v[1])
    485             sage: p.isinteger(v[1])
     471            sage: p=MixedIntegerLinearProgram()
     472            sage: v=p.new_variable()
     473            sage: p.set_objective(v[1])
     474            sage: p.is_integer(v[1])
    486475            False
    487             sage: p.setinteger(v[1])           
    488             sage: p.isinteger(v[1])
     476            sage: p.set_integer(v[1])           
     477            sage: p.is_integer(v[1])
    489478            True
    490479        """
    491480        # Returns an exception if the variable does not exist..
     
    497486            return True
    498487        return False
    499488
    500     def setreal(self,e):
     489    def set_real(self,e):
    501490        r"""
    502491        Sets a variable or a ``MIPVariable`` as real
    503492
     
    506495        - ``e`` : An instance of ``MIPVariable`` or one of
    507496                  its elements
    508497
    509         NOTE:
     498        EXAMPLE::
    510499
    511         We recommend you to define the types of your variables after
    512         your problem has been completely defined ( see example )
    513 
    514         EXAMPLE:
    515 
    516           sage: p=MIP()
    517           sage: x=p.newvar()
     500          sage: p=MixedIntegerLinearProgram()
     501          sage: x=p.new_variable()
     502          sage: # With the following instruction, all the variables
     503          sage: # from x will be real ( they are by default, though )
     504          sage: p.set_real(x)
     505          sage: p.set_objective(x[0]+x[1])
     506          sage: p.add_constraint(-3*x[0]+2*x[1],max=2)
    518507          sage: #
    519           sage: # The following instruction does absolutely nothing
    520           sage: # as none of the variables of x have been used yet
    521           sage: p.setreal(x)
    522           sage: p.setobj(x[0]+x[1])
    523           sage: p.addconstraint(-3*x[0]+2*x[1],max=2)
    524           sage: #
    525           sage: # This instructions sets x[0] and x[1]
    526           sage: # as real variables
    527           sage: p.setreal(x)
    528           sage: p.addconstraint(x[3]+x[2],max=2)
    529           sage: #
    530           sage: # x[3] is not set as real
    531           sage: # as no setreal(x) has been called
    532           sage: # after its first definition
    533           sage: # ( even if actually, it is as variables
    534           sage: # are real by default ... )
    535           sage: #
    536           sage: # Now it is done
    537           sage: p.setreal(x[3])
     508          sage: # It is still possible, though, to set one of these
     509          sage: # variable as binary while keeping the others as they are
     510          sage: p.set_binary(x[3])
    538511        """
    539512        if isinstance(e,MIPVariable):
     513            e.vtype=self.__REAL
    540514            if e.depth()==1:
    541515                for v in e.values():
    542516                    self.types[v]=self.__REAL               
    543517            else:
    544518                for v in e.keys():
    545                     self.setbinary(e[v])
     519                    self.set_real(e[v])
    546520        elif self.variables.has_key(e):       
    547521            self.types[e]=self.__REAL
    548522        else:
    549523            raise Exception("Wrong kind of variable..")
    550524
    551525
    552     def isreal(self,e):
     526    def is_real(self,e):
    553527        r"""
    554528        Tests whether the variable is real.
    555529
     
    563537
    564538        ``True`` if the variable is real, ``False`` otherwise
    565539
    566         EXAMPLE:
     540        EXAMPLE::
    567541
    568             sage: p=MIP()
    569             sage: v=p.newvar()
    570             sage: p.setobj(v[1])
    571             sage: p.isreal(v[1])
     542            sage: p=MixedIntegerLinearProgram()
     543            sage: v=p.new_variable()
     544            sage: p.set_objective(v[1])
     545            sage: p.is_real(v[1])
    572546            True
    573             sage: p.setbinary(v[1])
    574             sage: p.isreal(v[1])
     547            sage: p.set_binary(v[1])
     548            sage: p.is_real(v[1])
    575549            False
    576             sage: p.setreal(v[1])           
    577             sage: p.isreal(v[1])
     550            sage: p.set_real(v[1])           
     551            sage: p.is_real(v[1])
    578552            True
    579553        """
    580554       
     
    590564
    591565    def solve(self,solver=None,log=False,objective_only=False):
    592566        r"""
    593         Solves the MIP.
     567        Solves the MixedIntegerLinearProgram.
    594568
    595569        INPUT :
    596         - ``solver'' :
     570        - ``solver`` :
    597571                 3 solvers should be available through this class :
    598572                     - GLPK ( ``solver="GLPK"`` )
    599573                     http://www.gnu.org/software/glpk/
     
    636610           Variables:
    637611              x is Real ( min = 0, max = None )
    638612              y is Real ( min = 0, max = None )
     613             
     614        ::
    639615
    640 
    641            sage: p=MIP(sense=1)
    642            sage: x=p.newvar()
    643            sage: p.setobj(x[1]+5*x[2])
    644            sage: p.addconstraint(x[1]+0.2*x[2],max=4)
    645            sage: p.addconstraint(1.5*x[1]+3*x[2],max=4)
     616           sage: p=MixedIntegerLinearProgram(sense=1)
     617           sage: x=p.new_variable()
     618           sage: p.set_objective(x[1]+5*x[2])
     619           sage: p.add_constraint(x[1]+0.2*x[2],max=4)
     620           sage: p.add_constraint(1.5*x[1]+3*x[2],max=4)
    646621           sage: p.solve()           # optional - requires Glpk or COIN-OR/CBC
    647622           6.6666666666666661
    648623           sage: p.get_values(x)     # optional - requires Glpk or COIN-OR/CBC
     
    650625
    651626           sage: ### Computation of a maximum stable set in Petersen's graph ###
    652627           sage: g=graphs.PetersenGraph()
    653            sage: p=MIP(sense=1)
    654            sage: b=p.newvar()
    655            sage: p.setobj(sum([b[v] for v in g]))
     628           sage: p=MixedIntegerLinearProgram(sense=1)
     629           sage: b=p.new_variable()
     630           sage: p.set_objective(sum([b[v] for v in g]))
    656631           sage: for (u,v) in g.edges(labels=None):
    657            ...       p.addconstraint(b[u]+b[v],max=1)
    658            sage: p.setbinary(b)
     632           ...       p.add_constraint(b[u]+b[v],max=1)
     633           sage: p.set_binary(b)
    659634           sage: p.solve(objective_only=True)     # optional - requires Glpk or COIN-OR/CBC
    660635           4.0
    661 
    662 
    663636        """       
    664637
    665638        if self.objective==None:
     
    674647             try:
    675648                  from sage.numerical.mipCoin import solveCoin
    676649             except:
    677                 raise NotImplementedError("Coin/CBC is not installed and cannot be used to solve this MIP\n To install it, you can type in Sage : sage: install_package('cbc')")               
     650                raise NotImplementedError("Coin/CBC is not installed and cannot be used to solve this MixedIntegerLinearProgram\n To install it, you can type in Sage : sage: install_package('cbc')")               
    678651             return solveCoin(self,log=log,objective_only=objective_only)
    679652
    680653        elif solver=="GLPK":
    681654             try:
    682655                  from sage.numerical.mipGlpk import solveGlpk
    683656             except:
    684                 raise NotImplementedError("GLPK is not installed and cannot be used to solve this MIP\n To install it, you can type in Sage : sage: install_package('glpk')")               
     657                raise NotImplementedError("GLPK is not installed and cannot be used to solve this MixedIntegerLinearProgram\n To install it, you can type in Sage : sage: install_package('glpk')")               
    685658             return solveGlpk(self,log=log,objective_only=objective_only)
    686659        elif solver=="CPLEX":
    687660             raise NotImplementedError("The support for CPLEX is not written yet... We're seriously thinking about it, though ;-)")
     
    703676        values are their coefficients.
    704677        The value corresponding to key `-1` is the constant coefficient
    705678
    706         EXAMPLE:
     679        EXAMPLE::
    707680
    708             sage: p=MIP()
    709             sage: v=p.newvar()
     681            sage: p=MixedIntegerLinearProgram()
     682            sage: v=p.new_variable()
    710683            sage: p._NormalForm(v[0]+v[1])
    711684            {1: 1.0, 2: 1.0, -1: 0.0}
    712685        """
     
    714687        d[-1]=exp.constant_coefficient()
    715688        return d
    716689
    717     def _addElementToRing(self):
     690    def _add_element_to_ring(self,vtype):
    718691        r"""
    719692        Creates a new variable from the main ``InfinitePolynomialRing``
    720693
     
    722695
    723696        - The newly created variable
    724697
    725         EXAMPLE:
     698        EXAMPLE::
    726699
    727             sage: p=MIP()
    728             sage: v=p.newvar()
    729             sage: p.count[0]
     700            sage: p=MixedIntegerLinearProgram()
     701            sage: v=p.new_variable()
     702            sage: p.count
    730703            0
    731             sage: p._addElementToRing()
     704            sage: p._add_element_to_ring(p.__REAL)
    732705            x1
    733             sage: p.count[0]
     706            sage: p.count
    734707            1
    735708        """
    736         self.count[0]+=1
    737         v=self.x[self.count[0]]
    738         self.variables[v]=self.count[0]
    739         self.types[v]=self.__REAL
     709        self.count+=1
     710        v=self.x[self.count]
     711        self.variables[v]=self.count
     712        self.types[v]=vtype
    740713        self.min[v]=0.0
    741714        return v
    742715
    743     def setmin(self,v,min):
     716    def set_min(self,v,min):
    744717        r"""
    745718        Sets the minimum value of a variable
    746719
     
    752725
    753726        EXAMPLE::
    754727
    755             sage: p=MIP()
    756             sage: v=p.newvar()
    757             sage: p.setobj(v[1])
    758             sage: p.getmin(v[1])
     728            sage: p=MixedIntegerLinearProgram()
     729            sage: v=p.new_variable()
     730            sage: p.set_objective(v[1])
     731            sage: p.get_min(v[1])
    759732            0.0
    760             sage: p.setmin(v[1],6)
    761             sage: p.getmin(v[1])
     733            sage: p.set_min(v[1],6)
     734            sage: p.get_min(v[1])
    762735            6.0
    763736        """
    764737        self.min[v]=min
    765738
    766     def setmax(self,v,max):
     739    def set_max(self,v,max):
    767740        r"""
    768741        Sets the maximum value of a variable
    769742
     
    775748
    776749        EXAMPLE::
    777750
    778             sage: p=MIP()
    779             sage: v=p.newvar()
    780             sage: p.setobj(v[1])
    781             sage: p.getmax(v[1])
    782             sage: p.setmax(v[1],6)
    783             sage: p.getmax(v[1])
     751            sage: p=MixedIntegerLinearProgram()
     752            sage: v=p.new_variable()
     753            sage: p.set_objective(v[1])
     754            sage: p.get_max(v[1])
     755            sage: p.set_max(v[1],6)
     756            sage: p.get_max(v[1])
    784757            6.0
    785758        """
    786759        self.max[v]=max
    787760
    788761
    789     def getmin(self,v):
     762    def get_min(self,v):
    790763        r"""
    791764        Returns the minimum value of a variable
    792765
     
    801774
    802775        EXAMPLE::
    803776
    804             sage: p=MIP()
    805             sage: v=p.newvar()
    806             sage: p.setobj(v[1])
    807             sage: p.getmin(v[1])
     777            sage: p=MixedIntegerLinearProgram()
     778            sage: v=p.new_variable()
     779            sage: p.set_objective(v[1])
     780            sage: p.get_min(v[1])
    808781            0.0
    809             sage: p.setmin(v[1],6)
    810             sage: p.getmin(v[1])
     782            sage: p.set_min(v[1],6)
     783            sage: p.get_min(v[1])
    811784            6.0
    812785        """
    813         return float(self.min[v]) if self.min.has_key(v) else 0.0
    814     def getmax(self,v):
     786        return float(self.min[v]) if self.min.has_key(v) else None
     787
     788    def get_max(self,v):
    815789        r"""
    816790        Returns the maximum value of a variable
    817791
     
    826800
    827801        EXAMPLE::
    828802
    829             sage: p=MIP()
    830             sage: v=p.newvar()
    831             sage: p.setobj(v[1])
    832             sage: p.getmax(v[1])
    833             sage: p.setmax(v[1],6)
    834             sage: p.getmax(v[1])
     803            sage: p=MixedIntegerLinearProgram()
     804            sage: v=p.new_variable()
     805            sage: p.set_objective(v[1])
     806            sage: p.get_max(v[1])
     807            sage: p.set_max(v[1],6)
     808            sage: p.get_max(v[1])
    835809            6.0
    836810        """
    837811        return float(self.max[v]) if self.max.has_key(v) else None
     
    846820
    847821        ``MIPSolverException`` is the exception raised when the solver fails
    848822
    849         EXAMPLE:
     823        EXAMPLE::
    850824
    851825            sage: MIPSolverException("Error")
    852826            MIPSolverException()
     
    857831        r"""
    858832        Returns the value of the instance of ``MIPSolverException` `
    859833
    860         EXAMPLE:
     834        EXAMPLE::
    861835
    862836            sage: e=MIPSolverException("Error")
    863837            sage: print e
     
    867841
    868842class MIPVariable:
    869843     r"""
    870      ``MIPVariable`` is a variable used by the class ``MIP``
     844     ``MIPVariable`` is a variable used by the class ``MixedIntegerLinearProgram``
    871845     """
    872      def __init__(self,x,f,dim=1):
     846     def __init__(self,p,vtype,dim=1):
    873847         r"""
    874848         Constructor for ``MIPVariable``
    875849
    876850         INPUT:
    877851
    878          - ``x`` is the generator element of an ``InfinitePolynomialRing``
    879          - ``f`` is a function returning a new variable from the parent class
     852         - ``p`` is the instance of ``MixedIntegerLinearProgram`` to which the
     853            variable is to be linked.
    880854         - ``dim`` is the integer defining the definition of the variable
    881855
    882          For more informations, see method ``MIP.newvar``
     856         For more informations, see method ``MixedIntegerLinearProgram.new_variable``
    883857
    884          EXAMPLE:
     858         EXAMPLE::
    885859
    886             sage: p=MIP()
    887             sage: v=p.newvar()
     860            sage: p=MixedIntegerLinearProgram()
     861            sage: v=p.new_variable()
    888862           
    889863           
    890864         """
    891865         self.dim=dim
    892866         self.dict={}
    893          self.x=x
    894          self.f=f
     867         self.p=p
     868         self.vtype=vtype
    895869
    896870     def __getitem__(self,i):
    897871          r"""
     
    900874          Returns the element asked, otherwise creates it.
    901875          ( When depth>1, recursively creates the variables )
    902876
    903          EXAMPLE:
     877         EXAMPLE::
    904878
    905              sage: p=MIP()
    906              sage: v=p.newvar()
    907              sage: p.setobj(v[0]+v[1])
     879             sage: p=MixedIntegerLinearProgram()
     880             sage: v=p.new_variable()
     881             sage: p.set_objective(v[0]+v[1])
    908882             sage: v[0]
    909883             x1
    910884          """
    911885          if self.dict.has_key(i):
    912886               return self.dict[i]
    913887          elif self.dim==1:
    914               self.dict[i]=self.f()
     888              self.dict[i]=self.p._add_element_to_ring(self.vtype)
    915889              return self.dict[i]
    916890          else:
    917                self.dict[i]=MIPVariable(dim=self.dim-1,x=self.x, f=self.f)
     891               self.dict[i]=MIPVariable(self.p,self.vtype,dim=self.dim-1)
    918892               return self.dict[i]
    919893     def keys(self):
    920894         r"""
    921895         Returns the keys already defined in the dictionary
    922896
    923          EXAMPLE:
     897         EXAMPLE::
    924898
    925              sage: p=MIP()
    926              sage: v=p.newvar()
    927              sage: p.setobj(v[0]+v[1])
     899             sage: p=MixedIntegerLinearProgram()
     900             sage: v=p.new_variable()
     901             sage: p.set_objective(v[0]+v[1])
    928902             sage: v.keys()
    929903             [0, 1]
    930904         """
     
    933907         r"""
    934908         Returns the pairs (keys,value) contained in the dictionary
    935909
    936          EXAMPLE:
     910         EXAMPLE::
    937911
    938              sage: p=MIP()
    939              sage: v=p.newvar()
    940              sage: p.setobj(v[0]+v[1])
     912             sage: p=MixedIntegerLinearProgram()
     913             sage: v=p.new_variable()
     914             sage: p.set_objective(v[0]+v[1])
    941915             sage: v.items()
    942916             [(0, x1), (1, x2)]
    943917         """
     
    946920         r"""
    947921         Returns the current variable's depth
    948922
    949          EXAMPLE:
     923         EXAMPLE::
    950924
    951              sage: p=MIP()
    952              sage: v=p.newvar()
    953              sage: p.setobj(v[0]+v[1])
     925             sage: p=MixedIntegerLinearProgram()
     926             sage: v=p.new_variable()
     927             sage: p.set_objective(v[0]+v[1])
    954928             sage: v.depth()
    955929             1
    956930         """
     
    959933         r"""
    960934         Returns the symbolic variables associated to the current dictionary
    961935
    962          EXAMPLE:
     936         EXAMPLE::
    963937
    964              sage: p=MIP()
    965              sage: v=p.newvar()
    966              sage: p.setobj(v[0]+v[1])
     938             sage: p=MixedIntegerLinearProgram()
     939             sage: v=p.new_variable()
     940             sage: p.set_objective(v[0]+v[1])
    967941             sage: v.values()
    968942             [x1, x2]
    969943         """