Ticket #10043: trac_10043_review1.patch

File trac_10043_review1.patch, 144.5 KB (added by jdemeyer, 9 years ago)

Same as trac_10043 - review 1.patch

  • sage/numerical/backends/coin_backend.pyx

    # HG changeset patch
    # User Nathann Cohen <nathann.cohen@gmail.com>
    # Date 1287420379 -7200
    # Node ID f3c711eb0c73f57c3b15a0b62dd87a1fc4c82cf2
    # Parent  0b5f2ba89540c90760c269b99226082ab52b96d7
    [mq]: fix
    
    diff -r 0b5f2ba89540 -r f3c711eb0c73 sage/numerical/backends/coin_backend.pyx
    a b  
    1616        import multiprocessing
    1717        model.setNumberThreads(multiprocessing.cpu_count())
    1818
    19         self.set_log_level(0)
     19        self.set_verbosity(0)
    2020
    2121        if maximization:
    22             self.set_direction(+1)
     22            self.set_sense(+1)
    2323        else:
    24             self.set_direction(-1)
     24            self.set_sense(-1)
    2525
    2626    cpdef int add_variable(self):
    2727        r"""
     
    3232
    3333        EXAMPLE::
    3434
    35             sage: from sage.numerical.backends.generic_backend import getSolver
    36             sage: p = getSolver(solver = "Coin")    # optional - Coin
    37             sage: p.n_cols()                                         # optional - Coin
     35            sage: from sage.numerical.backends.generic_backend import get_solver
     36            sage: p = get_solver(solver = "Coin")    # optional - Coin
     37            sage: p.ncols()                                         # optional - Coin
    3838            0
    3939            sage: p.add_variable()                                   # optional - Coin
    4040            1
    41             sage: p.n_cols()                                         # optional - Coin
     41            sage: p.ncols()                                         # optional - Coin
    4242            1
    4343        """
    4444
     
    5454
    5555        EXAMPLE::
    5656
    57             sage: from sage.numerical.backends.generic_backend import getSolver
    58             sage: p = getSolver(solver = "Coin")    # optional - Coin
    59             sage: p.n_cols()                                         # optional - Coin
     57            sage: from sage.numerical.backends.generic_backend import get_solver
     58            sage: p = get_solver(solver = "Coin")    # optional - Coin
     59            sage: p.ncols()                                         # optional - Coin
    6060            0
    6161            sage: p.add_variables(5)                                 # optional - Coin
    6262            5
    63             sage: p.n_cols()                                         # optional - Coin
     63            sage: p.ncols()                                         # optional - Coin
    6464            5
    6565        """
    6666
     
    8585
    8686        EXAMPLE::
    8787
    88             sage: from sage.numerical.backends.generic_backend import getSolver
    89             sage: p = getSolver(solver = "Coin")   # optional - Coin
    90             sage: p.n_cols()                                        # optional - Coin
     88            sage: from sage.numerical.backends.generic_backend import get_solver
     89            sage: p = get_solver(solver = "Coin")   # optional - Coin
     90            sage: p.ncols()                                        # optional - Coin
    9191            0
    9292            sage: p.add_variable()                                  # optional - Coin
    9393            1
     
    105105        else:
    106106            self.si.setContinuous(variable)
    107107
    108     cpdef set_direction(self, int sense):
     108    cpdef set_sense(self, int sense):
    109109        r"""
    110110        Sets the direction (maximization/minimization).
    111111
     
    118118
    119119        EXAMPLE::
    120120
    121             sage: from sage.numerical.backends.generic_backend import getSolver
    122             sage: p = getSolver(solver = "Coin")  # optional - Coin
     121            sage: from sage.numerical.backends.generic_backend import get_solver
     122            sage: p = get_solver(solver = "Coin")  # optional - Coin
    123123            sage: p.is_maximization()                              # optional - Coin
    124124            True
    125             sage: p.set_direction(-1)                              # optional - Coin
     125            sage: p.set_sense(-1)                              # optional - Coin
    126126            sage: p.is_maximization()                              # optional - Coin
    127127            False
    128128        """
    129129        self.si.setObjSense(-sense)
    130130
    131     cpdef set_objective_coeff(self, int variable, double coeff):
     131    cpdef set_objective_coefficient(self, int variable, double coeff):
    132132        r"""
    133133        Sets the coefficient of a variable in the objective function
    134134
     
    140140
    141141        EXAMPLE::
    142142
    143             sage: from sage.numerical.backends.generic_backend import getSolver
    144             sage: p = getSolver(solver = "Coin")  # optional - Coin
     143            sage: from sage.numerical.backends.generic_backend import get_solver
     144            sage: p = get_solver(solver = "Coin")  # optional - Coin
    145145            sage: p.add_variable()                                 # optional - Coin
    146146            1
    147147            sage: p.get_objective_coeff(0)                         # optional - Coin
    148148            0.0
    149             sage: p.set_objective_coeff(0,2)                       # optional - Coin
     149            sage: p.set_objective_coefficient(0,2)                       # optional - Coin
    150150            sage: p.get_objective_coeff(0)                         # optional - Coin
    151151            2.0
    152152        """
     
    164164
    165165        EXAMPLE::
    166166
    167             sage: from sage.numerical.backends.generic_backend import getSolver
    168             sage: p = getSolver(solver = "Coin")    # optional - Coin
     167            sage: from sage.numerical.backends.generic_backend import get_solver
     168            sage: p = get_solver(solver = "Coin")    # optional - Coin
    169169            sage: p.add_variables(5)                                 # optional - Coin
    170170            5
    171171            sage: p.set_objective([1, 1, 2, 1, 3])                   # optional - Coin
     
    177177        for i,v in enumerate(coeff):
    178178            self.si.setObjCoeff(i, v)
    179179
    180     cpdef set_log_level(self, int level):
     180    cpdef set_verbosity(self, int level):
    181181        r"""
    182182        Sets the log (verbosity) level
    183183
     
    187187
    188188        EXAMPLE::
    189189
    190             sage: from sage.numerical.backends.generic_backend import getSolver
    191             sage: p = getSolver(solver = "Coin")   # optional - Coin
    192             sage: p.set_log_level(2)                                # optional - Coin
     190            sage: from sage.numerical.backends.generic_backend import get_solver
     191            sage: p = get_solver(solver = "Coin")   # optional - Coin
     192            sage: p.set_verbosity(2)                                # optional - Coin
    193193
    194194        """
    195195
     
    219219
    220220        EXAMPLE::
    221221
    222             sage: from sage.numerical.backends.generic_backend import getSolver
    223             sage: p = getSolver(solver = "Coin")   # optional - Coin
     222            sage: from sage.numerical.backends.generic_backend import get_solver
     223            sage: p = get_solver(solver = "Coin")   # optional - Coin
    224224            sage: p.add_variables(5)                                # optional - Coin
    225225            5
    226226            sage: p.add_constraints(5, +1, 2)                       # optional - Coin
    227             sage: p.get_row(4)                                      # optional - Coin
     227            sage: p.row(4)                                      # optional - Coin
    228228            ([], [])
    229             sage: p.get_row_bounds(4)                               # optional - Coin
     229            sage: p.row_bounds(4)                               # optional - Coin
    230230            (None, 2.0)
    231231        """
    232232
     
    266266
    267267        EXAMPLE::
    268268
    269             sage: from sage.numerical.backends.generic_backend import getSolver
    270             sage: p = getSolver(solver = "Coin") # optional - Coin
     269            sage: from sage.numerical.backends.generic_backend import get_solver
     270            sage: p = get_solver(solver = "Coin") # optional - Coin
    271271            sage: p.add_variables(5)                              # optional - Coin
    272272            5
    273273            sage: p.add_constraint(range(5), range(5), 0, 2)      # optional - Coin
    274             sage: p.get_row(0)                                    # optional - Coin
     274            sage: p.row(0)                                    # optional - Coin
    275275            ([0, 1, 2, 3, 4], [0.0, 1.0, 2.0, 3.0, 4.0])
    276             sage: p.get_row_bounds(0)                             # optional - Coin
     276            sage: p.row_bounds(0)                             # optional - Coin
    277277            (2.0, 2.0)
    278278        """
    279279
     
    290290                        bound if direction != -1 else +self.si.getInfinity())
    291291
    292292
    293     cpdef get_row(self, int index):
     293    cpdef row(self, int index):
    294294        r"""
    295295        Returns a row
    296296
     
    307307
    308308        EXAMPLE::
    309309
    310             sage: from sage.numerical.backends.generic_backend import getSolver
    311             sage: p = getSolver(solver = "Coin")  # optional - Coin
     310            sage: from sage.numerical.backends.generic_backend import get_solver
     311            sage: p = get_solver(solver = "Coin")  # optional - Coin
    312312            sage: p.add_variables(5)                               # optional - Coin
    313313            5
    314314            sage: p.add_constraint(range(5), range(5), 0, 2)       # optional - Coin
    315             sage: p.get_row(0)                                     # optional - Coin
     315            sage: p.row(0)                                     # optional - Coin
    316316            ([0, 1, 2, 3, 4], [0.0, 1.0, 2.0, 3.0, 4.0])
    317             sage: p.get_row_bounds(0)                              # optional - Coin
     317            sage: p.row_bounds(0)                              # optional - Coin
    318318            (2.0, 2.0)
    319319        """
    320320
     
    336336
    337337        return (indices, values)
    338338
    339     cpdef get_row_bounds(self, int i):
     339    cpdef row_bounds(self, int i):
    340340        r"""
    341341        Returns the bounds of a specific constraint.
    342342
     
    352352
    353353        EXAMPLE::
    354354
    355             sage: from sage.numerical.backends.generic_backend import getSolver
    356             sage: p = getSolver(solver = "Coin")  # optional - Coin
     355            sage: from sage.numerical.backends.generic_backend import get_solver
     356            sage: p = get_solver(solver = "Coin")  # optional - Coin
    357357            sage: p.add_variables(5)                               # optional - Coin
    358358            5
    359359            sage: p.add_constraint(range(5), range(5), 0, 2)       # optional - Coin
    360             sage: p.get_row(0)                                     # optional - Coin
     360            sage: p.row(0)                                     # optional - Coin
    361361            ([0, 1, 2, 3, 4], [0.0, 1.0, 2.0, 3.0, 4.0])
    362             sage: p.get_row_bounds(0)                              # optional - Coin
     362            sage: p.row_bounds(0)                              # optional - Coin
    363363            (2.0, 2.0)
    364364        """
    365365
     
    372372        return (lb[i] if lb[i] != - self.si.getInfinity() else None,
    373373                ub[i] if ub[i] != + self.si.getInfinity() else None)
    374374
    375     cpdef get_col_bounds(self, int i):
     375    cpdef col_bounds(self, int i):
    376376        r"""
    377377        Returns the bounds of a specific variable.
    378378
     
    388388
    389389        EXAMPLE::
    390390
    391             sage: from sage.numerical.backends.generic_backend import getSolver
    392             sage: p = getSolver(solver = "Coin")  # optional - Coin
     391            sage: from sage.numerical.backends.generic_backend import get_solver
     392            sage: p = get_solver(solver = "Coin")  # optional - Coin
    393393            sage: p.add_variable()                                 # optional - Coin
    394394            1
    395             sage: p.get_col_bounds(0)                              # optional - Coin
     395            sage: p.col_bounds(0)                              # optional - Coin
    396396            (0.0, None)
    397             sage: p.set_variable_max(0, 5)                         # optional - Coin
    398             sage: p.get_col_bounds(0)                              # optional - Coin
     397            sage: p.variable_max(0, 5)                         # optional - Coin
     398            sage: p.col_bounds(0)                              # optional - Coin
    399399            (0.0, 5.0)
    400400        """
    401401
     
    434434
    435435        EXAMPLE::
    436436
    437             sage: from sage.numerical.backends.generic_backend import getSolver
    438             sage: p = getSolver(solver = "Coin")  # optional - Coin
    439             sage: p.n_cols()                                       # optional - Coin
     437            sage: from sage.numerical.backends.generic_backend import get_solver
     438            sage: p = get_solver(solver = "Coin")  # optional - Coin
     439            sage: p.ncols()                                       # optional - Coin
    440440            0
    441             sage: p.n_rows()                                       # optional - Coin
     441            sage: p.nrows()                                       # optional - Coin
    442442            0
    443443            sage: p.add_constraints(5, -1, 0)                      # optional - Coin
    444444            sage: p.add_col(range(5), range(5))                    # optional - Coin
    445             sage: p.n_rows()                                       # optional - Coin
     445            sage: p.nrows()                                       # optional - Coin
    446446            5
    447447        """
    448448
     
    470470
    471471        EXAMPLE::
    472472
    473             sage: from sage.numerical.backends.generic_backend import getSolver
    474             sage: p = getSolver(solver = "Coin")    # optional - Coin
     473            sage: from sage.numerical.backends.generic_backend import get_solver
     474            sage: p = get_solver(solver = "Coin")    # optional - Coin
    475475            sage: p.add_constraints(5, -1, 0)       # optional - Coin
    476476            sage: p.add_col(range(5), [1,2,3,4,5])  # optional - Coin
    477477            sage: p.solve()                         # optional - Coin
     
    479479
    480480        TESTS::
    481481
    482             sage: from sage.numerical.backends.generic_backend import getSolver
    483             sage: p = getSolver(solver = "Coin")    # optional - Coin
     482            sage: from sage.numerical.backends.generic_backend import get_solver
     483            sage: p = get_solver(solver = "Coin")    # optional - Coin
    484484            sage: p.add_variable()                  # optional - Coin
    485485            1
    486486            sage: p.add_constraint([0], [1], +1, 4) # optional - Coin
    487487            sage: p.add_constraint([0], [1], -1, 6) # optional - Coin
    488             sage: p.set_objective_coeff(0,1)        # optional - Coin
     488            sage: p.set_objective_coefficient(0,1)        # optional - Coin
    489489            sage: p.solve()                         # optional - Coin
    490490            Traceback (most recent call last):
    491491            ...
     
    521521
    522522        EXAMPLE::
    523523
    524             sage: from sage.numerical.backends.generic_backend import getSolver
    525             sage: p = getSolver(solver = "Coin")  # optional - Coin
     524            sage: from sage.numerical.backends.generic_backend import get_solver
     525            sage: p = get_solver(solver = "Coin")  # optional - Coin
    526526            sage: p.add_variables(2)                               # optional - Coin
    527527            2
    528528            sage: p.add_constraint([0, 1], [1, 2], +1, 3)          # optional - Coin
     
    549549
    550550        EXAMPLE::
    551551
    552             sage: from sage.numerical.backends.generic_backend import getSolver
    553             sage: p = getSolver(solver = "Coin") # optional - Coin
     552            sage: from sage.numerical.backends.generic_backend import get_solver
     553            sage: p = get_solver(solver = "Coin") # optional - Coin
    554554            sage: p.add_variables(2)                              # optional - Coin
    555555            2
    556556            sage: p.add_constraint([0, 1], [1, 2], +1, 3)         # optional - Coin
     
    569569        solution = <double*> self.si.getColSolution()
    570570        return solution[variable]
    571571
    572     cpdef int n_cols(self):
     572    cpdef int ncols(self):
    573573        r"""
    574574        Returns the number of columns/variables.
    575575
    576576        EXAMPLE::
    577577
    578             sage: from sage.numerical.backends.generic_backend import getSolver
    579             sage: p = getSolver(solver = "Coin")  # optional - Coin
    580             sage: p.n_cols()                                       # optional - Coin
     578            sage: from sage.numerical.backends.generic_backend import get_solver
     579            sage: p = get_solver(solver = "Coin")  # optional - Coin
     580            sage: p.ncols()                                       # optional - Coin
    581581            0
    582582            sage: p.add_variables(2)                               # optional - Coin
    583583            2
    584             sage: p.n_cols()                                       # optional - Coin
     584            sage: p.ncols()                                       # optional - Coin
    585585            2
    586586        """
    587587
    588588        return self.si.getNumCols()
    589589
    590     cpdef int n_rows(self):
     590    cpdef int nrows(self):
    591591        r"""
    592592        Returns the number of rows/constraints.
    593593
    594594        EXAMPLE::
    595595
    596             sage: from sage.numerical.backends.generic_backend import getSolver
    597             sage: p = getSolver(solver = "Coin") # optional - Coin
    598             sage: p.n_rows()                                      # optional - Coin
     596            sage: from sage.numerical.backends.generic_backend import get_solver
     597            sage: p = get_solver(solver = "Coin") # optional - Coin
     598            sage: p.nrows()                                      # optional - Coin
    599599            0
    600600            sage: p.add_constraints(2, -1, 2)                     # optional - Coin
    601             sage: p.n_rows()                                      # optional - Coin
     601            sage: p.nrows()                                      # optional - Coin
    602602            2
    603603        """
    604604        return self.si.getNumRows()
     
    614614
    615615        EXAMPLE::
    616616
    617             sage: from sage.numerical.backends.generic_backend import getSolver
    618             sage: p = getSolver(solver = "Coin")  # optional - Coin
    619             sage: p.n_cols()                                       # optional - Coin
     617            sage: from sage.numerical.backends.generic_backend import get_solver
     618            sage: p = get_solver(solver = "Coin")  # optional - Coin
     619            sage: p.ncols()                                       # optional - Coin
    620620            0
    621621            sage: p.add_variable()                                 # optional - Coin
    622622            1
     
    627627        """
    628628
    629629        return (0 == self.si.isContinuous(index) and
    630                 self.get_variable_min(index) == 0 and
    631                 self.get_variable_max(index) == 1)     
     630                self.variable_min(index) == 0 and
     631                self.variable_max(index) == 1)     
    632632
    633633    cpdef bint is_variable_integer(self, int index):
    634634        r"""
     
    640640
    641641        EXAMPLE::
    642642
    643             sage: from sage.numerical.backends.generic_backend import getSolver
    644             sage: p = getSolver(solver = "Coin")  # optional - Coin
    645             sage: p.n_cols()                                       # optional - Coin
     643            sage: from sage.numerical.backends.generic_backend import get_solver
     644            sage: p = get_solver(solver = "Coin")  # optional - Coin
     645            sage: p.ncols()                                       # optional - Coin
    646646            0
    647647            sage: p.add_variable()                                 # optional - Coin
    648648            1
     
    651651            True
    652652        """
    653653        return (0 == self.si.isContinuous(index) and
    654                 (self.get_variable_min(index) != 0 or
    655                 self.get_variable_max(index) != 1))
     654                (self.variable_min(index) != 0 or
     655                self.variable_max(index) != 1))
    656656
    657657    cpdef bint is_variable_continuous(self, int index):
    658658        r"""
     
    664664
    665665        EXAMPLE::
    666666
    667             sage: from sage.numerical.backends.generic_backend import getSolver
    668             sage: p = getSolver(solver = "Coin")  # optional - Coin
    669             sage: p.n_cols()                                       # optional - Coin
     667            sage: from sage.numerical.backends.generic_backend import get_solver
     668            sage: p = get_solver(solver = "Coin")  # optional - Coin
     669            sage: p.ncols()                                       # optional - Coin
    670670            0
    671671            sage: p.add_variable()                                 # optional - Coin
    672672            1
     
    686686
    687687        EXAMPLE::
    688688
    689             sage: from sage.numerical.backends.generic_backend import getSolver
    690             sage: p = getSolver(solver = "Coin") # optional - Coin
     689            sage: from sage.numerical.backends.generic_backend import get_solver
     690            sage: p = get_solver(solver = "Coin") # optional - Coin
    691691            sage: p.is_maximization()                             # optional - Coin
    692692            True
    693             sage: p.set_direction(-1)                             # optional - Coin
     693            sage: p.set_sense(-1)                             # optional - Coin
    694694            sage: p.is_maximization()                             # optional - Coin
    695695            False
    696696        """
    697697
    698698        return self.si.getObjSense() == -1
    699699
    700 
    701     cpdef get_variable_max(self, int i):
     700    cpdef variable_max(self, int index, value = False):
    702701        r"""
    703         Returns the upper bound on a variable
    704 
    705         INPUT:
    706 
    707         - ``index`` (integer) -- the variable's id
    708 
    709         OUTPUT:
    710 
    711         A real value if the variable has an upper bound, ``None``
    712         otherwise.
    713 
    714         EXAMPLE::
    715 
    716             sage: from sage.numerical.backends.generic_backend import getSolver
    717             sage: p = getSolver(solver = "Coin")  # optional - Coin
    718             sage: p.add_variable()                                 # optional - Coin
    719             1
    720             sage: p.get_variable_max(0) is None                    # optional - Coin
    721             True
    722             sage: p.set_variable_max(0, 5)                         # optional - Coin
    723             sage: p.get_variable_max(0)                            # optional - Coin
    724             5.0
    725 
    726         """
    727 
    728         cdef double * ub
    729         ub = <double*> self.si.getColUpper()
    730         return ub[i] if ub[i] != + self.si.getInfinity() else None
    731 
    732 
    733     cpdef get_variable_min(self, int i):
    734         r"""
    735         Returns the lower bound on a variable
    736 
    737         INPUT:
    738 
    739         - ``index`` (integer) -- the variable's id
    740 
    741         OUTPUT:
    742 
    743         A real value if the variable has an lower bound, ``None``
    744         otherwise.
    745 
    746         EXAMPLE::
    747 
    748             sage: from sage.numerical.backends.generic_backend import getSolver
    749             sage: p = getSolver(solver = "Coin")  # optional - Coin
    750             sage: p.add_variable()                                 # optional - Coin
    751             1
    752             sage: p.get_variable_min(0)                            # optional - Coin
    753             0.0
    754             sage: p.set_variable_min(0, 5)                         # optional - Coin
    755             sage: p.get_variable_min(0)                            # optional - Coin
    756             5.0
    757         """
    758 
    759         cdef double * lb
    760         lb = <double*> self.si.getColLower()
    761         return lb[i] if lb[i] != - self.si.getInfinity() else None
    762 
    763     cpdef set_variable_max(self, int index, value):
    764         r"""
    765         Sets the upper bound on a variable
     702        Returns or defines the upper bound on a variable
    766703
    767704        INPUT:
    768705
    769706        - ``index`` (integer) -- the variable's id
    770707
    771708        - ``value`` -- real value, or ``None`` to mean that the
    772           variable has not upper bound.
     709          variable has not upper bound. When set to ``False``
     710          (default), the method returns the current value.
    773711
    774712        EXAMPLE::
    775713
    776             sage: from sage.numerical.backends.generic_backend import getSolver
    777             sage: p = getSolver(solver = "Coin")  # optional - Coin
     714            sage: from sage.numerical.backends.generic_backend import get_solver
     715            sage: p = get_solver(solver = "Coin")  # optional - Coin
    778716            sage: p.add_variable()                                 # optional - Coin
    779717            1
    780             sage: p.get_col_bounds(0)                              # optional - Coin
     718            sage: p.col_bounds(0)                              # optional - Coin
    781719            (0.0, None)
    782             sage: p.set_variable_max(0, 5)                         # optional - Coin
    783             sage: p.get_col_bounds(0)                              # optional - Coin
     720            sage: p.variable_max(0, 5)                         # optional - Coin
     721            sage: p.col_bounds(0)                              # optional - Coin
    784722            (0.0, 5.0)
    785723        """
     724        cdef double * ub
    786725
    787         self.si.setColUpper(index, value if value is not None else +self.si.getInfinity())
     726        if value == False:
     727            ub = <double*> self.si.getColUpper()
     728            return ub[index] if ub[index] != + self.si.getInfinity() else None
     729        else:
     730            self.si.setColUpper(index, value if value is not None else +self.si.getInfinity())
    788731
    789     cpdef set_variable_min(self, int index, value):
     732    cpdef variable_min(self, int index, value = False):
    790733        r"""
    791         Sets the lower bound on a variable
     734        Returns or defines the lower bound on a variable
    792735
    793736        INPUT:
    794737
    795738        - ``index`` (integer) -- the variable's id
    796739
    797740        - ``value`` -- real value, or ``None`` to mean that the
    798           variable has not lower bound.
     741          variable has not lower bound. When set to ``False``
     742          (default), the method returns the current value.
    799743
    800744        EXAMPLE::
    801745
    802             sage: from sage.numerical.backends.generic_backend import getSolver
    803             sage: p = getSolver(solver = "Coin")  # optional - Coin
     746            sage: from sage.numerical.backends.generic_backend import get_solver
     747            sage: p = get_solver(solver = "Coin")  # optional - Coin
    804748            sage: p.add_variable()                                 # optional - Coin
    805749            1
    806             sage: p.get_col_bounds(0)                              # optional - Coin
     750            sage: p.col_bounds(0)                              # optional - Coin
    807751            (0.0, None)
    808             sage: p.set_variable_min(0, 5)                         # optional - Coin
    809             sage: p.get_col_bounds(0)                              # optional - Coin
     752            sage: p.variable_min(0, 5)                         # optional - Coin
     753            sage: p.col_bounds(0)                              # optional - Coin
    810754            (5.0, None)
    811755        """
     756        cdef double * lb
    812757
    813         self.si.setColLower(index, value if value is not None else -self.si.getInfinity())
     758        if value == False:
     759            lb = <double*> self.si.getColLower()
     760            return lb[index] if lb[index] != - self.si.getInfinity() else None
     761        else:
     762            self.si.setColLower(index, value if value is not None else -self.si.getInfinity())
    814763   
    815764    cpdef write_mps(self, char * filename, int modern):
    816765        r"""
     
    822771
    823772        EXAMPLE::
    824773
    825             sage: from sage.numerical.backends.generic_backend import getSolver
    826             sage: p = getSolver(solver = "Coin")  # optional - Coin
     774            sage: from sage.numerical.backends.generic_backend import get_solver
     775            sage: p = get_solver(solver = "Coin")  # optional - Coin
    827776            sage: p.add_variables(2)                               # optional - Coin
    828777            2
    829778            sage: p.add_constraint([0, 1], [1, 2], +1, 3)          # optional - Coin
     
    834783        cdef char * mps = "mps"
    835784        self.si.writeMps(filename, mps, -1 if self.is_maximization() else 1)
    836785
    837     cpdef set_problem_name(self, char * name):
     786    cpdef problem_name(self, char * name = NULL):
    838787        r"""
    839         Sets the problem's name
     788        Returns or defines the problem's name
    840789
    841790        INPUT:
    842791
    843         - ``name`` (``char *``) -- the problem's name
     792        - ``name`` (``char *``) -- the problem's name. When set to
     793          ``NULL`` (default), the method returns the problem's name.
    844794
    845795        EXAMPLE::
    846796
    847             sage: from sage.numerical.backends.generic_backend import getSolver
    848             sage: p = getSolver(solver = "Coin")   # optional - Coin
    849             sage: p.set_problem_name("There once was a french fry") # optional - Coin
    850             sage: print p.get_problem_name()                        # optional - Coin
     797            sage: from sage.numerical.backends.generic_backend import get_solver
     798            sage: p = get_solver(solver = "Coin")   # optional - Coin
     799            sage: p.problem_name("There once was a french fry") # optional - Coin
     800            sage: print p.problem_name()                        # optional - Coin
    851801            <BLANKLINE>
    852802        """
    853803
    854         pass
     804        if name == NULL:
     805            return ""
    855806
    856     cpdef get_problem_name(self):
     807
     808    cpdef row_name(self, int index, char * name = NULL):
    857809        r"""
    858         Returns the problem's name
    859 
    860         EXAMPLE::
    861 
    862             sage: from sage.numerical.backends.generic_backend import getSolver
    863             sage: p = getSolver(solver = "Coin")   # optional - Coin
    864             sage: p.set_problem_name("There once was a french fry") # optional - Coin
    865             sage: print p.get_problem_name()                        # optional - Coin
    866             <BLANKLINE>
    867         """
    868 
    869         return ""
    870 
    871     cpdef get_row_name(self, int index):
    872         r"""
    873         Returns the ``index`` th row name
     810        Returns or defines the ``index`` th row name
    874811
    875812        INPUT:
    876813
    877814        - ``index`` (integer) -- the row's id
    878815
    879         EXAMPLE::
    880 
    881             sage: from sage.numerical.backends.generic_backend import getSolver
    882             sage: p = getSolver(solver = "Coin")           # optional - Coin
    883             sage: p.add_variable()                         # optional - Coin
    884             1
    885             sage: p.set_row_name(0, "I am a constraint")   # optional - Coin
    886             sage: print p.get_row_name(0)                  # optional - Coin
    887             <BLANKLINE>
    888         """
    889 
    890         return ""
    891 
    892 
    893     cpdef set_row_name(self, int index, char * name):
    894         r"""
    895         Sets the ``index`` th row name
    896 
    897         INPUT:
    898 
    899         - ``index`` (integer) -- the row's id
    900 
    901         - ``name`` (``char *``) -- its name
     816        - ``name`` (``char *``) -- its name. When set to ``NULL``
     817          (default), the method returns the current name.
    902818
    903819        EXAMPLE::
    904820
    905             sage: from sage.numerical.backends.generic_backend import getSolver
    906             sage: p = getSolver(solver = "Coin")  # optional - Coin
     821            sage: from sage.numerical.backends.generic_backend import get_solver
     822            sage: p = get_solver(solver = "Coin")  # optional - Coin
    907823            sage: p.add_constraints(1, -1, 2)                      # optional - Coin
    908             sage: p.set_row_name(0, "Empty constraint 1")          # optional - Coin
    909             sage: print p.get_row_name(0)                          # optional - Coin
     824            sage: p.row_name(0, "Empty constraint 1")          # optional - Coin
     825            sage: print p.row_name(0)                          # optional - Coin
    910826            <BLANKLINE>
    911827        """
     828        if name == NULL:
     829            return ""
    912830
    913         pass
    914 
    915     cpdef set_objective_name(self, name):
    916         pass
    917 
    918     cpdef set_col_name(self, int index, char * name):
     831    cpdef col_name(self, int index, char * name = NULL):
    919832        r"""
    920         Sets the ``index`` th col name
     833        Returns or defines the ``index`` th col name
    921834
    922835        INPUT:
    923836
    924837        - ``index`` (integer) -- the col's id
    925838
    926         - ``name`` (``char *``) -- its name
     839        - ``name`` (``char *``) -- its name. When set to ``NULL``
     840          (default), the method returns the current name.
    927841
    928842        EXAMPLE::
    929843
    930             sage: from sage.numerical.backends.generic_backend import getSolver
    931             sage: p = getSolver(solver = "Coin")  # optional - Coin
     844            sage: from sage.numerical.backends.generic_backend import get_solver
     845            sage: p = get_solver(solver = "Coin")  # optional - Coin
    932846            sage: p.add_variable()                                 # optional - Coin
    933847            1
    934             sage: p.set_col_name(0, "I am a variable")             # optional - Coin
    935             sage: print p.get_col_name(0)                          # optional - Coin
    936             <BLANKLINE>
    937         """
    938         pass
    939 
    940     cpdef get_col_name(self, int index):
    941         r"""
    942         Returns the ``index`` th col name
    943 
    944         INPUT:
    945 
    946         - ``index`` (integer) -- the col's id
    947 
    948         EXAMPLE::
    949 
    950             sage: from sage.numerical.backends.generic_backend import getSolver
    951             sage: p = getSolver(solver = "Coin")  # optional - Coin
    952             sage: p.add_variable()                                 # optional - Coin
    953             1
    954             sage: p.set_col_name(0, "I am a variable")             # optional - Coin
    955             sage: print p.get_col_name(0)                          # optional - Coin
     848            sage: p.col_name(0, "I am a variable")             # optional - Coin
     849            sage: print p.col_name(0)                          # optional - Coin
    956850            <BLANKLINE>
    957851        """
    958852
    959         return ""
     853        if name == NULL:
     854            return ""
  • sage/numerical/backends/cplex_backend.pxd

    diff -r 0b5f2ba89540 -r f3c711eb0c73 sage/numerical/backends/cplex_backend.pxd
    a b  
    1515    cdef c_cpxlp * lp
    1616    cdef current_sol
    1717
    18 
    1918cdef extern from "../../local/include/cplex.h":
    2019
    2120     # Create problem
  • sage/numerical/backends/cplex_backend.pyx

    diff -r 0b5f2ba89540 -r f3c711eb0c73 sage/numerical/backends/cplex_backend.pyx
    a b  
    1717        check(status)
    1818
    1919        if maximization:
    20             self.set_direction(+1)
     20            self.set_sense(+1)
    2121        else:
    22             self.set_direction(-1)
     22            self.set_sense(-1)
    2323
    2424    cpdef int add_variable(self):
    2525        r"""
     
    3030
    3131        EXAMPLE::
    3232
    33             sage: from sage.numerical.backends.generic_backend import getSolver
    34             sage: p = getSolver(solver = "CPLEX")                    # optional - CPLEX
    35             sage: p.n_cols()                                         # optional - CPLEX
     33            sage: from sage.numerical.backends.generic_backend import get_solver
     34            sage: p = get_solver(solver = "CPLEX")                    # optional - CPLEX
     35            sage: p.ncols()                                         # optional - CPLEX
    3636            0
    3737            sage: p.add_variable()                                   # optional - CPLEX
    3838            1
    39             sage: p.n_cols()                                         # optional - CPLEX
     39            sage: p.ncols()                                         # optional - CPLEX
    4040            1
    4141        """
    4242
     
    5454
    5555        EXAMPLE::
    5656
    57             sage: from sage.numerical.backends.generic_backend import getSolver
    58             sage: p = getSolver(solver = "CPLEX")                    # optional - CPLEX
    59             sage: p.n_cols()                                         # optional - CPLEX
     57            sage: from sage.numerical.backends.generic_backend import get_solver
     58            sage: p = get_solver(solver = "CPLEX")                    # optional - CPLEX
     59            sage: p.ncols()                                         # optional - CPLEX
    6060            0
    6161            sage: p.add_variables(5)                                 # optional - CPLEX
    6262            5
    63             sage: p.n_cols()                                         # optional - CPLEX
     63            sage: p.ncols()                                         # optional - CPLEX
    6464            5
    6565        """
    6666
     
    8585
    8686        EXAMPLE::
    8787
    88             sage: from sage.numerical.backends.generic_backend import getSolver
    89             sage: p = getSolver(solver = "CPLEX")   # optional - CPLEX
    90             sage: p.n_cols()                                        # optional - CPLEX
     88            sage: from sage.numerical.backends.generic_backend import get_solver
     89            sage: p = get_solver(solver = "CPLEX")   # optional - CPLEX
     90            sage: p.ncols()                                        # optional - CPLEX
    9191            0
    9292            sage: p.add_variable()                                  # optional - CPLEX
    9393            1
     
    109109        status = CPXchgctype(self.env, self.lp, 1, &variable, &type)
    110110        check(status)
    111111     
    112     cpdef set_direction(self, int sense):
     112    cpdef set_sense(self, int sense):
    113113        r"""
    114114        Sets the direction (maximization/minimization).
    115115
     
    122122
    123123        EXAMPLE::
    124124
    125             sage: from sage.numerical.backends.generic_backend import getSolver
    126             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     125            sage: from sage.numerical.backends.generic_backend import get_solver
     126            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    127127            sage: p.is_maximization()                              # optional - CPLEX
    128128            True
    129             sage: p.set_direction(-1)                              # optional - CPLEX
     129            sage: p.set_sense(-1)                              # optional - CPLEX
    130130            sage: p.is_maximization()                              # optional - CPLEX
    131131            False
    132132        """
    133133
    134134        CPXchgobjsen(self.env, self.lp, -sense)
    135135
    136     cpdef set_objective_coeff(self, int variable, double coeff):
     136    cpdef set_objective_coefficient(self, int variable, double coeff):
    137137        r"""
    138138        Sets the coefficient of a variable in the objective function
    139139
     
    145145
    146146        EXAMPLE::
    147147
    148             sage: from sage.numerical.backends.generic_backend import getSolver
    149             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     148            sage: from sage.numerical.backends.generic_backend import get_solver
     149            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    150150            sage: p.add_variable()                                 # optional - CPLEX
    151151            1
    152152            sage: p.get_objective_coeff(0)                         # optional - CPLEX
    153153            0.0
    154             sage: p.set_objective_coeff(0,2)                       # optional - CPLEX
     154            sage: p.set_objective_coefficient(0,2)                       # optional - CPLEX
    155155            sage: p.get_objective_coeff(0)                         # optional - CPLEX
    156156            2.0
    157157        """
     
    160160        status = CPXchgobj(self.env, self.lp, 1, &variable, &coeff)
    161161        check(status)
    162162
    163     cpdef set_problem_name(self, char * name):
     163    cpdef problem_name(self, char * name = NULL):
    164164        r"""
    165         Sets the problem's name
     165        Returns or defines the problem's name
    166166
    167167        INPUT:
    168168
    169         - ``name`` (``char *``) -- the problem's name
     169        - ``name`` (``char *``) -- the problem's name. When set to
     170          ``NULL`` (default), the method returns the problem's name.
    170171
    171172        EXAMPLE::
    172173
    173             sage: from sage.numerical.backends.generic_backend import getSolver
    174             sage: p = getSolver(solver = "CPLEX")   # optional - CPLEX
    175             sage: p.set_problem_name("There once was a french fry") # optional - CPLEX
    176             sage: print p.get_problem_name()                        # optional - CPLEX
    177             There once was a french fry
    178         """
    179 
    180         cdef int status
    181         status = CPXchgprobname(self.env, self.lp, name)
    182         check(status)
    183 
    184 
    185     cpdef get_problem_name(self):
    186         r"""
    187         Returns the problem's name
    188 
    189         EXAMPLE::
    190 
    191             sage: from sage.numerical.backends.generic_backend import getSolver
    192             sage: p = getSolver(solver = "CPLEX")   # optional - CPLEX
    193             sage: p.set_problem_name("There once was a french fry") # optional - CPLEX
    194             sage: print p.get_problem_name()                        # optional - CPLEX
     174            sage: from sage.numerical.backends.generic_backend import get_solver
     175            sage: p = get_solver(solver = "CPLEX")   # optional - CPLEX
     176            sage: p.problem_name("There once was a french fry") # optional - CPLEX
     177            sage: print p.problem_name()                        # optional - CPLEX
    195178            There once was a french fry
    196179        """
    197180
    198181        cdef int status
    199182        cdef int zero
    200         cdef char * name = <char*> sage_malloc(500*sizeof(char))
    201         status = CPXgetprobname(self.env, self.lp, name, 500, &zero)
    202         check(status)
     183        cdef char * n
     184        if name == NULL:
    203185
    204         s = str(name)
    205         sage_free(name)
     186            n = <char*> sage_malloc(500*sizeof(char))
     187            status = CPXgetprobname(self.env, self.lp, n, 500, &zero)
     188            check(status)
     189            s = str(n)
     190            sage_free(n)
     191            return s
    206192
    207         return s
     193
     194        else:
     195            status = CPXchgprobname(self.env, self.lp, name)
     196            check(status)
     197
    208198
    209199    cpdef set_objective(self, list coeff):
    210200        r"""
     
    217207
    218208        EXAMPLE::
    219209
    220             sage: from sage.numerical.backends.generic_backend import getSolver
    221             sage: p = getSolver(solver = "CPLEX")    # optional - CPLEX
     210            sage: from sage.numerical.backends.generic_backend import get_solver
     211            sage: p = get_solver(solver = "CPLEX")    # optional - CPLEX
    222212            sage: p.add_variables(5)                                 # optional - CPLEX
    223213            5
    224214            sage: p.set_objective([1, 1, 2, 1, 3])                   # optional - CPLEX
     
    227217        """
    228218
    229219        cdef int status
    230         cdef int n = self.n_cols()
     220        cdef int n = self.ncols()
    231221        cdef double * c_coeff = <double *> sage_malloc(n * sizeof(double))
    232222        cdef int * c_indices = <int *> sage_malloc(n * sizeof(int))
    233223       
     
    239229        check(status)
    240230
    241231
    242     cpdef set_log_level(self, int level):
     232    cpdef set_verbosity(self, int level):
    243233        r"""
    244234        Sets the log (verbosity) level
    245235
     
    249239
    250240        EXAMPLE::
    251241
    252             sage: from sage.numerical.backends.generic_backend import getSolver
    253             sage: p = getSolver(solver = "CPLEX")   # optional - CPLEX
    254             sage: p.set_log_level(2)                                # optional - CPLEX
     242            sage: from sage.numerical.backends.generic_backend import get_solver
     243            sage: p = get_solver(solver = "CPLEX")   # optional - CPLEX
     244            sage: p.set_verbosity(2)                                # optional - CPLEX
    255245
    256246        """
    257247
     
    283273
    284274        EXAMPLE::
    285275
    286             sage: from sage.numerical.backends.generic_backend import getSolver
    287             sage: p = getSolver(solver = "CPLEX")   # optional - CPLEX
     276            sage: from sage.numerical.backends.generic_backend import get_solver
     277            sage: p = get_solver(solver = "CPLEX")   # optional - CPLEX
    288278            sage: p.add_variables(5)                                # optional - CPLEX
    289279            5
    290280            sage: p.add_constraints(5, +1, 2)                       # optional - CPLEX
    291             sage: p.get_row(4)                                      # optional - CPLEX
     281            sage: p.row(4)                                      # optional - CPLEX
    292282            ([], [])
    293             sage: p.get_row_bounds(4)                               # optional - CPLEX
     283            sage: p.row_bounds(4)                               # optional - CPLEX
    294284            (None, 2.0)
    295285        """
    296286
     
    348338
    349339        EXAMPLE::
    350340
    351             sage: from sage.numerical.backends.generic_backend import getSolver
    352             sage: p = getSolver(solver = "CPLEX") # optional - CPLEX
     341            sage: from sage.numerical.backends.generic_backend import get_solver
     342            sage: p = get_solver(solver = "CPLEX") # optional - CPLEX
    353343            sage: p.add_variables(5)                              # optional - CPLEX
    354344            5
    355345            sage: p.add_constraint(range(5), range(5), 0, 2)      # optional - CPLEX
    356             sage: p.get_row(0)                                    # optional - CPLEX
     346            sage: p.row(0)                                    # optional - CPLEX
    357347            ([1, 2, 3, 4], [1.0, 2.0, 3.0, 4.0])
    358             sage: p.get_row_bounds(0)                             # optional - CPLEX
     348            sage: p.row_bounds(0)                             # optional - CPLEX
    359349            (2.0, 2.0)
    360350        """
    361351
    362352        cdef int status
    363353        cdef int i
    364354        cdef int n = len(indices)
    365         cdef int n_rows = self.n_rows()
     355        cdef int nrows = self.nrows()
    366356        cdef char sense
    367357
    368358        if direction == 1:
     
    382372        for 0<= i < n:
    383373            c_coeff[i] = coeffs[i]
    384374            c_indices[i] = indices[i]
    385             c_row[i] = n_rows
     375            c_row[i] = nrows
    386376
    387377
    388378        status = CPXchgcoeflist(self.env, self.lp, n, c_row, c_indices, c_coeff)
    389379        check(status)
    390380
    391     cpdef get_row(self, int index):
     381    cpdef row(self, int index):
    392382        r"""
    393383        Returns a row
    394384
     
    405395
    406396        EXAMPLE::
    407397
    408             sage: from sage.numerical.backends.generic_backend import getSolver
    409             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     398            sage: from sage.numerical.backends.generic_backend import get_solver
     399            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    410400            sage: p.add_variables(5)                               # optional - CPLEX
    411401            5
    412402            sage: p.add_constraint(range(5), range(5), 0, 2)       # optional - CPLEX
    413             sage: p.get_row(0)                                     # optional - CPLEX
     403            sage: p.row(0)                                     # optional - CPLEX
    414404            ([1, 2, 3, 4], [1.0, 2.0, 3.0, 4.0])
    415             sage: p.get_row_bounds(0)                              # optional - CPLEX
     405            sage: p.row_bounds(0)                              # optional - CPLEX
    416406            (2.0, 2.0)
    417407        """
    418408
     
    422412        cdef list indices = []
    423413        cdef list values = []
    424414
    425         cdef double * c_coeff = <double *> sage_malloc((self.n_cols()+10) * sizeof(double))
    426         cdef int * c_indices = <int *> sage_malloc((self.n_cols()+10) * sizeof(int))
     415        cdef double * c_coeff = <double *> sage_malloc((self.ncols()+10) * sizeof(double))
     416        cdef int * c_indices = <int *> sage_malloc((self.ncols()+10) * sizeof(int))
    427417
    428         status = CPXgetrows(self.env, self.lp, &n, &zero, c_indices, c_coeff, self.n_cols()+3, &zero, index, index)
     418        status = CPXgetrows(self.env, self.lp, &n, &zero, c_indices, c_coeff, self.ncols()+3, &zero, index, index)
    429419
    430420        check(status)
    431421
     
    438428
    439429        return (indices, values)
    440430
    441     cpdef get_row_bounds(self, int index):
     431    cpdef row_bounds(self, int index):
    442432        r"""
    443433        Returns the bounds of a specific constraint.
    444434
     
    454444
    455445        EXAMPLE::
    456446
    457             sage: from sage.numerical.backends.generic_backend import getSolver
    458             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     447            sage: from sage.numerical.backends.generic_backend import get_solver
     448            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    459449            sage: p.add_variables(5)                               # optional - CPLEX
    460450            5
    461451            sage: p.add_constraint(range(5), range(5), 0, 2)       # optional - CPLEX
    462             sage: p.get_row(0)                                     # optional - CPLEX
     452            sage: p.row(0)                                     # optional - CPLEX
    463453            ([1, 2, 3, 4], [1.0, 2.0, 3.0, 4.0])
    464             sage: p.get_row_bounds(0)                              # optional - CPLEX
     454            sage: p.row_bounds(0)                              # optional - CPLEX
    465455            (2.0, 2.0)
    466456        """
    467457
     
    481471        else:
    482472            return (value, value)
    483473
    484     cpdef get_col_bounds(self, int index):
     474    cpdef col_bounds(self, int index):
    485475        r"""
    486476        Returns the bounds of a specific variable.
    487477
     
    497487
    498488        EXAMPLE::
    499489
    500             sage: from sage.numerical.backends.generic_backend import getSolver
    501             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     490            sage: from sage.numerical.backends.generic_backend import get_solver
     491            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    502492            sage: p.add_variable()                                 # optional - CPLEX
    503493            1
    504             sage: p.get_col_bounds(0)                              # optional - CPLEX
     494            sage: p.col_bounds(0)                              # optional - CPLEX
    505495            (0.0, None)
    506             sage: p.set_variable_max(0, 5)                         # optional - CPLEX
    507             sage: p.get_col_bounds(0)                              # optional - CPLEX
     496            sage: p.variable_max(0, 5)                         # optional - CPLEX
     497            sage: p.col_bounds(0)                              # optional - CPLEX
    508498            (0.0, 5.0)
    509499        """
    510500
     
    533523
    534524        EXAMPLE::
    535525
    536             sage: from sage.numerical.backends.generic_backend import getSolver
    537             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     526            sage: from sage.numerical.backends.generic_backend import get_solver
     527            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    538528            sage: p.add_variable()                                 # optional - CPLEX
    539529            1
    540530            sage: p.get_objective_coeff(0)                         # optional - CPLEX
    541531            0.0
    542             sage: p.set_objective_coeff(0,2)                       # optional - CPLEX
     532            sage: p.set_objective_coefficient(0,2)                       # optional - CPLEX
    543533            sage: p.get_objective_coeff(0)                         # optional - CPLEX
    544534            2.0
    545535        """
     
    574564
    575565        EXAMPLE::
    576566
    577             sage: from sage.numerical.backends.generic_backend import getSolver
    578             sage: p = getSolver(solver = "CPLEX")                  # optional - CPLEX
    579             sage: p.n_cols()                                       # optional - CPLEX
     567            sage: from sage.numerical.backends.generic_backend import get_solver
     568            sage: p = get_solver(solver = "CPLEX")                  # optional - CPLEX
     569            sage: p.ncols()                                       # optional - CPLEX
    580570            0
    581             sage: p.n_rows()                                       # optional - CPLEX
     571            sage: p.nrows()                                       # optional - CPLEX
    582572            0
    583573            sage: p.add_constraints(5, -1, 0)                      # optional - CPLEX
    584574            sage: p.add_col(range(5), range(5))                    # optional - CPLEX
    585             sage: p.n_rows()                                       # optional - CPLEX
     575            sage: p.nrows()                                       # optional - CPLEX
    586576            5
    587577        """
    588578
    589579        cdef int status
    590580        cdef int i
    591581        cdef int n = len(indices)
    592         cdef int n_cols = self.n_cols()
     582        cdef int ncols = self.ncols()
    593583
    594584        status = CPXnewcols(self.env, self.lp, 1, NULL, NULL, NULL, NULL, NULL)
    595585
     
    603593        for 0<= i < n:
    604594            c_coeff[i] = coeffs[i]
    605595            c_indices[i] = indices[i]
    606             c_col[i] = n_cols
     596            c_col[i] = ncols
    607597
    608598
    609599        status = CPXchgcoeflist(self.env, self.lp, n, c_indices, c_col, c_coeff)
     
    621611
    622612        EXAMPLE::
    623613
    624             sage: from sage.numerical.backends.generic_backend import getSolver
    625             sage: p = getSolver(solver = "CPLEX") # optional - CPLEX
     614            sage: from sage.numerical.backends.generic_backend import get_solver
     615            sage: p = get_solver(solver = "CPLEX") # optional - CPLEX
    626616            sage: p.add_constraints(5, -1, 0)                     # optional - CPLEX
    627617            sage: p.add_col(range(5), range(5))                   # optional - CPLEX
    628618            sage: p.solve()                                       # optional - CPLEX
    629619            0
    630             sage: p.set_objective_coeff(0,1)                      # optional - CPLEX
     620            sage: p.set_objective_coefficient(0,1)                      # optional - CPLEX
    631621            sage: p.solve()                                       # optional - CPLEX
    632622            Traceback (most recent call last):
    633623            ...
     
    671661
    672662        EXAMPLE::
    673663
    674             sage: from sage.numerical.backends.generic_backend import getSolver
    675             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     664            sage: from sage.numerical.backends.generic_backend import get_solver
     665            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    676666            sage: p.add_variables(2)                               # optional - CPLEX
    677667            2
    678668            sage: p.add_constraint([0, 1], [1, 2], +1, 3)          # optional - CPLEX
     
    705695
    706696        EXAMPLE::
    707697
    708             sage: from sage.numerical.backends.generic_backend import getSolver
    709             sage: p = getSolver(solver = "CPLEX") # optional - CPLEX
     698            sage: from sage.numerical.backends.generic_backend import get_solver
     699            sage: p = get_solver(solver = "CPLEX") # optional - CPLEX
    710700            sage: p.add_variables(2)                              # optional - CPLEX
    711701            2
    712702            sage: p.add_constraint([0, 1], [1, 2], +1, 3)         # optional - CPLEX
     
    730720        return value
    731721
    732722
    733     cpdef int n_cols(self):
     723    cpdef int ncols(self):
    734724        r"""
    735725        Returns the number of columns/variables.
    736726
    737727        EXAMPLE::
    738728
    739             sage: from sage.numerical.backends.generic_backend import getSolver
    740             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
    741             sage: p.n_cols()                                       # optional - CPLEX
     729            sage: from sage.numerical.backends.generic_backend import get_solver
     730            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
     731            sage: p.ncols()                                       # optional - CPLEX
    742732            0
    743733            sage: p.add_variables(2)                               # optional - CPLEX
    744734            2
    745             sage: p.n_cols()                                       # optional - CPLEX
     735            sage: p.ncols()                                       # optional - CPLEX
    746736            2
    747737        """
    748738
    749739        return CPXgetnumcols(self.env, self.lp)
    750740
    751     cpdef int n_rows(self):
     741    cpdef int nrows(self):
    752742        r"""
    753743        Returns the number of rows/constraints.
    754744
    755745        EXAMPLE::
    756746
    757             sage: from sage.numerical.backends.generic_backend import getSolver
    758             sage: p = getSolver(solver = "CPLEX") # optional - CPLEX
    759             sage: p.n_rows()                                      # optional - CPLEX
     747            sage: from sage.numerical.backends.generic_backend import get_solver
     748            sage: p = get_solver(solver = "CPLEX") # optional - CPLEX
     749            sage: p.nrows()                                      # optional - CPLEX
    760750            0
    761751            sage: p.add_constraints(2, -1, 2)                     # optional - CPLEX
    762             sage: p.n_rows()                                      # optional - CPLEX
     752            sage: p.nrows()                                      # optional - CPLEX
    763753            2
    764754        """
    765755
    766756        return CPXgetnumrows(self.env, self.lp)
    767757
    768     cpdef get_row_name(self, int index):
     758    cpdef row_name(self, int index, char * name = NULL):
    769759        r"""
    770         Returns the ``index`` th row name
     760        Returns or defines the ``index`` th row name
    771761
    772762        INPUT:
    773763
    774764        - ``index`` (integer) -- the row's id
    775765
    776         EXAMPLE::
    777 
    778             sage: from sage.numerical.backends.generic_backend import getSolver
    779             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
    780             sage: p.add_variable()                                 # optional - CPLEX
    781             1
    782             sage: p.set_col_name(0, "I am a variable")             # optional - CPLEX
    783             sage: p.get_col_name(0)                                # optional - CPLEX
    784             'I am a variable'
    785         """
    786 
    787         cdef int status
    788         cdef int zero
    789         cdef char * name = <char *>sage_malloc(500*sizeof(char))
    790         status = CPXgetrowname(self.env, self.lp, &name, name, 500, &zero, index, index)
    791         if status == 1219:
    792             sage_free(name)
    793             return ""
    794         check(status)
    795 
    796         s = str(name)
    797         sage_free(name)
    798 
    799         return s
    800 
    801     cpdef set_row_name(self, int index, char * name):
    802         r"""
    803         Sets the ``index`` th row name
    804 
    805         INPUT:
    806 
    807         - ``index`` (integer) -- the row's id
    808 
    809         - ``name`` (``char *``) -- its name
     766        - ``name`` (``char *``) -- its name. When set to ``NULL``
     767          (default), the method returns the current name.
    810768
    811769        EXAMPLE::
    812770
    813             sage: from sage.numerical.backends.generic_backend import getSolver
    814             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     771            sage: from sage.numerical.backends.generic_backend import get_solver
     772            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    815773            sage: p.add_constraints(1, -1, 2)                      # optional - CPLEX
    816             sage: p.set_row_name(0, "Empty constraint 1")          # optional - CPLEX
    817             sage: p.get_row_name(0)                                # optional - CPLEX
     774            sage: p.row_name(0, "Empty constraint 1")          # optional - CPLEX
     775            sage: p.row_name(0)                                # optional - CPLEX
    818776            'Empty constraint 1'
    819777
    820778        """
    821779
    822780        cdef int status
     781        cdef int zero
     782        cdef char * n
    823783
    824         status = CPXchgrowname(self.env, self.lp, 1, &index, &name)
    825         check(status)
     784        if name == NULL:
     785            n = <char *>sage_malloc(500*sizeof(char))
     786            status = CPXgetrowname(self.env, self.lp, &n, n, 500, &zero, index, index)
     787            if status == 1219:
     788                sage_free(n)
     789                return ""
     790            check(status)
    826791
    827     cpdef set_col_name(self, int index, char * name):
     792            s = str(n)
     793            sage_free(n)
     794
     795            return s
     796
     797            pass
     798        else:
     799            status = CPXchgrowname(self.env, self.lp, 1, &index, &name)
     800            check(status)
     801
     802    cpdef col_name(self, int index, char * name = NULL):
    828803        r"""
    829         Sets the ``index`` th col name
     804        Returns or defines the ``index`` th col name.
    830805
    831806        INPUT:
    832807
    833808        - ``index`` (integer) -- the col's id
    834809
    835         - ``name`` (``char *``) -- its name
     810        - ``name`` (``char *``) -- its name. When set to ``NULL``
     811          (default), the method returns the current name.
    836812
    837813        EXAMPLE::
    838814
    839             sage: from sage.numerical.backends.generic_backend import getSolver
    840             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     815            sage: from sage.numerical.backends.generic_backend import get_solver
     816            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    841817            sage: p.add_variable()                                 # optional - CPLEX
    842818            1
    843             sage: p.set_col_name(0, "I am a variable")             # optional - CPLEX
    844             sage: p.get_col_name(0)                                # optional - CPLEX
     819            sage: p.col_name(0, "I am a variable")             # optional - CPLEX
     820            sage: p.col_name(0)                                # optional - CPLEX
    845821            'I am a variable'
    846822        """
    847823
    848824        cdef int status
    849         status = CPXchgcolname(self.env, self.lp, 1, &index, &name)
    850         check(status)
     825        cdef char * n
     826        cdef int zero
    851827
     828        if name == NULL:
    852829
    853     cpdef get_col_name(self, int index):
    854         r"""
    855         Returns the ``index`` th variable name
     830            n = <char *>sage_malloc(500*sizeof(char))
     831            status = CPXgetcolname(self.env, self.lp, &n, n, 500, &zero, index, index)
     832            if status == 1219:
     833                sage_free(n)
     834                return ""
     835            check(status)
    856836
    857         INPUT:
     837            s = str(n)
     838            sage_free(n)
     839            return s
    858840
    859         - ``index`` (integer) -- the variable's id
     841        else:
     842            status = CPXchgcolname(self.env, self.lp, 1, &index, &name)
     843            check(status)
    860844
    861         EXAMPLE::
    862 
    863             sage: from sage.numerical.backends.generic_backend import getSolver
    864             sage: p = getSolver(solver = "CPLEX")                  # optional - CPLEX
    865             sage: p.add_variable()                                 # optional - CPLEX
    866             1
    867             sage: p.set_col_name(0, "I am a variable")             # optional - CPLEX
    868             sage: p.get_col_name(0)                                # optional - CPLEX
    869             'I am a variable'
    870         """
    871 
    872         cdef int status
    873         cdef int zero
    874         cdef char * name = <char *>sage_malloc(500*sizeof(char))
    875         status = CPXgetcolname(self.env, self.lp, &name, name, 500, &zero, index, index)
    876         if status == 1219:
    877             sage_free(name)
    878             return ""
    879         check(status)
    880 
    881         s = str(name)
    882         sage_free(name)
    883 
    884 
    885         return s
    886845
    887846
    888847    cpdef bint is_variable_binary(self, int index):
     
    895854
    896855        EXAMPLE::
    897856
    898             sage: from sage.numerical.backends.generic_backend import getSolver
    899             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
    900             sage: p.n_cols()                                       # optional - CPLEX
     857            sage: from sage.numerical.backends.generic_backend import get_solver
     858            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
     859            sage: p.ncols()                                       # optional - CPLEX
    901860            0
    902861            sage: p.add_variable()                                 # optional - CPLEX
    903862            1
     
    931890
    932891        EXAMPLE::
    933892
    934             sage: from sage.numerical.backends.generic_backend import getSolver
    935             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
    936             sage: p.n_cols()                                       # optional - CPLEX
     893            sage: from sage.numerical.backends.generic_backend import get_solver
     894            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
     895            sage: p.ncols()                                       # optional - CPLEX
    937896            0
    938897            sage: p.add_variable()                                 # optional - CPLEX
    939898            1
     
    966925
    967926        EXAMPLE::
    968927
    969             sage: from sage.numerical.backends.generic_backend import getSolver
    970             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
    971             sage: p.n_cols()                                       # optional - CPLEX
     928            sage: from sage.numerical.backends.generic_backend import get_solver
     929            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
     930            sage: p.ncols()                                       # optional - CPLEX
    972931            0
    973932            sage: p.add_variable()                                 # optional - CPLEX
    974933            1
     
    1000959
    1001960        EXAMPLE::
    1002961
    1003             sage: from sage.numerical.backends.generic_backend import getSolver
    1004             sage: p = getSolver(solver = "CPLEX") # optional - CPLEX
     962            sage: from sage.numerical.backends.generic_backend import get_solver
     963            sage: p = get_solver(solver = "CPLEX") # optional - CPLEX
    1005964            sage: p.is_maximization()                             # optional - CPLEX
    1006965            True
    1007             sage: p.set_direction(-1)                             # optional - CPLEX
     966            sage: p.set_sense(-1)                             # optional - CPLEX
    1008967            sage: p.is_maximization()                             # optional - CPLEX
    1009968            False
    1010969        """
    1011970
    1012971        return -1 == CPXgetobjsen(self.env, self.lp)
    1013972
    1014     cpdef get_variable_max(self, int index):
     973    cpdef variable_max(self, int index, value = False):
    1015974        r"""
    1016         Returns the upper bound on a variable
    1017 
    1018         INPUT:
    1019 
    1020         - ``index`` (integer) -- the variable's id
    1021 
    1022         OUTPUT:
    1023 
    1024         A real value if the variable has an upper bound, ``None``
    1025         otherwise.
    1026 
    1027         EXAMPLE::
    1028 
    1029             sage: from sage.numerical.backends.generic_backend import getSolver
    1030             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
    1031             sage: p.add_variable()                                 # optional - CPLEX
    1032             1
    1033             sage: p.get_variable_max(0) is None                    # optional - CPLEX
    1034             True
    1035             sage: p.set_variable_max(0, 5)                         # optional - CPLEX
    1036             sage: p.get_variable_max(0)                            # optional - CPLEX
    1037             5.0
    1038 
    1039         """
    1040 
    1041         cdef int status
    1042         cdef double ub
    1043 
    1044         status = CPXgetub(self.env, self.lp, &ub, index, index)
    1045         check(status)
    1046 
    1047         return ub if ub != CPX_INFBOUND else None
    1048 
    1049     cpdef get_variable_min(self, int index):
    1050         r"""
    1051         Returns the lower bound on a variable
    1052 
    1053         INPUT:
    1054 
    1055         - ``index`` (integer) -- the variable's id
    1056 
    1057         OUTPUT:
    1058 
    1059         A real value if the variable has an lower bound, ``None``
    1060         otherwise.
    1061 
    1062         EXAMPLE::
    1063 
    1064             sage: from sage.numerical.backends.generic_backend import getSolver
    1065             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
    1066             sage: p.add_variable()                                 # optional - CPLEX
    1067             1
    1068             sage: p.get_variable_min(0)                            # optional - CPLEX
    1069             0.0
    1070             sage: p.set_variable_min(0, 5)                         # optional - CPLEX
    1071             sage: p.get_variable_min(0)                            # optional - CPLEX
    1072             5.0
    1073         """
    1074 
    1075         cdef int status
    1076         cdef double lb
    1077 
    1078         status = CPXgetlb(self.env, self.lp, &lb, index, index)
    1079         check(status)
    1080 
    1081         return lb if lb != -CPX_INFBOUND else None
    1082 
    1083     cpdef set_variable_max(self, int index, value):
    1084         r"""
    1085         Sets the upper bound on a variable
     975        Returns or defines the upper bound on a variable
    1086976
    1087977        INPUT:
    1088978
    1089979        - ``index`` (integer) -- the variable's id
    1090980
    1091981        - ``value`` -- real value, or ``None`` to mean that the
    1092           variable has not upper bound.
     982          variable has not upper bound. When set to ``False``
     983          (default), the method returns the current value.
    1093984
    1094985        EXAMPLE::
    1095986
    1096             sage: from sage.numerical.backends.generic_backend import getSolver
    1097             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     987            sage: from sage.numerical.backends.generic_backend import get_solver
     988            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    1098989            sage: p.add_variable()                                 # optional - CPLEX
    1099990            1
    1100             sage: p.get_col_bounds(0)                              # optional - CPLEX
     991            sage: p.col_bounds(0)                              # optional - CPLEX
    1101992            (0.0, None)
    1102             sage: p.set_variable_max(0, 5)                         # optional - CPLEX
    1103             sage: p.get_col_bounds(0)                              # optional - CPLEX
     993            sage: p.variable_max(0, 5)                         # optional - CPLEX
     994            sage: p.col_bounds(0)                              # optional - CPLEX
    1104995            (0.0, 5.0)
    1105996        """
     997        cdef int status
     998        cdef double ub
     999        cdef char x
     1000        cdef double c_value
    11061001
    1107         cdef int status
    1108         cdef char x = 'U'
    1109         cdef double c_value = value if value is not None else +CPX_INFBOUND
    1110         status = CPXchgbds(self.env, self.lp, 1, &index, &x, &c_value)
    1111         check(status)
     1002        if value == False:
    11121003
    1113     cpdef set_variable_min(self, int index, value):
     1004            status = CPXgetub(self.env, self.lp, &ub, index, index)
     1005            check(status)
     1006
     1007            return ub if ub != CPX_INFBOUND else None
     1008
     1009        else:
     1010
     1011            x = 'U'
     1012            c_value = value if value is not None else +CPX_INFBOUND
     1013            status = CPXchgbds(self.env, self.lp, 1, &index, &x, &c_value)
     1014            check(status)
     1015
     1016    cpdef variable_min(self, int index, value = False):
    11141017        r"""
    1115         Sets the lower bound on a variable
     1018        Returns or defines the lower bound on a variable
    11161019
    11171020        INPUT:
    11181021
    11191022        - ``index`` (integer) -- the variable's id
    11201023
    11211024        - ``value`` -- real value, or ``None`` to mean that the
    1122           variable has not lower bound.
     1025          variable has not lower bound. When set to ``False``
     1026          (default), the method returns the current value.
    11231027
    11241028        EXAMPLE::
    11251029
    1126             sage: from sage.numerical.backends.generic_backend import getSolver
    1127             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     1030            sage: from sage.numerical.backends.generic_backend import get_solver
     1031            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    11281032            sage: p.add_variable()                                 # optional - CPLEX
    11291033            1
    1130             sage: p.get_col_bounds(0)                              # optional - CPLEX
     1034            sage: p.col_bounds(0)                              # optional - CPLEX
    11311035            (0.0, None)
    1132             sage: p.set_variable_min(0, 5)                         # optional - CPLEX
    1133             sage: p.get_col_bounds(0)                              # optional - CPLEX
     1036            sage: p.variable_min(0, 5)                         # optional - CPLEX
     1037            sage: p.col_bounds(0)                              # optional - CPLEX
    11341038            (5.0, None)
    11351039        """
     1040        cdef int status
     1041        cdef double lb
     1042        cdef char x
     1043        cdef double c_value
    11361044
    1137         cdef int status
    1138         cdef char x = 'L'
    1139         cdef double c_value = value if value is not None else -CPX_INFBOUND
    1140         status = CPXchgbds(self.env, self.lp, 1, &index, &x, &c_value)
    1141         check(status)
     1045        if value == False:
     1046            status = CPXgetlb(self.env, self.lp, &lb, index, index)
     1047            check(status)
     1048            return lb if lb != -CPX_INFBOUND else None
     1049
     1050        else:
     1051            x = 'L'
     1052            c_value = value if value is not None else -CPX_INFBOUND
     1053            status = CPXchgbds(self.env, self.lp, 1, &index, &x, &c_value)
     1054            check(status)
    11421055   
    11431056    cpdef write_lp(self, char * filename):
    11441057        r"""
     
    11501063
    11511064        EXAMPLE::
    11521065
    1153             sage: from sage.numerical.backends.generic_backend import getSolver
    1154             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     1066            sage: from sage.numerical.backends.generic_backend import get_solver
     1067            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    11551068            sage: p.add_variables(2)                               # optional - CPLEX
    11561069            2
    11571070            sage: p.add_constraint([0, 1], [1, 2], +1, 3)          # optional - CPLEX
     
    11741087
    11751088        EXAMPLE::
    11761089
    1177             sage: from sage.numerical.backends.generic_backend import getSolver
    1178             sage: p = getSolver(solver = "CPLEX")  # optional - CPLEX
     1090            sage: from sage.numerical.backends.generic_backend import get_solver
     1091            sage: p = get_solver(solver = "CPLEX")  # optional - CPLEX
    11791092            sage: p.add_variables(2)                               # optional - CPLEX
    11801093            2
    11811094            sage: p.add_constraint([0, 1], [1, 2], +1, 3)          # optional - CPLEX
  • sage/numerical/backends/generic_backend.pxd

    diff -r 0b5f2ba89540 -r f3c711eb0c73 sage/numerical/backends/generic_backend.pxd
    a b  
    11cdef class GenericBackend:
    22    cpdef int add_variable(self)
    33    cpdef int add_variables(self, int)
    4     cpdef  set_variable_type(self, int variable, int vtype)
    5     cpdef  set_direction(self, int sense)
    6     cpdef  set_objective_coeff(self, int variable, double coeff)
    7     cpdef  set_objective(self, list coeff)
    8     cpdef set_log_level(self, int level)
     4    cpdef set_variable_type(self, int variable, int vtype)
     5    cpdef set_sense(self, int sense)
     6    cpdef set_objective_coefficient(self, int variable, double coeff)
     7    cpdef set_objective(self, list coeff)
     8    cpdef set_verbosity(self, int level)
    99    cpdef add_constraint(self, list indices, list coeffs, int direction, double bound)
    1010    cpdef add_col(self, list indices, list coeffs)
    1111    cpdef add_constraints(self, int number, int direction, double bound)
    1212    cpdef int solve(self) except -1
    1313    cpdef double get_objective_value(self)
    1414    cpdef double get_variable_value(self, int variable)
    15     cpdef int n_rows(self)
    16     cpdef int n_cols(self)
    1715    cpdef name(self)
    1816    cpdef bint is_maximization(self)
    19     cpdef  set_problem_name(self, char * name)
    20     cpdef get_problem_name(self)
    21     cpdef  set_objective_name(self, name)
    22     cpdef  write_lp(self, char * name)
    23     cpdef  write_mps(self, char * name, int modern)
    24     cpdef get_row(self, int i)
     17    cpdef write_lp(self, char * name)
     18    cpdef write_mps(self, char * name, int modern)
     19    cpdef row(self, int i)
    2520    cpdef double get_objective_coeff(self, int i)
    26     cpdef int n_cols(self)
    27     cpdef int n_rows(self)
    28     cpdef get_row_name(self, int)
     21    cpdef int ncols(self)
     22    cpdef int nrows(self)
    2923    cpdef bint is_variable_binary(self, int)
    3024    cpdef bint is_variable_integer(self, int)
    3125    cpdef bint is_variable_continuous(self, int)
    32     cpdef get_row_bounds(self, int index)
    33     cpdef get_col_bounds(self, int index)
    34     cpdef  set_row_name(self, int index, char * name)
    35     cpdef  set_col_name(self, int index, char * name)
    36     cpdef get_col_name(self, int index)
    3726
    38     cpdef get_variable_max(self, int index)
    39     cpdef get_variable_min(self, int index)
    40     cpdef  set_variable_max(self, int index, value)
    41     cpdef  set_variable_min(self, int index, value)
     27    cpdef problem_name(self, char * name = *)
     28    cpdef row_bounds(self, int index)
     29    cpdef col_bounds(self, int index)
     30    cpdef row_name(self, int index, char * name = *)
     31    cpdef col_name(self, int index, char * name = *)
     32    cpdef variable_max(self, int index, value = *)
     33    cpdef variable_min(self, int index, value = *)
    4234
  • sage/numerical/backends/generic_backend.pyx

    diff -r 0b5f2ba89540 -r f3c711eb0c73 sage/numerical/backends/generic_backend.pyx
    a b  
    2323
    2424        EXAMPLE::
    2525
    26             sage: from sage.numerical.backends.generic_backend import getSolver
    27             sage: p = getSolver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
    28             sage: p.n_cols()                                         # optional - Nonexistent_LP_solver
     26            sage: from sage.numerical.backends.generic_backend import get_solver
     27            sage: p = get_solver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
     28            sage: p.ncols()                                         # optional - Nonexistent_LP_solver
    2929            0
    3030            sage: p.add_variable()                                   # optional - Nonexistent_LP_solver
    3131            1
    32             sage: p.n_cols()                                         # optional - Nonexistent_LP_solver
     32            sage: p.ncols()                                         # optional - Nonexistent_LP_solver
    3333            1
    3434        """
    3535        raise NotImplementedError()
     
    4343
    4444        EXAMPLE::
    4545
    46             sage: from sage.numerical.backends.generic_backend import getSolver
    47             sage: p = getSolver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
    48             sage: p.n_cols()                                         # optional - Nonexistent_LP_solver
     46            sage: from sage.numerical.backends.generic_backend import get_solver
     47            sage: p = get_solver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
     48            sage: p.ncols()                                         # optional - Nonexistent_LP_solver
    4949            0
    5050            sage: p.add_variables(5)                                 # optional - Nonexistent_LP_solver
    5151            5
    52             sage: p.n_cols()                                         # optional - Nonexistent_LP_solver
     52            sage: p.ncols()                                         # optional - Nonexistent_LP_solver
    5353            5
    5454        """
    5555
     
    7171
    7272        EXAMPLE::
    7373
    74             sage: from sage.numerical.backends.generic_backend import getSolver
    75             sage: p = getSolver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
    76             sage: p.n_cols()                                        # optional - Nonexistent_LP_solver
     74            sage: from sage.numerical.backends.generic_backend import get_solver
     75            sage: p = get_solver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
     76            sage: p.ncols()                                        # optional - Nonexistent_LP_solver
    7777            0
    7878            sage: p.add_variable()                                  # optional - Nonexistent_LP_solver
    7979            1
     
    8484
    8585        raise NotImplementedError()
    8686
    87     cpdef set_direction(self, int sense):
     87    cpdef set_sense(self, int sense):
    8888        r"""
    8989        Sets the direction (maximization/minimization).
    9090
     
    9797
    9898        EXAMPLE::
    9999
    100             sage: from sage.numerical.backends.generic_backend import getSolver
    101             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     100            sage: from sage.numerical.backends.generic_backend import get_solver
     101            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    102102            sage: p.is_maximization()                              # optional - Nonexistent_LP_solver
    103103            True
    104             sage: p.set_direction(-1)                              # optional - Nonexistent_LP_solver
     104            sage: p.set_sense(-1)                              # optional - Nonexistent_LP_solver
    105105            sage: p.is_maximization()                              # optional - Nonexistent_LP_solver
    106106            False
    107107        """
    108108
    109109        raise NotImplementedError()
    110110
    111     cpdef  set_objective_coeff(self, int variable, double coeff):
     111    cpdef  set_objective_coefficient(self, int variable, double coeff):
    112112        r"""
    113113        Sets the coefficient of a variable in the objective function
    114114
     
    120120
    121121        EXAMPLE::
    122122
    123             sage: from sage.numerical.backends.generic_backend import getSolver
    124             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     123            sage: from sage.numerical.backends.generic_backend import get_solver
     124            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    125125            sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    126126            1
    127127            sage: p.get_objective_coeff(0)                         # optional - Nonexistent_LP_solver
    128128            0.0
    129             sage: p.set_objective_coeff(0,2)                       # optional - Nonexistent_LP_solver
     129            sage: p.set_objective_coefficient(0,2)                       # optional - Nonexistent_LP_solver
    130130            sage: p.get_objective_coeff(0)                         # optional - Nonexistent_LP_solver
    131131            2.0
    132132        """
     
    144144
    145145        EXAMPLE::
    146146
    147             sage: from sage.numerical.backends.generic_backend import getSolver
    148             sage: p = getSolver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
     147            sage: from sage.numerical.backends.generic_backend import get_solver
     148            sage: p = get_solver(solver = "Nonexistent_LP_solver")    # optional - Nonexistent_LP_solver
    149149            sage: p.add_variables(5)                                 # optional - Nonexistent_LP_solver
    150150            5
    151151            sage: p.set_objective([1, 1, 2, 1, 3])                   # optional - Nonexistent_LP_solver
     
    155155
    156156        raise NotImplementedError()
    157157
    158     cpdef set_log_level(self, int level):
     158    cpdef set_verbosity(self, int level):
    159159        r"""
    160160        Sets the log (verbosity) level
    161161
     
    165165
    166166        EXAMPLE::
    167167
    168             sage: from sage.numerical.backends.generic_backend import getSolver
    169             sage: p = getSolver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
    170             sage: p.set_log_level(2)                                # optional - Nonexistent_LP_solver
     168            sage: from sage.numerical.backends.generic_backend import get_solver
     169            sage: p = get_solver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
     170            sage: p.set_verbosity(2)                                # optional - Nonexistent_LP_solver
    171171
    172172        """
    173173
     
    205205
    206206        EXAMPLE::
    207207
    208             sage: from sage.numerical.backends.generic_backend import getSolver
    209             sage: p = getSolver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
     208            sage: from sage.numerical.backends.generic_backend import get_solver
     209            sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
    210210            sage: p.add_variables(5)                              # optional - Nonexistent_LP_solver
    211211            5
    212212            sage: p.add_constraint(range(5), range(5), 0, 2)      # optional - Nonexistent_LP_solver
    213             sage: p.get_row(0)                                    # optional - Nonexistent_LP_solver
     213            sage: p.row(0)                                    # optional - Nonexistent_LP_solver
    214214            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    215             sage: p.get_row_bounds(0)                             # optional - Nonexistent_LP_solver
     215            sage: p.row_bounds(0)                             # optional - Nonexistent_LP_solver
    216216            (2.0, 2.0)
    217217        """
    218218        raise NotImplementedError()
     
    240240
    241241        EXAMPLE::
    242242
    243             sage: from sage.numerical.backends.generic_backend import getSolver
    244             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    245             sage: p.n_cols()                                       # optional - Nonexistent_LP_solver
     243            sage: from sage.numerical.backends.generic_backend import get_solver
     244            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     245            sage: p.ncols()                                       # optional - Nonexistent_LP_solver
    246246            0
    247             sage: p.n_rows()                                       # optional - Nonexistent_LP_solver
     247            sage: p.nrows()                                       # optional - Nonexistent_LP_solver
    248248            0
    249249            sage: p.add_constraints(5, -1, 0)                      # optional - Nonexistent_LP_solver
    250250            sage: p.add_col(range(5), range(5))                    # optional - Nonexistent_LP_solver
    251             sage: p.n_rows()                                       # optional - Nonexistent_LP_solver
     251            sage: p.nrows()                                       # optional - Nonexistent_LP_solver
    252252            5
    253253        """
    254254
     
    274274
    275275        EXAMPLE::
    276276
    277             sage: from sage.numerical.backends.generic_backend import getSolver
    278             sage: p = getSolver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
     277            sage: from sage.numerical.backends.generic_backend import get_solver
     278            sage: p = get_solver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
    279279            sage: p.add_variables(5)                                # optional - Nonexistent_LP_solver
    280280            5
    281281            sage: p.add_constraints(5, +1, 2)                       # optional - Nonexistent_LP_solver
    282             sage: p.get_row(4)                                      # optional - Nonexistent_LP_solver
     282            sage: p.row(4)                                      # optional - Nonexistent_LP_solver
    283283            ([], [])
    284             sage: p.get_row_bounds(4)                               # optional - Nonexistent_LP_solver
     284            sage: p.row_bounds(4)                               # optional - Nonexistent_LP_solver
    285285            (None, 2.0)
    286286        """
    287287
     
    299299
    300300        EXAMPLE::
    301301
    302             sage: from sage.numerical.backends.generic_backend import getSolver
    303             sage: p = getSolver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
     302            sage: from sage.numerical.backends.generic_backend import get_solver
     303            sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
    304304            sage: p.add_constraints(5, -1, 0)                     # optional - Nonexistent_LP_solver
    305305            sage: p.add_col(range(5), range(5))                   # optional - Nonexistent_LP_solver
    306306            sage: p.solve()                                       # optional - Nonexistent_LP_solver
    307307            0
    308             sage: p.set_objective_coeff(0,1)                      # optional - Nonexistent_LP_solver
     308            sage: p.set_objective_coefficient(0,1)                      # optional - Nonexistent_LP_solver
    309309            sage: p.solve()                                       # optional - Nonexistent_LP_solver
    310310            Traceback (most recent call last):
    311311            ...
     
    323323
    324324        EXAMPLE::
    325325
    326             sage: from sage.numerical.backends.generic_backend import getSolver
    327             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     326            sage: from sage.numerical.backends.generic_backend import get_solver
     327            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    328328            sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
    329329            2
    330330            sage: p.add_constraint([0, 1], [1, 2], +1, 3)          # optional - Nonexistent_LP_solver
     
    351351
    352352        EXAMPLE::
    353353
    354             sage: from sage.numerical.backends.generic_backend import getSolver
    355             sage: p = getSolver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
     354            sage: from sage.numerical.backends.generic_backend import get_solver
     355            sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
    356356            sage: p.add_variables(2)                              # optional - Nonexistent_LP_solver
    357357            2
    358358            sage: p.add_constraint([0, 1], [1, 2], +1, 3)         # optional - Nonexistent_LP_solver
     
    369369
    370370        raise NotImplementedError()
    371371
    372     cpdef int n_cols(self):
     372    cpdef int ncols(self):
    373373        r"""
    374374        Returns the number of columns/variables.
    375375
    376376        EXAMPLE::
    377377
    378             sage: from sage.numerical.backends.generic_backend import getSolver
    379             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    380             sage: p.n_cols()                                       # optional - Nonexistent_LP_solver
     378            sage: from sage.numerical.backends.generic_backend import get_solver
     379            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     380            sage: p.ncols()                                       # optional - Nonexistent_LP_solver
    381381            0
    382382            sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
    383383            2
    384             sage: p.n_cols()                                       # optional - Nonexistent_LP_solver
     384            sage: p.ncols()                                       # optional - Nonexistent_LP_solver
    385385            2
    386386        """
    387387
    388388        raise NotImplementedError()
    389389
    390     cpdef int n_rows(self):
     390    cpdef int nrows(self):
    391391        r"""
    392392        Returns the number of rows/constraints.
    393393
    394394        EXAMPLE::
    395395
    396             sage: from sage.numerical.backends.generic_backend import getSolver
    397             sage: p = getSolver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
    398             sage: p.n_rows()                                      # optional - Nonexistent_LP_solver
     396            sage: from sage.numerical.backends.generic_backend import get_solver
     397            sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
     398            sage: p.nrows()                                      # optional - Nonexistent_LP_solver
    399399            0
    400400            sage: p.add_constraints(2, -1, 2)                     # optional - Nonexistent_LP_solver
    401             sage: p.n_rows()                                      # optional - Nonexistent_LP_solver
     401            sage: p.nrows()                                      # optional - Nonexistent_LP_solver
    402402            2
    403403        """
    404404
     
    413413
    414414        EXAMPLE::
    415415
    416             sage: from sage.numerical.backends.generic_backend import getSolver
    417             sage: p = getSolver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
     416            sage: from sage.numerical.backends.generic_backend import get_solver
     417            sage: p = get_solver(solver = "Nonexistent_LP_solver") # optional - Nonexistent_LP_solver
    418418            sage: p.is_maximization()                             # optional - Nonexistent_LP_solver
    419419            True
    420             sage: p.set_direction(-1)                             # optional - Nonexistent_LP_solver
     420            sage: p.set_sense(-1)                             # optional - Nonexistent_LP_solver
    421421            sage: p.is_maximization()                             # optional - Nonexistent_LP_solver
    422422            False
    423423        """
    424424        raise NotImplementedError()
    425425
    426     cpdef  set_problem_name(self, char * name):
     426    cpdef problem_name(self, char * name = NULL):
    427427        r"""
    428         Sets the problem's name
     428        Returns or defines the problem's name
    429429
    430430        INPUT:
    431431
    432         - ``name`` (``char *``) -- the problem's name
     432        - ``name`` (``char *``) -- the problem's name. When set to
     433          ``NULL`` (default), the method returns the problem's name.
    433434
    434435        EXAMPLE::
    435436
    436             sage: from sage.numerical.backends.generic_backend import getSolver
    437             sage: p = getSolver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
    438             sage: p.set_problem_name("There once was a french fry") # optional - Nonexistent_LP_solver
     437            sage: from sage.numerical.backends.generic_backend import get_solver
     438            sage: p = get_solver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
     439            sage: p.problem_name("There once was a french fry") # optional - Nonexistent_LP_solver
    439440            sage: print p.get_problem_name()                        # optional - Nonexistent_LP_solver
    440441            There once was a french fry
    441442        """
    442443
    443444        raise NotImplementedError()
    444445
    445     cpdef get_problem_name(self):
    446         r"""
    447         Returns the problem's name
    448 
    449         EXAMPLE::
    450 
    451             sage: from sage.numerical.backends.generic_backend import getSolver
    452             sage: p = getSolver(solver = "Nonexistent_LP_solver")   # optional - Nonexistent_LP_solver
    453             sage: p.set_problem_name("There once was a french fry") # optional - Nonexistent_LP_solver
    454             sage: print p.get_problem_name()                        # optional - Nonexistent_LP_solver
    455             There once was a french fry
    456         """
    457 
    458         raise NotImplementedError()
    459 
    460     cpdef  set_objective_name(self, name):
    461         raise NotImplementedError()
    462 
    463446    cpdef write_lp(self, char * name):
    464447        r"""
    465448        Writes the problem to a .lp file
     
    470453
    471454        EXAMPLE::
    472455
    473             sage: from sage.numerical.backends.generic_backend import getSolver
    474             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     456            sage: from sage.numerical.backends.generic_backend import get_solver
     457            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    475458            sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
    476459            2
    477460            sage: p.add_constraint([0, 1], [1, 2], +1, 3)          # optional - Nonexistent_LP_solver
     
    490473
    491474        EXAMPLE::
    492475
    493             sage: from sage.numerical.backends.generic_backend import getSolver
    494             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     476            sage: from sage.numerical.backends.generic_backend import get_solver
     477            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    495478            sage: p.add_variables(2)                               # optional - Nonexistent_LP_solver
    496479            2
    497480            sage: p.add_constraint([0, 1], [1, 2], +1, 3)          # optional - Nonexistent_LP_solver
     
    500483        """
    501484        raise NotImplementedError()
    502485
    503     cpdef get_row(self, int i):
     486    cpdef row(self, int i):
    504487        r"""
    505488        Returns a row
    506489
     
    517500
    518501        EXAMPLE::
    519502
    520             sage: from sage.numerical.backends.generic_backend import getSolver
    521             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     503            sage: from sage.numerical.backends.generic_backend import get_solver
     504            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    522505            sage: p.add_variables(5)                               # optional - Nonexistent_LP_solver
    523506            5
    524507            sage: p.add_constraint(range(5), range(5), 0, 2)       # optional - Nonexistent_LP_solver
    525             sage: p.get_row(0)                                     # optional - Nonexistent_LP_solver
     508            sage: p.row(0)                                     # optional - Nonexistent_LP_solver
    526509            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    527             sage: p.get_row_bounds(0)                              # optional - Nonexistent_LP_solver
     510            sage: p.row_bounds(0)                              # optional - Nonexistent_LP_solver
    528511            (2.0, 2.0)
    529512        """
    530513
     
    542525
    543526        EXAMPLE::
    544527
    545             sage: from sage.numerical.backends.generic_backend import getSolver
    546             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     528            sage: from sage.numerical.backends.generic_backend import get_solver
     529            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    547530            sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    548531            1
    549532            sage: p.get_objective_coeff(0)                         # optional - Nonexistent_LP_solver
    550533            0.0
    551             sage: p.set_objective_coeff(0,2)                       # optional - Nonexistent_LP_solver
     534            sage: p.set_objective_coefficient(0,2)                       # optional - Nonexistent_LP_solver
    552535            sage: p.get_objective_coeff(0)                         # optional - Nonexistent_LP_solver
    553536            2.0
    554537        """
    555538
    556539        raise NotImplementedError()
    557540
    558     cpdef get_row_name(self, int index):
    559         r"""
    560         Returns the ``index`` th row name
    561 
    562         INPUT:
    563 
    564         - ``index`` (integer) -- the row's id
    565 
    566         EXAMPLE::
    567 
    568             sage: from sage.numerical.backends.generic_backend import getSolver
    569             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    570             sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    571             1
    572             sage: p.set_col_name(0, "I am a variable")             # optional - Nonexistent_LP_solver
    573             sage: p.get_col_name(0)                                # optional - Nonexistent_LP_solver
    574             'I am a variable'
    575         """
    576 
    577         raise NotImplementedError()
    578 
    579     cpdef get_row_bounds(self, int index):
     541    cpdef row_bounds(self, int index):
    580542        r"""
    581543        Returns the bounds of a specific constraint.
    582544
     
    592554
    593555        EXAMPLE::
    594556
    595             sage: from sage.numerical.backends.generic_backend import getSolver
    596             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     557            sage: from sage.numerical.backends.generic_backend import get_solver
     558            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    597559            sage: p.add_variables(5)                               # optional - Nonexistent_LP_solver
    598560            5
    599561            sage: p.add_constraint(range(5), range(5), 0, 2)       # optional - Nonexistent_LP_solver
    600             sage: p.get_row(0)                                     # optional - Nonexistent_LP_solver
     562            sage: p.row(0)                                     # optional - Nonexistent_LP_solver
    601563            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    602             sage: p.get_row_bounds(0)                              # optional - Nonexistent_LP_solver
     564            sage: p.row_bounds(0)                              # optional - Nonexistent_LP_solver
    603565            (2.0, 2.0)
    604566        """
    605567        raise NotImplementedError()
    606568
    607     cpdef get_col_bounds(self, int index):
     569    cpdef col_bounds(self, int index):
    608570        r"""
    609571        Returns the bounds of a specific variable.
    610572
     
    620582
    621583        EXAMPLE::
    622584
    623             sage: from sage.numerical.backends.generic_backend import getSolver
    624             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     585            sage: from sage.numerical.backends.generic_backend import get_solver
     586            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    625587            sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    626588            1
    627             sage: p.get_col_bounds(0)                              # optional - Nonexistent_LP_solver
     589            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    628590            (0.0, None)
    629             sage: p.set_variable_max(0, 5)                         # optional - Nonexistent_LP_solver
    630             sage: p.get_col_bounds(0)                              # optional - Nonexistent_LP_solver
     591            sage: p.variable_max(0, 5)                         # optional - Nonexistent_LP_solver
     592            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    631593            (0.0, 5.0)
    632594        """
    633595
     
    643605
    644606        EXAMPLE::
    645607
    646             sage: from sage.numerical.backends.generic_backend import getSolver
    647             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    648             sage: p.n_cols()                                       # optional - Nonexistent_LP_solver
     608            sage: from sage.numerical.backends.generic_backend import get_solver
     609            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     610            sage: p.ncols()                                       # optional - Nonexistent_LP_solver
    649611            0
    650612            sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    651613            1
     
    667629
    668630        EXAMPLE::
    669631
    670             sage: from sage.numerical.backends.generic_backend import getSolver
    671             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    672             sage: p.n_cols()                                       # optional - Nonexistent_LP_solver
     632            sage: from sage.numerical.backends.generic_backend import get_solver
     633            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     634            sage: p.ncols()                                       # optional - Nonexistent_LP_solver
    673635            0
    674636            sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    675637            1
     
    690652
    691653        EXAMPLE::
    692654
    693             sage: from sage.numerical.backends.generic_backend import getSolver
    694             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    695             sage: p.n_cols()                                       # optional - Nonexistent_LP_solver
     655            sage: from sage.numerical.backends.generic_backend import get_solver
     656            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     657            sage: p.ncols()                                       # optional - Nonexistent_LP_solver
    696658            0
    697659            sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    698660            1
     
    706668
    707669        raise NotImplementedError()
    708670
    709     cpdef set_row_name(self, int index, char * name):
     671    cpdef row_name(self, int index, char * name = NULL):
    710672        r"""
    711         Sets the ``index`` th row name
     673        Returns or defines the ``index`` th row name
    712674
    713675        INPUT:
    714676
    715677        - ``index`` (integer) -- the row's id
    716678
    717         - ``name`` (``char *``) -- its name
     679        - ``name`` (``char *``) -- its name. When set to ``NULL``
     680          (default), the method returns the current name.
    718681
    719682        EXAMPLE::
    720683
    721             sage: from sage.numerical.backends.generic_backend import getSolver
    722             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     684            sage: from sage.numerical.backends.generic_backend import get_solver
     685            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    723686            sage: p.add_constraints(1, -1, 2)                      # optional - Nonexistent_LP_solver
    724             sage: p.set_row_name(0, "Empty constraint 1")          # optional - Nonexistent_LP_solver
    725             sage: p.get_row_name(0)                                # optional - Nonexistent_LP_solver
     687            sage: p.row_name(0, "Empty constraint 1")          # optional - Nonexistent_LP_solver
     688            sage: p.row_name(0)                                # optional - Nonexistent_LP_solver
    726689            'Empty constraint 1'
    727690
    728691        """
    729692
    730693        raise NotImplementedError()
    731694
    732     cpdef set_col_name(self, int index, char * name):
     695    cpdef col_name(self, int index, char * name = NULL):
    733696        r"""
    734         Sets the ``index`` th col name
     697        Returns or defines the ``index`` th col name
    735698
    736699        INPUT:
    737700
    738701        - ``index`` (integer) -- the col's id
    739702
    740         - ``name`` (``char *``) -- its name
     703        - ``name`` (``char *``) -- its name. When set to ``NULL``
     704          (default), the method returns the current name.
    741705
    742706        EXAMPLE::
    743707
    744             sage: from sage.numerical.backends.generic_backend import getSolver
    745             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     708            sage: from sage.numerical.backends.generic_backend import get_solver
     709            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    746710            sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    747711            1
    748             sage: p.set_col_name(0, "I am a variable")             # optional - Nonexistent_LP_solver
    749             sage: p.get_col_name(0)                                # optional - Nonexistent_LP_solver
     712            sage: p.col_name(0, "I am a variable")             # optional - Nonexistent_LP_solver
     713            sage: p.col_name(0)                                # optional - Nonexistent_LP_solver
    750714            'I am a variable'
    751715        """
    752716
    753717        raise NotImplementedError()
    754718
    755     cpdef get_col_name(self, int index):
     719    cpdef  variable_max(self, int index, value = None):
    756720        r"""
    757         Returns the ``index`` th variable name
    758 
    759         INPUT:
    760 
    761         - ``index`` (integer) -- the variable's id
    762 
    763         EXAMPLE::
    764 
    765             sage: from sage.numerical.backends.generic_backend import getSolver
    766             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    767             sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    768             1
    769             sage: p.set_col_name(0, "I am a variable")             # optional - Nonexistent_LP_solver
    770             sage: p.get_col_name(0)                                # optional - Nonexistent_LP_solver
    771             'I am a variable'
    772         """
    773 
    774         raise NotImplementedError()
    775 
    776     cpdef get_variable_max(self, int index):
    777         r"""
    778         Returns the upper bound on a variable
    779 
    780         INPUT:
    781 
    782         - ``index`` (integer) -- the variable's id
    783 
    784         OUTPUT:
    785 
    786         A real value if the variable has an upper bound, ``None``
    787         otherwise.
    788 
    789         EXAMPLE::
    790 
    791             sage: from sage.numerical.backends.generic_backend import getSolver
    792             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    793             sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    794             1
    795             sage: p.get_variable_max(0) is None                    # optional - Nonexistent_LP_solver
    796             True
    797             sage: p.set_variable_max(0, 5)                         # optional - Nonexistent_LP_solver
    798             sage: p.get_variable_max(0)                            # optional - Nonexistent_LP_solver
    799             5.0
    800 
    801         """
    802 
    803         raise NotImplementedError()
    804 
    805     cpdef get_variable_min(self, int index):
    806         r"""
    807         Returns the lower bound on a variable
    808 
    809         INPUT:
    810 
    811         - ``index`` (integer) -- the variable's id
    812 
    813         OUTPUT:
    814 
    815         A real value if the variable has an lower bound, ``None``
    816         otherwise.
    817 
    818         EXAMPLE::
    819 
    820             sage: from sage.numerical.backends.generic_backend import getSolver
    821             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    822             sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    823             1
    824             sage: p.get_variable_min(0)                            # optional - Nonexistent_LP_solver
    825             0.0
    826             sage: p.set_variable_min(0, 5)                         # optional - Nonexistent_LP_solver
    827             sage: p.get_variable_min(0)                            # optional - Nonexistent_LP_solver
    828             5.0
    829         """
    830         raise NotImplementedError()
    831 
    832     cpdef  set_variable_max(self, int index, value):
    833         r"""
    834         Sets the upper bound on a variable
     721        Returns or defines the upper bound on a variable
    835722
    836723        INPUT:
    837724
    838725        - ``index`` (integer) -- the variable's id
    839726
    840727        - ``value`` -- real value, or ``None`` to mean that the
    841           variable has not upper bound.
     728          variable has not upper bound. When set to ``None``
     729          (default), the method returns the current value.
    842730
    843731        EXAMPLE::
    844732
    845             sage: from sage.numerical.backends.generic_backend import getSolver
    846             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     733            sage: from sage.numerical.backends.generic_backend import get_solver
     734            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    847735            sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    848736            1
    849             sage: p.get_col_bounds(0)                              # optional - Nonexistent_LP_solver
     737            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    850738            (0.0, None)
    851             sage: p.set_variable_max(0, 5)                         # optional - Nonexistent_LP_solver
    852             sage: p.get_col_bounds(0)                              # optional - Nonexistent_LP_solver
     739            sage: p.variable_max(0, 5)                         # optional - Nonexistent_LP_solver
     740            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    853741            (0.0, 5.0)
    854742        """
    855743
    856744        raise NotImplementedError()
    857745
    858     cpdef  set_variable_min(self, int index, value):
     746    cpdef  variable_min(self, int index, value = None):
    859747        r"""
    860         Sets the lower bound on a variable
     748        Returns or defines the lower bound on a variable
    861749
    862750        INPUT:
    863751
    864752        - ``index`` (integer) -- the variable's id
    865753
    866754        - ``value`` -- real value, or ``None`` to mean that the
    867           variable has not lower bound.
     755          variable has not lower bound. When set to ``None``
     756          (default), the method returns the current value.
    868757
    869758        EXAMPLE::
    870759
    871             sage: from sage.numerical.backends.generic_backend import getSolver
    872             sage: p = getSolver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
     760            sage: from sage.numerical.backends.generic_backend import get_solver
     761            sage: p = get_solver(solver = "Nonexistent_LP_solver")  # optional - Nonexistent_LP_solver
    873762            sage: p.add_variable()                                 # optional - Nonexistent_LP_solver
    874763            1
    875             sage: p.get_col_bounds(0)                              # optional - Nonexistent_LP_solver
     764            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    876765            (0.0, None)
    877             sage: p.set_variable_min(0, 5)                         # optional - Nonexistent_LP_solver
    878             sage: p.get_col_bounds(0)                              # optional - Nonexistent_LP_solver
     766            sage: p.variable_min(0, 5)                         # optional - Nonexistent_LP_solver
     767            sage: p.col_bounds(0)                              # optional - Nonexistent_LP_solver
    879768            (5.0, None)
    880769        """
    881770
    882771        raise NotImplementedError()
    883772   
    884773
    885 cpdef GenericBackend getSolver(constraint_generation = False, solver = None):
     774cpdef GenericBackend get_solver(constraint_generation = False, solver = None):
    886775    r"""
    887776    Returns a solver according to the given preferences
    888777
     
    920809
    921810    EXAMPLE::
    922811
    923         sage: from sage.numerical.backends.generic_backend import getSolver
    924         sage: p = getSolver()
     812        sage: from sage.numerical.backends.generic_backend import get_solver
     813        sage: p = get_solver()
    925814
    926815    """
    927816
  • sage/numerical/backends/glpk_backend.pyx

    diff -r 0b5f2ba89540 -r f3c711eb0c73 sage/numerical/backends/glpk_backend.pyx
    a b  
    66
    77cdef class GLPKBackend(GenericBackend):
    88
    9     def __cinit__(self):
     9    def __cinit__(self, maximization = True):
    1010        r"""
    1111        Constructor
    1212
     
    1919        self.iocp = new_c_glp_iocp()
    2020        glp_init_iocp(self.iocp)
    2121        self.iocp.presolve = GLP_ON
    22         glp_set_obj_dir(self.lp, GLP_MAX)
    23         self.set_log_level(0)
     22        self.set_verbosity(0)
     23
     24        if maximization:
     25            self.set_sense(+1)
     26        else:
     27            self.set_sense(-1)
     28
    2429        #self.iocp.gmi_cuts = GLP_ON
    2530        #self.iocp.fp_heur = GLP_ON
    2631        #self.iocp.mir_cuts = GLP_ON
     
    3439
    3540        EXAMPLE::
    3641
    37             sage: from sage.numerical.backends.generic_backend import getSolver
    38             sage: p = getSolver(solver = "GLPK")
    39             sage: p.n_cols()
     42            sage: from sage.numerical.backends.generic_backend import get_solver
     43            sage: p = get_solver(solver = "GLPK")
     44            sage: p.ncols()
    4045            0
    4146            sage: p.add_variable()
    4247            1
    43             sage: p.n_cols()
     48            sage: p.ncols()
    4449            1
    4550        """
    4651
     
    6065
    6166        EXAMPLE::
    6267
    63             sage: from sage.numerical.backends.generic_backend import getSolver
    64             sage: p = getSolver(solver = "GLPK")
    65             sage: p.n_cols()
     68            sage: from sage.numerical.backends.generic_backend import get_solver
     69            sage: p = get_solver(solver = "GLPK")
     70            sage: p.ncols()
    6671            0
    6772            sage: p.add_variables(5)
    6873            5
    69             sage: p.n_cols()
     74            sage: p.ncols()
    7075            5
    7176        """
    7277
     
    100105
    101106        EXAMPLE::
    102107
    103             sage: from sage.numerical.backends.generic_backend import getSolver
    104             sage: p = getSolver(solver = "GLPK")
    105             sage: p.n_cols()
     108            sage: from sage.numerical.backends.generic_backend import get_solver
     109            sage: p = get_solver(solver = "GLPK")
     110            sage: p.ncols()
    106111            0
    107112            sage: p.add_variable()
    108113            1
     
    120125        else:
    121126            glp_set_col_kind(self.lp, variable+1, GLP_CV)
    122127
    123     cpdef set_direction(self, int sense):
     128    cpdef set_sense(self, int sense):
    124129        r"""
    125130        Sets the direction (maximization/minimization).
    126131
     
    133138
    134139        EXAMPLE::
    135140
    136             sage: from sage.numerical.backends.generic_backend import getSolver
    137             sage: p = getSolver(solver = "GLPK")
     141            sage: from sage.numerical.backends.generic_backend import get_solver
     142            sage: p = get_solver(solver = "GLPK")
    138143            sage: p.is_maximization()
    139144            True
    140             sage: p.set_direction(-1)
     145            sage: p.set_sense(-1)
    141146            sage: p.is_maximization()
    142147            False
    143148        """
     
    146151        else:
    147152            glp_set_obj_dir(self.lp, GLP_MIN)
    148153
    149     cpdef set_objective_coeff(self, int variable, double coeff):
     154    cpdef set_objective_coefficient(self, int variable, double coeff):
    150155        r"""
    151156        Sets the coefficient of a variable in the objective function
    152157
     
    158163
    159164        EXAMPLE::
    160165
    161             sage: from sage.numerical.backends.generic_backend import getSolver
    162             sage: p = getSolver(solver = "GLPK")
     166            sage: from sage.numerical.backends.generic_backend import get_solver
     167            sage: p = get_solver(solver = "GLPK")
    163168            sage: p.add_variable()
    164169            1
    165170            sage: p.get_objective_coeff(0)
    166171            0.0
    167             sage: p.set_objective_coeff(0,2)
     172            sage: p.set_objective_coefficient(0,2)
    168173            sage: p.get_objective_coeff(0)
    169174            2.0
    170175        """
     
    172177        glp_set_obj_coef(self.lp, variable + 1, coeff)
    173178
    174179
    175     cpdef set_problem_name(self, char * name):
     180    cpdef problem_name(self, char * name = NULL):
    176181        r"""
    177         Sets the problem's name
     182        Returns or defines the problem's name
    178183
    179184        INPUT:
    180185
    181         - ``name`` (``char *``) -- the problem's name
     186        - ``name`` (``char *``) -- the problem's name. When set to
     187          ``NULL`` (default), the method returns the problem's name.
    182188
    183189        EXAMPLE::
    184190
    185             sage: from sage.numerical.backends.generic_backend import getSolver
    186             sage: p = getSolver(solver = "GLPK")
    187             sage: p.set_problem_name("There once was a french fry")
    188             sage: print p.get_problem_name()
     191            sage: from sage.numerical.backends.generic_backend import get_solver
     192            sage: p = get_solver(solver = "GLPK")
     193            sage: p.problem_name("There once was a french fry")
     194            sage: print p.problem_name()
    189195            There once was a french fry
    190196        """
     197        cdef char * n
     198   
     199        if name == NULL:
     200            n =  <char *> glp_get_prob_name(self.lp)
     201            if n == NULL:
     202                return ""
     203            else:
     204                return n
    191205
    192         glp_set_prob_name(self.lp, name)
    193 
    194     cpdef  get_problem_name(self):
    195         r"""
    196         Returns the problem's name
    197 
    198         EXAMPLE::
    199 
    200             sage: from sage.numerical.backends.generic_backend import getSolver
    201             sage: p = getSolver(solver = "GLPK")
    202             sage: p.set_problem_name("There once was a french fry")
    203             sage: print p.get_problem_name()
    204             There once was a french fry
    205         """
    206 
    207         cdef char * name = <char *> glp_get_prob_name(self.lp)
    208         if name == NULL:
    209             return ""
    210206        else:
    211             return name
     207            glp_set_prob_name(self.lp, name)
    212208
    213209    cpdef set_objective(self, list coeff):
    214210        r"""
     
    221217
    222218        EXAMPLE::
    223219
    224             sage: from sage.numerical.backends.generic_backend import getSolver
    225             sage: p = getSolver(solver = "GLPK")
     220            sage: from sage.numerical.backends.generic_backend import get_solver
     221            sage: p = get_solver(solver = "GLPK")
    226222            sage: p.add_variables(5)
    227223            5
    228224            sage: p.set_objective([1, 1, 2, 1, 3])
     
    235231        for i,v in enumerate(coeff):
    236232            glp_set_obj_coef(self.lp, i+1, v)
    237233
    238     cpdef set_log_level(self, int level):
     234    cpdef set_verbosity(self, int level):
    239235        r"""
    240         Sets the log (verbosity) level
     236        Sets the verbosity level
    241237
    242238        INPUT:
    243239
     
    245241
    246242        EXAMPLE::
    247243
    248             sage: from sage.numerical.backends.generic_backend import getSolver
    249             sage: p = getSolver(solver = "GLPK")
    250             sage: p.set_log_level(2)
     244            sage: from sage.numerical.backends.generic_backend import get_solver
     245            sage: p = get_solver(solver = "GLPK")
     246            sage: p.set_verbosity(2)
    251247
    252248        """
    253249        if level == 0:
     
    279275
    280276        EXAMPLE::
    281277
    282             sage: from sage.numerical.backends.generic_backend import getSolver
    283             sage: p = getSolver(solver = "GLPK")
     278            sage: from sage.numerical.backends.generic_backend import get_solver
     279            sage: p = get_solver(solver = "GLPK")
    284280            sage: p.add_variables(5)
    285281            5
    286282            sage: p.add_constraints(5, +1, 2)
    287             sage: p.get_row(4)
     283            sage: p.row(4)
    288284            ([], [])
    289             sage: p.get_row_bounds(4)
     285            sage: p.row_bounds(4)
    290286            (None, 2.0)
    291287        """
    292288
     
    336332
    337333        EXAMPLE::
    338334
    339             sage: from sage.numerical.backends.generic_backend import getSolver
    340             sage: p = getSolver(solver = "GLPK")
     335            sage: from sage.numerical.backends.generic_backend import get_solver
     336            sage: p = get_solver(solver = "GLPK")
    341337            sage: p.add_variables(5)
    342338            5
    343339            sage: p.add_constraint(range(5), range(5), 0, 2)
    344             sage: p.get_row(0)
     340            sage: p.row(0)
    345341            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    346             sage: p.get_row_bounds(0)
     342            sage: p.row_bounds(0)
    347343            (2.0, 2.0)
    348344        """
    349345
     
    371367        glp_set_mat_row(self.lp, n, len(indices), row_i, row_values)
    372368        glp_set_row_bnds(self.lp, n, direction, bound, bound)
    373369
    374     cpdef get_row(self, int index):
     370    cpdef row(self, int index):
    375371        r"""
    376372        Returns a row
    377373
     
    388384
    389385        EXAMPLE::
    390386
    391             sage: from sage.numerical.backends.generic_backend import getSolver
    392             sage: p = getSolver(solver = "GLPK")
     387            sage: from sage.numerical.backends.generic_backend import get_solver
     388            sage: p = get_solver(solver = "GLPK")
    393389            sage: p.add_variables(5)
    394390            5
    395391            sage: p.add_constraint(range(5), range(5), 0, 2)
    396             sage: p.get_row(0)
     392            sage: p.row(0)
    397393            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    398             sage: p.get_row_bounds(0)
     394            sage: p.row_bounds(0)
    399395            (2.0, 2.0)
    400396        """
    401397        cdef int n = glp_get_num_cols(self.lp)
     
    415411
    416412        return (indices, values)
    417413
    418     cpdef get_row_bounds(self, int index):
     414    cpdef row_bounds(self, int index):
    419415        r"""
    420416        Returns the bounds of a specific constraint.
    421417
     
    431427
    432428        EXAMPLE::
    433429
    434             sage: from sage.numerical.backends.generic_backend import getSolver
    435             sage: p = getSolver(solver = "GLPK")
     430            sage: from sage.numerical.backends.generic_backend import get_solver
     431            sage: p = get_solver(solver = "GLPK")
    436432            sage: p.add_variables(5)
    437433            5
    438434            sage: p.add_constraint(range(5), range(5), 0, 2)
    439             sage: p.get_row(0)
     435            sage: p.row(0)
    440436            ([4, 3, 2, 1], [4.0, 3.0, 2.0, 1.0])
    441             sage: p.get_row_bounds(0)
     437            sage: p.row_bounds(0)
    442438            (2.0, 2.0)
    443439        """
    444440        cdef double ub
     
    452448            (ub if ub != +DBL_MAX else None)
    453449            )
    454450
    455     cpdef get_col_bounds(self, int index):
     451    cpdef col_bounds(self, int index):
    456452        r"""
    457453        Returns the bounds of a specific variable.
    458454
     
    468464
    469465        EXAMPLE::
    470466
    471             sage: from sage.numerical.backends.generic_backend import getSolver
    472             sage: p = getSolver(solver = "GLPK")
     467            sage: from sage.numerical.backends.generic_backend import get_solver
     468            sage: p = get_solver(solver = "GLPK")
    473469            sage: p.add_variable()
    474470            1
    475             sage: p.get_col_bounds(0)
     471            sage: p.col_bounds(0)
    476472            (0.0, None)
    477             sage: p.set_variable_max(0, 5)
    478             sage: p.get_col_bounds(0)
     473            sage: p.variable_max(0, 5)
     474            sage: p.col_bounds(0)
    479475            (0.0, 5.0)
    480476        """
    481477
     
    501497
    502498        EXAMPLE::
    503499
    504             sage: from sage.numerical.backends.generic_backend import getSolver
    505             sage: p = getSolver(solver = "GLPK")
     500            sage: from sage.numerical.backends.generic_backend import get_solver
     501            sage: p = get_solver(solver = "GLPK")
    506502            sage: p.add_variable()
    507503            1
    508504            sage: p.get_objective_coeff(0)
    509505            0.0
    510             sage: p.set_objective_coeff(0,2)
     506            sage: p.set_objective_coefficient(0,2)
    511507            sage: p.get_objective_coeff(0)
    512508            2.0
    513509        """
     
    537533
    538534        EXAMPLE::
    539535
    540             sage: from sage.numerical.backends.generic_backend import getSolver
    541             sage: p = getSolver(solver = "GLPK")
    542             sage: p.n_cols()
     536            sage: from sage.numerical.backends.generic_backend import get_solver
     537            sage: p = get_solver(solver = "GLPK")
     538            sage: p.ncols()
    543539            0
    544             sage: p.n_rows()
     540            sage: p.nrows()
    545541            0
    546542            sage: p.add_constraints(5, -1, 0)
    547543            sage: p.add_col(range(5), range(5))
    548             sage: p.n_rows()
     544            sage: p.nrows()
    549545            5
    550546        """
    551547
     
    579575
    580576        EXAMPLE::
    581577
    582             sage: from sage.numerical.backends.generic_backend import getSolver
    583             sage: p = getSolver(solver = "GLPK")
     578            sage: from sage.numerical.backends.generic_backend import get_solver
     579            sage: p = get_solver(solver = "GLPK")
    584580            sage: p.add_constraints(5, -1, 0)
    585581            sage: p.add_col(range(5), range(5))
    586582            sage: p.solve()
    587583            0
    588             sage: p.set_objective_coeff(0,1)
     584            sage: p.set_objective_coefficient(0,1)
    589585            sage: p.solve()
    590586            Traceback (most recent call last):
    591587            ...
     
    616612
    617613        EXAMPLE::
    618614
    619             sage: from sage.numerical.backends.generic_backend import getSolver
    620             sage: p = getSolver(solver = "GLPK")
     615            sage: from sage.numerical.backends.generic_backend import get_solver
     616            sage: p = get_solver(solver = "GLPK")
    621617            sage: p.add_variables(2)
    622618            2
    623619            sage: p.add_constraint([0, 1], [1, 2], +1, 3)
     
    643639
    644640        EXAMPLE::
    645641
    646             sage: from sage.numerical.backends.generic_backend import getSolver
    647             sage: p = getSolver(solver = "GLPK")
     642            sage: from sage.numerical.backends.generic_backend import get_solver
     643            sage: p = get_solver(solver = "GLPK")
    648644            sage: p.add_variables(2)
    649645            2
    650646            sage: p.add_constraint([0, 1], [1, 2], +1, 3)
     
    660656        """   
    661657        return glp_mip_col_val(self.lp, variable+1)
    662658
    663     cpdef int n_cols(self):
     659    cpdef int ncols(self):
    664660        r"""
    665661        Returns the number of columns/variables.
    666662
    667663        EXAMPLE::
    668664
    669             sage: from sage.numerical.backends.generic_backend import getSolver
    670             sage: p = getSolver(solver = "GLPK")
    671             sage: p.n_cols()
     665            sage: from sage.numerical.backends.generic_backend import get_solver
     666            sage: p = get_solver(solver = "GLPK")
     667            sage: p.ncols()
    672668            0
    673669            sage: p.add_variables(2)
    674670            2
    675             sage: p.n_cols()
     671            sage: p.ncols()
    676672            2
    677673        """
    678674        return glp_get_num_cols(self.lp)
    679675
    680     cpdef int n_rows(self):
     676    cpdef int nrows(self):
    681677        r"""
    682678        Returns the number of rows/constraints.
    683679
    684680        EXAMPLE::
    685681
    686             sage: from sage.numerical.backends.generic_backend import getSolver
    687             sage: p = getSolver(solver = "GLPK")
    688             sage: p.n_rows()
     682            sage: from sage.numerical.backends.generic_backend import get_solver
     683            sage: p = get_solver(solver = "GLPK")
     684            sage: p.nrows()
    689685            0
    690686            sage: p.add_constraints(2, -1, 2)
    691             sage: p.n_rows()
     687            sage: p.nrows()
    692688            2
    693689        """
    694690
    695691        return glp_get_num_rows(self.lp)
    696692
    697     cpdef get_row_name(self, int index):
     693    cpdef col_name(self, int index, char * name = NULL):
    698694        r"""
    699         Returns the ``index`` th row name
     695        Returns or defines the ``index`` th col name
     696
     697        INPUT:
     698
     699        - ``index`` (integer) -- the col's id
     700
     701        - ``name`` (``char *``) -- its name. When set to ``NULL``
     702          (default), the method returns the current name.
     703
     704        EXAMPLE::
     705
     706            sage: from sage.numerical.backends.generic_backend import get_solver
     707            sage: p = get_solver(solver = "GLPK")
     708            sage: p.add_variable()
     709            1
     710            sage: p.col_name(0, "I am a variable")
     711            sage: p.col_name(0)
     712            'I am a variable'
     713        """
     714        cdef char * s
     715
     716        if name == NULL:
     717            glp_create_index(self.lp)
     718            s = <char*> glp_get_col_name(self.lp, index + 1)
     719           
     720            if s != NULL:
     721                return s
     722            else:
     723                return ""
     724        else:
     725            glp_set_col_name(self.lp, index + 1, name)
     726
     727    cpdef row_name(self, int index, char * name = NULL):
     728        r"""
     729        Returns or defines the ``index`` th row name
    700730
    701731        INPUT:
    702732
    703733        - ``index`` (integer) -- the row's id
    704734
    705         EXAMPLE::
    706 
    707             sage: from sage.numerical.backends.generic_backend import getSolver
    708             sage: p = getSolver(solver = "GLPK")
    709             sage: p.add_variable()
    710             1
    711             sage: p.set_col_name(0, "I am a variable")
    712             sage: p.get_col_name(0)
    713             'I am a variable'
    714         """
    715         glp_create_index(self.lp)
    716         cdef char *  s = <char*> glp_get_row_name(self.lp, index + 1)
    717 
    718         if s != NULL:
    719             return s
    720         else:
    721             return ""
    722 
    723 
    724     cpdef set_col_name(self, int index, char * name):
    725         r"""
    726         Sets the ``index`` th col name
    727 
    728         INPUT:
    729 
    730         - ``index`` (integer) -- the col's id
    731 
    732         - ``name`` (``char *``) -- its name
     735        - ``name`` (``char *``) -- its name. When set to ``NULL``
     736          (default), the method returns the current name.
    733737
    734738        EXAMPLE::
    735739
    736             sage: from sage.numerical.backends.generic_backend import getSolver
    737             sage: p = getSolver(solver = "GLPK")
    738             sage: p.add_variable()
    739             1
    740             sage: p.set_col_name(0, "I am a variable")
    741             sage: p.get_col_name(0)
    742             'I am a variable'
    743         """
    744 
    745         glp_set_col_name(self.lp, index + 1, name)
    746 
    747     cpdef get_col_name(self, int index):
    748         r"""
    749         Returns the ``index`` th variable name
    750 
    751         INPUT:
    752 
    753         - ``index`` (integer) -- the variable's id
    754 
    755         EXAMPLE::
    756 
    757             sage: from sage.numerical.backends.generic_backend import getSolver
    758             sage: p = getSolver(solver = "GLPK")
     740            sage: from sage.numerical.backends.generic_backend import get_solver
     741            sage: p = get_solver(solver = "GLPK")
    759742            sage: p.add_constraints(1, -1, 2)
    760             sage: p.set_row_name(0, "Empty constraint 1")
    761             sage: p.get_row_name(0)
    762             'Empty constraint 1'
    763         """
    764         glp_create_index(self.lp)
    765         cdef char *  s = <char*> glp_get_col_name(self.lp, index + 1)
    766 
    767         if s != NULL:
    768             return s
    769         else:
    770             return ""
    771 
    772     cpdef set_row_name(self, int index, char * name):
    773         r"""
    774         Sets the ``index`` th row name
    775 
    776         INPUT:
    777 
    778         - ``index`` (integer) -- the row's id
    779 
    780         - ``name`` (``char *``) -- its name
    781 
    782         EXAMPLE::
    783 
    784             sage: from sage.numerical.backends.generic_backend import getSolver
    785             sage: p = getSolver(solver = "GLPK")
    786             sage: p.add_constraints(1, -1, 2)
    787             sage: p.set_row_name(0, "Empty constraint 1")
    788             sage: p.get_row_name(0)
     743            sage: p.row_name(0, "Empty constraint 1")
     744            sage: p.row_name(0)
    789745            'Empty constraint 1'
    790746
    791747        """
     748        cdef char *  s
    792749
    793         glp_set_row_name(self.lp, index + 1, name)
     750        if name == NULL:
     751            glp_create_index(self.lp)
     752            s = <char*> glp_get_row_name(self.lp, index + 1)
     753           
     754            if s != NULL:
     755                return s
     756            else:
     757                return ""
     758        else:
     759            glp_set_row_name(self.lp, index + 1, name)
    794760
    795761    cpdef bint is_variable_binary(self, int index):
    796762        r"""
     
    802768
    803769        EXAMPLE::
    804770
    805             sage: from sage.numerical.backends.generic_backend import getSolver
    806             sage: p = getSolver(solver = "GLPK")
    807             sage: p.n_cols()
     771            sage: from sage.numerical.backends.generic_backend import get_solver
     772            sage: p = get_solver(solver = "GLPK")
     773            sage: p.ncols()
    808774            0
    809775            sage: p.add_variable()
    810776            1
     
    825791
    826792        EXAMPLE::
    827793
    828             sage: from sage.numerical.backends.generic_backend import getSolver
    829             sage: p = getSolver(solver = "GLPK")
    830             sage: p.n_cols()
     794            sage: from sage.numerical.backends.generic_backend import get_solver
     795            sage: p = get_solver(solver = "GLPK")
     796            sage: p.ncols()
    831797            0
    832798            sage: p.add_variable()
    833799            1
     
    847813
    848814        EXAMPLE::
    849815
    850             sage: from sage.numerical.backends.generic_backend import getSolver
    851             sage: p = getSolver(solver = "GLPK")
    852             sage: p.n_cols()
     816            sage: from sage.numerical.backends.generic_backend import get_solver
     817            sage: p = get_solver(solver = "GLPK")
     818            sage: p.ncols()
    853819            0
    854820            sage: p.add_variable()
    855821            1
     
    868834
    869835        EXAMPLE::
    870836
    871             sage: from sage.numerical.backends.generic_backend import getSolver
    872             sage: p = getSolver(solver = "GLPK")
     837            sage: from sage.numerical.backends.generic_backend import get_solver
     838            sage: p = get_solver(solver = "GLPK")
    873839            sage: p.is_maximization()
    874840            True
    875             sage: p.set_direction(-1)
     841            sage: p.set_sense(-1)
    876842            sage: p.is_maximization()
    877843            False
    878844        """
    879845
    880846        return glp_get_obj_dir(self.lp) == GLP_MAX
    881847
    882     cpdef get_variable_max(self, int index):
     848    cpdef variable_max(self, int index, value = False):
    883849        r"""
    884         Returns the upper bound on a variable
    885 
    886         INPUT:
    887 
    888         - ``index`` (integer) -- the variable's id
    889 
    890         OUTPUT:
    891 
    892         A real value if the variable has an upper bound, ``None``
    893         otherwise.
    894 
    895         EXAMPLE::
    896 
    897             sage: from sage.numerical.backends.generic_backend import getSolver
    898             sage: p = getSolver(solver = "GLPK")
    899             sage: p.add_variable()
    900             1
    901             sage: p.get_variable_max(0) is None
    902             True
    903             sage: p.set_variable_max(0, 5)
    904             sage: p.get_variable_max(0)
    905             5.0
    906 
    907         """
    908         cdef double x = glp_get_col_ub(self.lp, index +1)
    909         if x == DBL_MAX:
    910             return None
    911         else:
    912             return x
    913 
    914     cpdef get_variable_min(self, int index):
    915         r"""
    916         Returns the lower bound on a variable
    917 
    918         INPUT:
    919 
    920         - ``index`` (integer) -- the variable's id
    921 
    922         OUTPUT:
    923 
    924         A real value if the variable has an lower bound, ``None``
    925         otherwise.
    926 
    927         EXAMPLE::
    928 
    929             sage: from sage.numerical.backends.generic_backend import getSolver
    930             sage: p = getSolver(solver = "GLPK")
    931             sage: p.add_variable()
    932             1
    933             sage: p.get_variable_min(0)
    934             0.0
    935             sage: p.set_variable_min(0, 5)
    936             sage: p.get_variable_min(0)
    937             5.0
    938         """
    939         cdef double x = glp_get_col_lb(self.lp, index +1)
    940         if x == -DBL_MAX:
    941             return None
    942         else:
    943             return x
    944 
    945     cpdef set_variable_max(self, int index, value):
    946         r"""
    947         Sets the upper bound on a variable
     850        Returns or defines the upper bound on a variable
    948851
    949852        INPUT:
    950853
    951854        - ``index`` (integer) -- the variable's id
    952855
    953856        - ``value`` -- real value, or ``None`` to mean that the
    954           variable has not upper bound.
     857          variable has not upper bound. When set to ``False``
     858          (default), the method returns the current value.
    955859
    956860        EXAMPLE::
    957861
    958             sage: from sage.numerical.backends.generic_backend import getSolver
    959             sage: p = getSolver(solver = "GLPK")
     862            sage: from sage.numerical.backends.generic_backend import get_solver
     863            sage: p = get_solver(solver = "GLPK")
    960864            sage: p.add_variable()
    961865            1
    962             sage: p.get_col_bounds(0)
     866            sage: p.col_bounds(0)
    963867            (0.0, None)
    964             sage: p.set_variable_max(0, 5)
    965             sage: p.get_col_bounds(0)
     868            sage: p.variable_max(0, 5)
     869            sage: p.col_bounds(0)
    966870            (0.0, 5.0)
    967871        """
     872        cdef double x
     873        cdef double min
    968874
    969         cdef double min = glp_get_col_lb(self.lp, index + 1)
    970 
    971         if value is None and min == -DBL_MAX:
    972             glp_set_col_bnds(self.lp, index + 1, GLP_FR, 0, 0)
    973 
    974         elif value is None:
    975             glp_set_col_bnds(self.lp, index + 1, GLP_LO, min, 0)
    976 
    977         elif min == -DBL_MAX:
    978             glp_set_col_bnds(self.lp, index + 1, GLP_UP, 0, value)
    979            
    980         elif min == value:
    981             glp_set_col_bnds(self.lp, index + 1, GLP_FX,  value, value)
     875        if value == False:
     876            x = glp_get_col_ub(self.lp, index +1)
     877            if x == DBL_MAX:
     878                return None
     879            else:
     880                return x
    982881
    983882        else:
    984             glp_set_col_bnds(self.lp, index + 1, GLP_DB, min, value)
     883            min = glp_get_col_lb(self.lp, index + 1)
    985884
    986     cpdef set_variable_min(self, int index, value):
     885            if value is None and min == -DBL_MAX:
     886                glp_set_col_bnds(self.lp, index + 1, GLP_FR, 0, 0)
     887
     888            elif value is None:
     889                glp_set_col_bnds(self.lp, index + 1, GLP_LO, min, 0)
     890
     891            elif min == -DBL_MAX:
     892                glp_set_col_bnds(self.lp, index + 1, GLP_UP, 0, value)
     893           
     894            elif min == value:
     895                glp_set_col_bnds(self.lp, index + 1, GLP_FX,  value, value)
     896
     897            else:
     898                glp_set_col_bnds(self.lp, index + 1, GLP_DB, min, value)
     899
     900
     901    cpdef variable_min(self, int index, value = False):
    987902        r"""
    988         Sets the lower bound on a variable
     903        Returns or defines the lower bound on a variable
    989904
    990905        INPUT:
    991906
    992907        - ``index`` (integer) -- the variable's id
    993908
    994909        - ``value`` -- real value, or ``None`` to mean that the
    995           variable has not lower bound.
     910          variable has not lower bound. When set to ``False``
     911          (default), the method returns the current value.
    996912
    997913        EXAMPLE::
    998914
    999             sage: from sage.numerical.backends.generic_backend import getSolver
    1000             sage: p = getSolver(solver = "GLPK")
     915            sage: from sage.numerical.backends.generic_backend import get_solver
     916            sage: p = get_solver(solver = "GLPK")
    1001917            sage: p.add_variable()
    1002918            1
    1003             sage: p.get_col_bounds(0)
     919            sage: p.col_bounds(0)
    1004920            (0.0, None)
    1005             sage: p.set_variable_min(0, 5)
    1006             sage: p.get_col_bounds(0)
     921            sage: p.variable_min(0, 5)
     922            sage: p.col_bounds(0)
    1007923            (5.0, None)
    1008924        """
    1009    
    1010         cdef double max = glp_get_col_ub(self.lp, index + 1)
     925        cdef double x
     926        cdef double max
    1011927
    1012         if value is None and max == DBL_MAX:
    1013             glp_set_col_bnds(self.lp, index + 1, GLP_FR, 0.0, 0.0)
     928        if value == False:
     929            x = glp_get_col_lb(self.lp, index +1)
     930            if x == -DBL_MAX:
     931                return None
     932            else:
     933                return x
     934        else:
     935            max = glp_get_col_ub(self.lp, index + 1)
    1014936
    1015         elif value is None:
    1016             glp_set_col_bnds(self.lp, index + 1, GLP_UP, 0.0, max)
     937            if value is None and max == DBL_MAX:
     938                glp_set_col_bnds(self.lp, index + 1, GLP_FR, 0.0, 0.0)
    1017939
    1018         elif max == DBL_MAX:
    1019             glp_set_col_bnds(self.lp, index + 1, GLP_LO, value, 0.0)
     940            elif value is None:
     941                glp_set_col_bnds(self.lp, index + 1, GLP_UP, 0.0, max)
     942
     943            elif max == DBL_MAX:
     944                glp_set_col_bnds(self.lp, index + 1, GLP_LO, value, 0.0)
    1020945           
    1021         elif max == value:
    1022             glp_set_col_bnds(self.lp, index + 1, GLP_FX,  value, value)
     946            elif max == value:
     947                glp_set_col_bnds(self.lp, index + 1, GLP_FX,  value, value)
    1023948
    1024         else:
    1025             glp_set_col_bnds(self.lp, index + 1, GLP_DB, value, min)
     949            else:
     950                glp_set_col_bnds(self.lp, index + 1, GLP_DB, value, min)
    1026951
    1027952    cpdef write_lp(self, char * filename):
    1028953        r"""
     
    1034959
    1035960        EXAMPLE::
    1036961
    1037             sage: from sage.numerical.backends.generic_backend import getSolver
    1038             sage: p = getSolver(solver = "GLPK")
     962            sage: from sage.numerical.backends.generic_backend import get_solver
     963            sage: p = get_solver(solver = "GLPK")
    1039964            sage: p.add_variables(2)
    1040965            2
    1041966            sage: p.add_constraint([0, 1], [1, 2], +1, 3)
     
    1054979
    1055980        EXAMPLE::
    1056981
    1057             sage: from sage.numerical.backends.generic_backend import getSolver
    1058             sage: p = getSolver(solver = "GLPK")
     982            sage: from sage.numerical.backends.generic_backend import get_solver
     983            sage: p = get_solver(solver = "GLPK")
    1059984            sage: p.add_variables(2)
    1060985            2
    1061986            sage: p.add_constraint([0, 1], [1, 2], +1, 3)
  • sage/numerical/mip.pyx

    diff -r 0b5f2ba89540 -r f3c711eb0c73 sage/numerical/mip.pyx
    a b  
    171171            sage: p = MixedIntegerLinearProgram(maximization=True)
    172172        """
    173173
    174         from sage.numerical.backends.generic_backend import getSolver
    175         self._backend = getSolver(solver = solver)
     174        from sage.numerical.backends.generic_backend import get_solver
     175        self._backend = get_solver(solver = solver)
     176
    176177        if not maximization:
    177             self._backend.set_direction(-1)
     178            self._backend.set_sense(-1)
    178179
    179180        self.__BINARY = 0
    180181        self.__REAL = -1
     
    204205
    205206         return ("Mixed Integer Program "+
    206207
    207                  ( "\"" +self._backend.get_problem_name()+ "\""
    208                    if (str(self._backend.get_problem_name()) != "") else "")+
     208                 ( "\"" +self._backend.problem_name()+ "\""
     209                   if (str(self._backend.problem_name()) != "") else "")+
    209210
    210211                 " ( " + ("maximization" if b.is_maximization() else "minimization" ) +
    211212
    212                  ", " + str(b.n_cols()) + " variables, " +
    213                  str(b.n_rows()) + " constraints )")
     213                 ", " + str(b.ncols()) + " variables, " +
     214                 str(b.nrows()) + " constraints )")
    214215
    215216    def __getitem__(self, v):
    216217        r"""
     
    254255            Mixed Integer Program "Test program" ( maximization, 0 variables, 0 constraints )
    255256        """
    256257
    257         self._backend.set_problem_name(name)
    258 
    259     def set_objective_name(self,name):
    260         r"""
    261         Sets the name of the objective function.
    262 
    263         INPUT:
    264 
    265         - ``name`` -- A string representing the name of the
    266           objective function.
    267          
    268         EXAMPLE::
    269 
    270             sage: p=MixedIntegerLinearProgram()
    271             sage: p.set_objective_name("Objective function")
    272         """
    273 
    274         self._backend.set_objective_name(name)
     258        self._backend.problem_name(name)
    275259
    276260    def _update_variables_name(self):
    277261        r"""
     
    397381        value+="  "
    398382       
    399383        first = True
    400         for 0<= i< b.n_cols():
     384        for 0<= i< b.ncols():
    401385            c = b.get_objective_coeff(i)
    402386            if c != 0:
    403387
     
    409393        value += "\nConstraints:"
    410394
    411395
    412         for 0<= i < b.n_rows():
     396        for 0<= i < b.nrows():
    413397
    414             indices, values = b.get_row(i)
     398            indices, values = b.row(i)
    415399
    416             lb, ub = b.get_row_bounds(i)
     400            lb, ub = b.row_bounds(i)
    417401
    418402            value += ("\n  "+
    419                       (b.get_row_name(i)+": " if b.get_row_name(i)!="" else "")+
     403                      (b.row_name(i)+": " if b.row_name(i)!="" else "")+
    420404                      (str(lb)+" <= " if lb!=None else "")
    421405                      )
    422406
     
    433417
    434418        value += "\nVariables:"
    435419
    436         for 0<= i < b.n_cols():
     420        for 0<= i < b.ncols():
    437421            value += "\n  " + str(inv_variables[i]) + " is"
    438422
    439423            if b.is_variable_integer(i):
     
    443427            else:
    444428                value += " a real variable"
    445429
    446             lb, ub = b.get_col_bounds(i)
     430            lb, ub = b.col_bounds(i)
    447431
    448432            value += " (min=" + \
    449433                ( str(lb)
     
    644628       
    645629        f.pop(-1,0)
    646630
    647         for i in range(self._backend.n_cols()):
     631        for i in range(self._backend.ncols()):
    648632            values.append(f.get(i,0))
    649633
    650634        self._backend.set_objective(values)
     
    776760                self._backend.add_constraint(indices, values, +1, max)
    777761
    778762            if name != None:
    779                 self._backend.set_row_name(self._backend.n_rows()-1,name)
     763                self._backend.row_name(self._backend.nrows()-1,name)
    780764
    781765        elif isinstance(linear_function,LinearConstraint):
    782766            functions = linear_function.constraints
     
    10671051        if solver != None:
    10681052            raise ValueError("Solver argument deprecated. This parameter now has to be set when calling the class' constructor")
    10691053
    1070         self._backend.set_log_level(log)
     1054        self._backend.set_verbosity(log)
    10711055
    10721056        self._backend.solve()
    10731057
     
    11031087
    11041088        self._variables[v] = len(self._variables)
    11051089        self._backend.add_variable()
    1106         self._backend.set_variable_type(self._backend.n_cols()-1,vtype)
     1090        self._backend.set_variable_type(self._backend.ncols()-1,vtype)
    11071091        return v
    11081092
    11091093    def set_min(self, v, min):
     
    11281112            sage: p.get_min(v[1])
    11291113            6.0
    11301114        """
    1131         self._backend.set_variable_min(self._variables[v], min)
     1115        self._backend.variable_min(self._variables[v], min)
    11321116
    11331117    def set_max(self, v, max):
    11341118        r"""
     
    11521136            6.0
    11531137        """
    11541138
    1155         self._backend.set_variable_max(self._variables[v], max)
     1139        self._backend.variable_max(self._variables[v], max)
    11561140
    11571141    def get_min(self, v):
    11581142        r"""
     
    11791163            6.0
    11801164        """
    11811165
    1182         return self._backend.get_variable_min(self._variables[v])
     1166        return self._backend.variable_min(self._variables[v])
    11831167
    11841168    def get_max(self, v):
    11851169        r"""
     
    12051189            6.0
    12061190        """
    12071191
    1208         return self._backend.get_variable_max(self._variables[v])
     1192        return self._backend.variable_max(self._variables[v])
    12091193
    12101194class MIPSolverException(Exception):
    12111195    r"""
     
    13531337        if self._dim == 1:
    13541338            for (k,v) in self._dict.iteritems():
    13551339                name = prefix + "[" + str(k) + "]"
    1356                 self._p._backend.set_col_name(self._p._variables[v], name)
     1340                self._p._backend.col_name(self._p._variables[v], name)
    13571341                #self._p._variables_name[self._p._variables[v]]=prefix + "[" + str(k) + "]"
    13581342        else:
    13591343            for v in self._dict.itervalues():