Ticket #10341: trac_10431-part3.patch

File trac_10431-part3.patch, 30.3 KB (added by malb, 10 years ago)
  • sage/numerical/backends/generic_backend.pxd

    # HG changeset patch
    # User Martin Albrecht <martinralbrecht@googlemail.com>
    # Date 1290951182 0
    # Node ID cf07c22147a765fdb31736896575452e92719168
    # Parent  941d427801567a358c491463387f86495369a323
    #10341 more API changes
      * drop setting a variable name by col_name()
      * drop setting a constraint name by row_name()
      * add an optional parameter name to add_variable and add_linear_constraint
      * add an optional parameter obj to add_variable
      * unify get/set_objective_coefficient
    
    diff -r 941d42780156 -r cf07c22147a7 sage/numerical/backends/generic_backend.pxd
    a b  
    66##############################################################################
    77
    88cdef class GenericBackend:
    9     cpdef int add_variable(self, lower_bound=*, upper_bound=*, binary=*, continuous=*, integer=*) except -1
    10     cpdef int add_variables(self, int, lower_bound=*, upper_bound=*, binary=*, continuous=*, integer=*) except -1
     9    cpdef int add_variable(self, lower_bound=*, upper_bound=*, binary=*, continuous=*, integer=*, obj=*, name=*) except -1
     10    cpdef int add_variables(self, int, lower_bound=*, upper_bound=*, binary=*, continuous=*, integer=*, obj=*, names=*) except -1
    1111    cpdef set_variable_type(self, int variable, int vtype)
    1212    cpdef set_sense(self, int sense)
    13     cpdef set_objective_coefficient(self, int variable, double coeff)
     13    cpdef objective_coefficient(self, int variable, coeff=*)
    1414    cpdef set_objective(self, list coeff)
    1515    cpdef set_verbosity(self, int level)
    16     cpdef add_linear_constraint(self, constraints, lower_bound, upper_bound)
     16    cpdef add_linear_constraint(self, constraints, lower_bound, upper_bound, name=*)
    1717    cpdef add_col(self, list indices, list coeffs)
    18     cpdef add_linear_constraints(self, int number, lower_bound, upper_bound)
     18    cpdef add_linear_constraints(self, int number, lower_bound, upper_bound, names=*)
    1919    cpdef int solve(self) except -1
    2020    cpdef double get_objective_value(self)
    2121    cpdef double get_variable_value(self, int variable)
     
    2323    cpdef write_lp(self, char * name)
    2424    cpdef write_mps(self, char * name, int modern)
    2525    cpdef row(self, int i)
    26     cpdef double get_objective_coefficient(self, int i)
    2726    cpdef int ncols(self)
    2827    cpdef int nrows(self)
    2928    cpdef bint is_variable_binary(self, int)
     
    3332    cpdef problem_name(self, char * name = *)
    3433    cpdef row_bounds(self, int index)
    3534    cpdef col_bounds(self, int index)
    36     cpdef row_name(self, int index, char * name = *)
    37     cpdef col_name(self, int index, char * name = *)
     35    cpdef row_name(self, int index)
     36    cpdef col_name(self, int index)
    3837    cpdef variable_upper_bound(self, int index, value = *)
    3938    cpdef variable_lower_bound(self, int index, value = *)
    4039
  • sage/numerical/backends/generic_backend.pyx

    diff -r 941d42780156 -r cf07c22147a7 sage/numerical/backends/generic_backend.pyx
    a b  
    2626
    2727
    2828cdef class GenericBackend:
    29     cpdef int add_variable(self, lower_bound=0.0, upper_bound=None, binary=False, continuous=True, integer=False) except -1:
     29    cpdef int add_variable(self, lower_bound=0.0, upper_bound=None, binary=False, continuous=True, integer=False, obj=0.0, name=None) except -1:
    3030        """
    3131        Add a variable.
    3232
     
    4545
    4646        - ``integer`` - ``True`` if the variable is binary (default: ``False``).
    4747
     48        - ``obj`` - (optional) coefficient of this variable in the objective function (default: 0.0)
     49
     50        - ``name`` - an optional name for the newly added variable (default: ``None``).
     51
    4852        OUTPUT: The index of the newly created variable           
    4953
    5054        EXAMPLE::
     
    6569            Traceback (most recent call last):
    6670            ...
    6771            ValueError: ...           
     72            sage: p.add_variable(name='x',obj=1.0)                    # optional - Nonexistent_LP_solver
     73            3
     74            sage: p.col_name(3)                                       # optional - Nonexistent_LP_solver
     75            'x'
     76            sage: p.objective_coefficient(3)                          # optional - Nonexistent_LP_solver
     77            1.0
    6878        """
    6979        raise NotImplementedError()
    7080
    71     cpdef int add_variables(self, int n, lower_bound=0.0, upper_bound=None, binary=False, continuous=True, integer=False) except -1:
     81    cpdef int add_variables(self, int n, lower_bound=0.0, upper_bound=None, binary=False, continuous=True, integer=False, obj=0.0, names=None) except -1:
    7282        """
    7383        Add ``n`` variables.
    7484
     
    8999
    90100        - ``integer`` - ``True`` if the variable is binary (default: ``False``).
    91101
     102        - ``obj`` - (optional) coefficient of all variables in the objective function (default: 0.0)
     103
     104        - ``names`` - optional list of names (default: ``None``)
     105
    92106        OUTPUT: The index of the variable created last.
    93107
    94108        EXAMPLE::
     
    101115            4
    102116            sage: p.ncols()                                           # optional - Nonexistent_LP_solver
    103117            5
    104             sage: p.add_variables(2, lower_bound=-2.0, integer=True) # optional - Nonexistent_LP_solver
     118            sage: p.add_variables(2, lower_bound=-2.0, integer=True, names=['a','b']) # optional - Nonexistent_LP_solver
    105119            6
    106120        """
    107121        raise NotImplementedError()
     
    157171        """
    158172        raise NotImplementedError()
    159173
    160     cpdef  set_objective_coefficient(self, int variable, double coeff):
     174    cpdef  objective_coefficient(self, int variable, coeff=None):
    161175        """
    162         Set the coefficient of a variable in the objective function
     176        Set or get the coefficient of a variable in the objective
     177        function
    163178
    164179        INPUT:
    165180
     
    173188            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    174189            sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    175190            1
    176             sage: p.get_objective_coefficient(0)                         # optional - Nonexistent_LP_solver
     191            sage: p.objective_coefficient(0)                         # optional - Nonexistent_LP_solver
    177192            0.0
    178             sage: p.set_objective_coefficient(0,2)                       # optional - Nonexistent_LP_solver
    179             sage: p.get_objective_coefficient(0)                         # optional - Nonexistent_LP_solver
     193            sage: p.objective_coefficient(0,2)                       # optional - Nonexistent_LP_solver
     194            sage: p.objective_coefficient(0)                         # optional - Nonexistent_LP_solver
    180195            2.0
    181196        """
    182197        raise NotImplementedError()
     
    197212            sage: p.add_variables(5)                                 # optional - Nonexistent_LP_solver
    198213            5
    199214            sage: p.set_objective([1, 1, 2, 1, 3])                   # optional - Nonexistent_LP_solver
    200             sage: map(lambda x :p.get_objective_coeffient(x), range(5))  # optional - Nonexistent_LP_solver
     215            sage: map(lambda x :p.objective_coefficient(x), range(5))  # optional - Nonexistent_LP_solver
    201216            [1.0, 1.0, 2.0, 1.0, 3.0]
    202217        """
    203218        raise NotImplementedError()
     
    218233        """
    219234        raise NotImplementedError()
    220235
    221     cpdef add_linear_constraint(self, coefficients, lower_bound, upper_bound):
     236    cpdef add_linear_constraint(self, coefficients, lower_bound, upper_bound, name=None):
    222237        """
    223238        Add a linear constraint.
    224239
     
    232247
    233248        - ``upper_bound`` - an upper bound, either a real value or ``None``
    234249 
     250        - ``name`` - an optional name for this row (default: ``None``)
     251
    235252        EXAMPLE::
    236253
    237254            sage: from sage.numerical.backends.generic_backend import get_solver
     
    243260            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])                   # optional - Nonexistent_LP_solver
    244261            sage: p.row_bounds(0)                                  # optional - Nonexistent_LP_solver
    245262            (2.0, 2.0)
     263            sage: p.add_linear_constraint( zip(range(5), range(5)), 1.0, 1.0, name='foo') # optional - Nonexistent_LP_solver
     264            sage: p.row_name(-1)                                                          # optional - Nonexistent_LP_solver
     265            "foo"
    246266        """
    247267        raise NotImplementedError()
    248268
     
    282302        """
    283303        raise NotImplementedError()
    284304
    285     cpdef add_linear_constraints(self, int number, lower_bound, upper_bound):
     305    cpdef add_linear_constraints(self, int number, lower_bound, upper_bound, names=None):
    286306        """
    287307        Add constraints.
    288308
     
    294314
    295315        - ``upper_bound`` - an upper bound, either a real value or ``None``
    296316
     317        - ``names`` - an optional list of names (default: ``None``)
     318
    297319        EXAMPLE::
    298320
    299321            sage: from sage.numerical.backends.generic_backend import get_solver
     
    326348            sage: p.add_col(range(5), range(5))                    # optional - Nonexistent_LP_solver
    327349            sage: p.solve()                                        # optional - Nonexistent_LP_solver
    328350            0
    329             sage: p.set_objective_coefficient(0,1)                 # optional - Nonexistent_LP_solver
     351            sage: p.objective_coefficient(0,1)                 # optional - Nonexistent_LP_solver
    330352            sage: p.solve()                                        # optional - Nonexistent_LP_solver
    331353            Traceback (most recent call last):
    332354            ...
     
    530552        """
    531553        raise NotImplementedError()
    532554
    533     cpdef double get_objective_coefficient(self, int i):
    534         """
    535         Set the coefficient of a variable in the objective function
    536 
    537         INPUT:
    538 
    539         - ``variable`` (integer) -- the variable's id
    540 
    541         - ``coeff`` (double) -- its coefficient
    542 
    543         EXAMPLE::
    544 
    545             sage: from sage.numerical.backends.generic_backend import get_solver
    546             sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    547             sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    548             1
    549             sage: p.get_objective_coeffient(0)                         # optional - Nonexistent_LP_solver
    550             0.0
    551             sage: p.set_objective_coefficient(0,2)                       # optional - Nonexistent_LP_solver
    552             sage: p.get_objective_coeffient(0)                         # optional - Nonexistent_LP_solver
    553             2.0
    554         """
    555         raise NotImplementedError()
    556 
    557555    cpdef row_bounds(self, int index):
    558556        """
    559557        Return the bounds of a specific constraint.
     
    680678        """
    681679        raise NotImplementedError()
    682680
    683     cpdef row_name(self, int index, char * name = NULL):
     681    cpdef row_name(self, int index):
    684682        """
    685         Return or define the ``index`` th row name
     683        Return the ``index`` th row name
    686684
    687685        INPUT:
    688686
    689687        - ``index`` (integer) -- the row's id
    690688
    691         - ``name`` (``char *``) -- its name. When set to ``NULL``
    692           (default), the method returns the current name.
    693 
    694689        EXAMPLE::
    695690
    696691            sage: from sage.numerical.backends.generic_backend import get_solver
    697692            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    698             sage: p.add_linear_constraints(1, 2, None)         # optional - Nonexistent_LP_solver
    699             sage: p.row_name(0, "Empty constraint 1")          # optional - Nonexistent_LP_solver
    700             sage: p.row_name(0)                                # optional - Nonexistent_LP_solver
     693            sage: p.add_linear_constraints(1, 2, None, name="Empty constraint 1")  # optional - Nonexistent_LP_solver
     694            sage: p.row_name(0)                                     # optional - Nonexistent_LP_solver
    701695            'Empty constraint 1'
    702696
    703697        """
    704698        raise NotImplementedError()
    705699
    706     cpdef col_name(self, int index, char * name = NULL):
     700    cpdef col_name(self, int index):
    707701        """
    708         Return or define the ``index`` th col name
     702        Return the ``index`` th col name
    709703
    710704        INPUT:
    711705
     
    718712
    719713            sage: from sage.numerical.backends.generic_backend import get_solver
    720714            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    721             sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
     715            sage: p.add_variable(name="I am a variable")            # optional - Nonexistent_LP_solver
    722716            1
    723             sage: p.col_name(0, "I am a variable")             # optional - Nonexistent_LP_solver
    724             sage: p.col_name(0)                                # optional - Nonexistent_LP_solver
     717            sage: p.col_name(0)                                     # optional - Nonexistent_LP_solver
    725718            'I am a variable'
    726719        """
    727720        raise NotImplementedError()
  • sage/numerical/backends/glpk_backend.pyx

    diff -r 941d42780156 -r cf07c22147a7 sage/numerical/backends/glpk_backend.pyx
    a b  
    3535        else:
    3636            self.set_sense(-1)
    3737
    38     cpdef int add_variable(self, lower_bound=0.0, upper_bound=None, binary=False, continuous=False, integer=False) except -1:
     38    cpdef int add_variable(self, lower_bound=0.0, upper_bound=None, binary=False, continuous=False, integer=False, obj=0.0, name=None) except -1:
    3939        """
    4040        Add a variable.
    4141
    4242        This amounts to adding a new column to the matrix. By default,
    43         the variable is both positive and real.
     43        the variable is both positive, real and the coefficient in the
     44        objective function is 0.0.
    4445
    4546        INPUT:
    4647
     
    5455
    5556        - ``integer`` - ``True`` if the variable is binary (default: ``False``).
    5657
     58        - ``obj`` - (optional) coefficient of this variable in the objective function (default: 0.0)
     59
     60        - ``name`` - an optional name for the newly added variable (default: ``None``).
     61
    5762        OUTPUT: The index of the newly created variable           
    5863
    5964        EXAMPLE::
     
    7479            Traceback (most recent call last):
    7580            ...
    7681            ValueError: ...           
     82            sage: p.add_variable(name='x',obj=1.0)
     83            3
     84            sage: p.col_name(3)
     85            'x'
     86            sage: p.objective_coefficient(3)
     87            1.0
    7788        """
    7889        cdef int vtype = int(bool(binary)) + int(bool(continuous)) + int(bool(integer))
    7990        if  vtype == 0:
     
    93104            glp_set_col_kind(self.lp, n_var, GLP_BV)
    94105        elif integer:
    95106            glp_set_col_kind(self.lp, n_var, GLP_IV)
     107
     108        if name is not None:
     109            glp_set_col_name(self.lp, n_var, name)
    96110       
     111        if obj:
     112            self.objective_coefficient(n_var - 1, obj)
     113
    97114        return n_var - 1
    98115
    99     cpdef int add_variables(self, int number, lower_bound=0.0, upper_bound=None, binary=False, continuous=False, integer=False) except -1:
     116    cpdef int add_variables(self, int number, lower_bound=0.0, upper_bound=None, binary=False, continuous=False, integer=False, obj=0.0, names=None) except -1:
    100117        """
    101118        Add ``number`` new variables.
    102119
    103120        This amounts to adding new columns to the matrix. By default,
    104         the variables are both positive and real.
     121        the variables are both positive, real and theor coefficient in
     122        the objective function is 0.0.
    105123
    106124        INPUT:
    107125
     
    117135
    118136        - ``integer`` - ``True`` if the variable is binary (default: ``False``).
    119137
     138        - ``obj`` - (optional) coefficient of all variables in the objective function (default: 0.0)
     139
     140        - ``names`` - optional list of names (default: ``None``)
     141
    120142        OUTPUT: The index of the variable created last.
    121143
    122144        EXAMPLE::
     
    129151            4
    130152            sage: p.ncols()
    131153            5
    132             sage: p.add_variables(2, lower_bound=-2.0, integer=True)
     154            sage: p.add_variables(2, lower_bound=-2.0, integer=True, names=['a','b'])
    133155            6
    134156        """
    135157        cdef int vtype = int(bool(binary)) + int(bool(continuous)) + int(bool(integer))
     
    154176                glp_set_col_kind(self.lp, n_var - i, GLP_BV)
    155177            elif integer:
    156178                glp_set_col_kind(self.lp, n_var - i, GLP_IV)
     179
     180            if obj:
     181                self.bjective_coefficient(n_var - i - 1, obj)
     182
     183            if names is not None:
     184                glp_set_col_name(self.lp, n_var, names[number - i - 1])
     185
    157186        return n_var - 1
    158187
    159188    cpdef set_variable_type(self, int variable, int vtype):
     
    218247        else:
    219248            glp_set_obj_dir(self.lp, GLP_MIN)
    220249
    221     cpdef set_objective_coefficient(self, int variable, double coeff):
     250    cpdef objective_coefficient(self, int variable, coeff=None):
    222251        """
    223         Set the coefficient of a variable in the objective function
     252        Set or get the coefficient of a variable in the objective function
    224253
    225254        INPUT:
    226255
    227256        - ``variable`` (integer) -- the variable's id
    228257
    229         - ``coeff`` (double) -- its coefficient
     258        - ``coeff`` (double) -- its coefficient or ``None`` for
     259          reading (default: ``None``)
    230260
    231261        EXAMPLE::
    232262
     
    234264            sage: p = get_solver(solver = "GLPK")
    235265            sage: p.add_variable()
    236266            0
    237             sage: p.get_objective_coefficient(0)
     267            sage: p.objective_coefficient(0)
    238268            0.0
    239             sage: p.set_objective_coefficient(0,2)
    240             sage: p.get_objective_coefficient(0)
     269            sage: p.objective_coefficient(0,2)
     270            sage: p.objective_coefficient(0)
    241271            2.0
    242272        """
    243         glp_set_obj_coef(self.lp, variable + 1, coeff)
     273        if coeff is None:
     274            return glp_get_obj_coef(self.lp, variable + 1)
     275        else:
     276            glp_set_obj_coef(self.lp, variable + 1, coeff)
    244277
    245278    cpdef problem_name(self, char * name = NULL):
    246279        """
     
    287320            sage: p.add_variables(5)
    288321            4
    289322            sage: p.set_objective([1, 1, 2, 1, 3])
    290             sage: map(lambda x :p.get_objective_coefficient(x), range(5))
     323            sage: map(lambda x :p.objective_coefficient(x), range(5))
    291324            [1.0, 1.0, 2.0, 1.0, 3.0]
    292325        """
    293326        cdef int i
     
    319352        else:
    320353            self.iocp.msg_lev = GLP_MSG_ALL
    321354
    322     cpdef add_linear_constraint(self, coefficients, lower_bound, upper_bound):
     355    cpdef add_linear_constraint(self, coefficients, lower_bound, upper_bound, name=None):
    323356        """
    324357        Add a linear constraint.
    325358
     
    332365        - ``lower_bound`` - a lower bound, either a real value or ``None``
    333366
    334367        - ``upper_bound`` - an upper bound, either a real value or ``None``
     368
     369        - ``name`` - an optional name for this row (default: ``None``)
    335370 
    336371        EXAMPLE::
    337372
     
    344379            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    345380            sage: p.row_bounds(0)
    346381            (2.0, 2.0)
     382            sage: p.add_linear_constraint( zip(range(5), range(5)), 1.0, 1.0, name='foo')
     383            sage: p.row_name(1)
     384            'foo'
    347385        """
    348386        if lower_bound is None and upper_bound is None:
    349387            raise ValueError("At least one of 'upper_bound' or 'lower_bound' must be set.")
     
    373411            else:
    374412                glp_set_row_bnds(self.lp, n, GLP_DB, lower_bound, upper_bound)
    375413
     414        if name is not None:
     415            glp_set_row_name(self.lp, n, name)
     416
    376417        sage_free(row_i)
    377418        sage_free(row_values)
    378419
    379     cpdef add_linear_constraints(self, int number, lower_bound, upper_bound):
     420    cpdef add_linear_constraints(self, int number, lower_bound, upper_bound, names=None):
    380421        """
    381422        Add ``'number`` linear constraints.
    382423
     
    388429
    389430        - ``upper_bound`` - an upper bound, either a real value or ``None``
    390431
     432        - ``names`` - an optional list of names (default: ``None``)
     433
    391434        EXAMPLE::
    392435
    393436            sage: from sage.numerical.backends.generic_backend import get_solver
     
    399442            ([], [])
    400443            sage: p.row_bounds(4)
    401444            (None, 2.0)
     445            sage: p.add_linear_constraints(2, None, 2, names=['foo','bar'])
    402446        """
    403447        if lower_bound is None and upper_bound is None:
    404448            raise ValueError("At least one of 'upper_bound' or 'lower_bound' must be set.")
     
    417461                    glp_set_row_bnds(self.lp, n-i, GLP_FX, lower_bound, upper_bound)
    418462                else:
    419463                    glp_set_row_bnds(self.lp, n-i, GLP_DB, lower_bound, upper_bound)
     464            if names is not None:
     465                glp_set_row_name(self.lp, n-i, names[number-i-1])
    420466
    421467    cpdef row(self, int index):
    422468        r"""
     
    537583            (ub if ub != +DBL_MAX else None)
    538584            )
    539585
    540     cpdef double get_objective_coefficient(self, int index):
    541         """
    542         Return the coefficient of a variable in the objective
    543         function.
    544 
    545         INPUT:
    546 
    547         - ``index`` (integer) -- the variable's id.
    548 
    549         EXAMPLE::
    550 
    551             sage: from sage.numerical.backends.generic_backend import get_solver
    552             sage: p = get_solver(solver = "GLPK")
    553             sage: p.add_variable()
    554             0
    555             sage: p.get_objective_coefficient(0)
    556             0.0
    557             sage: p.set_objective_coefficient(0,2)
    558             sage: p.get_objective_coefficient(0)
    559             2.0
    560         """
    561         return glp_get_obj_coef(self.lp, index + 1)
    562            
    563 
    564586    cpdef add_col(self, list indices, list coeffs):
    565587        """
    566588        Add a column.
     
    632654            sage: p.add_col(range(5), range(5))
    633655            sage: p.solve()
    634656            0
    635             sage: p.set_objective_coefficient(0,1)
     657            sage: p.objective_coefficient(0,1)
    636658            sage: p.solve()
    637659            Traceback (most recent call last):
    638660            ...
     
    741763
    742764        return glp_get_num_rows(self.lp)
    743765
    744     cpdef col_name(self, int index, char * name = NULL):
     766    cpdef col_name(self, int index):
    745767        """
    746         Return or define the ``index`` th col name
     768        Return the ``index`` th col name
    747769
    748770        INPUT:
    749771
    750772        - ``index`` (integer) -- the col's id
    751773
    752         - ``name`` (``char *``) -- its name. When set to ``NULL``
    753           (default), the method returns the current name.
     774        EXAMPLE::
     775
     776            sage: from sage.numerical.backends.generic_backend import get_solver
     777            sage: p = get_solver(solver = "GLPK")
     778            sage: p.add_variable(name='I am a variable')
     779            0
     780            sage: p.col_name(0)
     781            'I am a variable'
     782        """
     783        cdef char * s
     784
     785        glp_create_index(self.lp)
     786        s = <char*> glp_get_col_name(self.lp, index + 1)
     787       
     788        if s != NULL:
     789            return s
     790        else:
     791            return ""
     792
     793    cpdef row_name(self, int index):
     794        """
     795        Return the ``index`` th row name
     796
     797        INPUT:
     798
     799        - ``index`` (integer) -- the row's id
    754800
    755801        EXAMPLE::
    756802
    757803            sage: from sage.numerical.backends.generic_backend import get_solver
    758804            sage: p = get_solver(solver = "GLPK")
    759             sage: p.add_variable()
    760             0
    761             sage: p.col_name(0, "I am a variable")
    762             sage: p.col_name(0)
    763             'I am a variable'
    764         """
    765         cdef char * s
    766 
    767         if name == NULL:
    768             glp_create_index(self.lp)
    769             s = <char*> glp_get_col_name(self.lp, index + 1)
    770            
    771             if s != NULL:
    772                 return s
    773             else:
    774                 return ""
    775         else:
    776             glp_set_col_name(self.lp, index + 1, name)
    777 
    778     cpdef row_name(self, int index, char * name = NULL):
    779         """
    780         Return or define the ``index`` th row name
    781 
    782         INPUT:
    783 
    784         - ``index`` (integer) -- the row's id
    785 
    786         - ``name`` (``char *``) -- its name. When set to ``NULL``
    787           (default), the method returns the current name.
    788 
    789         EXAMPLE::
    790 
    791             sage: from sage.numerical.backends.generic_backend import get_solver
    792             sage: p = get_solver(solver = "GLPK")
    793             sage: p.add_linear_constraints(1, 2, None)
    794             sage: p.row_name(0, "Empty constraint 1")
     805            sage: p.add_linear_constraints(1, 2, None, names=['Empty constraint 1'])
    795806            sage: p.row_name(0)
    796807            'Empty constraint 1'
    797808        """
    798809        cdef char *  s
    799810
    800         if name == NULL:
    801             glp_create_index(self.lp)
    802             s = <char*> glp_get_row_name(self.lp, index + 1)
     811        glp_create_index(self.lp)
     812        s = <char*> glp_get_row_name(self.lp, index + 1)
    803813           
    804             if s != NULL:
    805                 return s
    806             else:
    807                 return ""
     814        if s != NULL:
     815            return s
    808816        else:
    809             glp_set_row_name(self.lp, index + 1, name)
     817            return ""
    810818
    811819    cpdef bint is_variable_binary(self, int index):
    812820        """
  • sage/numerical/mip.pyx

    diff -r 941d42780156 -r cf07c22147a7 sage/numerical/mip.pyx
    a b  
    274274
    275275        self._backend.problem_name(name)
    276276
    277     def _update_variables_name(self):
    278         r"""
    279         Updates the names of the variables.
     277    # def _update_variables_name(self):
     278    #     r"""
     279    #     Updates the names of the variables.
    280280
    281         Only called before writing the Problem to a MPS or LP file.
     281    #     Only called before writing the Problem to a MPS or LP file.
    282282       
    283         EXAMPLE::
     283    #     EXAMPLE::
    284284
    285             sage: p=MixedIntegerLinearProgram()
    286             sage: v=p.new_variable(name="Test")
    287             sage: v[5]+v[99]
    288             x_0 +x_1
    289             sage: p._update_variables_name()
    290         """
     285    #         sage: p=MixedIntegerLinearProgram()
     286    #         sage: v=p.new_variable(name="Test")
     287    #         sage: v[5]+v[99]
     288    #         x_0 +x_1
     289    #         sage: p._update_variables_name()
     290    #     """
    291291
    292         for v in self._mipvariables:
    293             v._update_variables_name()
     292    #     for v in self._mipvariables:
     293    #         v._update_variables_name()
    294294
    295295
    296296    def new_variable(self, real=False, binary=False, integer=False, dim=1,name=None):
     
    386386        cdef int i, j
    387387        cdef double c
    388388        cdef GenericBackend b = self._backend
    389         self._update_variables_name()
     389        #self._update_variables_name()
    390390
    391391        inv_variables = [0]*len(self._variables)
    392392        for (v,id) in self._variables.iteritems():
     
    399399       
    400400        first = True
    401401        for 0<= i< b.ncols():
    402             c = b.get_objective_coefficient(i)
     402            c = b.objective_coefficient(i)
    403403            if c != 0:
    404404
    405405                value+= ((" +" if (not first and c>0) else " ") +
    406                          str(inv_variables[i]*b.get_objective_coefficient(i))
     406                         str(inv_variables[i]*b.objective_coefficient(i))
    407407                         )
    408408                first = False
    409409
     
    729729            sage: b = p.new_variable()
    730730            sage: p.add_constraint( b[8] - b[15] <= 3*b[8] + 9)
    731731            sage: p.show()
    732            
     732            Maximization:
     733            <BLANKLINE>
     734            Constraints:
     735              -2.0 x_0 -1.0 x_1 <= 9.0
     736            Variables:
     737              x_0 is a real variable (min=0.0, max=+oo)
     738              x_1 is a real variable (min=0.0, max=+oo)
     739
    733740        Empty constraint::
    734741
    735742            sage: p=MixedIntegerLinearProgram()
     
    776783            if min == None and max == None:
    777784                raise ValueError("Both max and min are set to None ? Weird!")
    778785
    779             self._backend.add_linear_constraint(C, min, max)
    780 
    781             if name != None:
    782                 self._backend.row_name(self._backend.nrows()-1,name)
     786            self._backend.add_linear_constraint(C, min, max, name)
    783787
    784788        elif isinstance(linear_function,LinearConstraint):
    785789            functions = linear_function.constraints
     
    13351339            self._dict[i] = MIPVariable(self._p, self._vtype, dim=self._dim-1)
    13361340            return self._dict[i]
    13371341
    1338     def _update_variables_name(self, prefix=None):
    1339         r"""
    1340         Updates the names of the variables in the parent instant of ``MixedIntegerLinearProgram``.
     1342    # def _update_variables_name(self, prefix=None):
     1343    #     r"""
     1344    #     Updates the names of the variables in the parent instant of ``MixedIntegerLinearProgram``.
    13411345
    1342         Only called before writing the Problem to a MPS or LP file.
     1346    #     Only called before writing the Problem to a MPS or LP file.
    13431347       
    1344         EXAMPLE::
     1348    #     EXAMPLE::
    13451349
    1346             sage: p=MixedIntegerLinearProgram()
    1347             sage: v=p.new_variable(name="Test")
    1348             sage: v[5]+v[99]
    1349             x_0 +x_1
    1350             sage: v._update_variables_name()
    1351         """
     1350    #         sage: p=MixedIntegerLinearProgram()
     1351    #         sage: v=p.new_variable(name="Test")
     1352    #         sage: v[5]+v[99]
     1353    #         x_0 +x_1
     1354    #         sage: v._update_variables_name()
     1355    #     """
    13521356
    1353         if prefix == None:
    1354             prefix = self._name
     1357    #     if prefix == None:
     1358    #         prefix = self._name
    13551359
    1356         if self._dim == 1:
    1357             for (k,v) in self._dict.iteritems():
    1358                 name = prefix + "[" + str(k) + "]"
    1359                 self._p._backend.col_name(self._p._variables[v], name)
    1360                 #self._p._variables_name[self._p._variables[v]]=prefix + "[" + str(k) + "]"
    1361         else:
    1362             for v in self._dict.itervalues():
    1363                 v._update_variables_name(prefix=prefix + "(" + str(k) + ")")
    1364                
    1365                
     1360    #     if self._dim == 1:
     1361    #         for (k,v) in self._dict.iteritems():
     1362    #             name = prefix + "[" + str(k) + "]"
     1363    #             self._p._backend.col_name(self._p._variables[v], name)
     1364    #             #self._p._variables_name[self._p._variables[v]]=prefix + "[" + str(k) + "]"
     1365    #     else:
     1366    #         for v in self._dict.itervalues():
     1367    #             v._update_variables_name(prefix=prefix + "(" + str(k) + ")")
     1368                               
    13661369
    13671370    def __repr__(self):
    13681371        r"""