Ticket #10151: trac_10151.patch

sage/graphs/digraph.py

@@ -1180 +1180 @@
         
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
         
-        p=MixedIntegerLinearProgram(maximization=False)
+        p=MixedIntegerLinearProgram(maximization=False, solver=solver)
         
         b=p.new_variable()
         x=p.new_variable(dim=2)
@@ -1204 +1204 @@
         p.set_objective(Sum([b[(u,v)] for (u,v) in self.edges(labels=None)]))
 
         if value_only:
-            return p.solve(objective_only=True, solver=solver, log=verbose)
+            return p.solve(objective_only=True, log=verbose)
         else:
-            p.solve(solver=solver, log=verbose)
+            p.solve(log=verbose)
 
             b_sol=p.get_values(b)
 
@@ -1302 +1302 @@
         
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
         
-        p=MixedIntegerLinearProgram(maximization=False)
+        p=MixedIntegerLinearProgram(maximization=False, solver=solver)
         
         b=p.new_variable()
         x=p.new_variable(dim=2)
@@ -1326 +1326 @@
         p.set_objective(Sum([b[v] for v in self]))
 
         if value_only:
-            return p.solve(objective_only=True, solver=solver, log=verbose)
+            return p.solve(objective_only=True, log=verbose)
         else:
-            p.solve(solver=solver, log=verbose)
+            p.solve(log=verbose)
             b_sol=p.get_values(b)
 
             from sage.sets.set import Set

sage/graphs/generic_graph.py

@@ -2243 +2243 @@
 
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
         
-        p = MixedIntegerLinearProgram(maximization=False)
+        p = MixedIntegerLinearProgram(maximization=False, solver=solver)
 
         # The orientation of an edge is boolean
         # and indicates whether the edge uv 
@@ -2264 +2264 @@
 
         p.set_binary(orientation)
 
-        p.solve(solver=solver, log=verbose)
+        p.solve(log=verbose)
 
         orientation = p.get_values(orientation)
 
@@ -3278 +3278 @@
         return B, C
 
 
-    def steiner_tree(self,vertices, weighted = False):
+    def steiner_tree(self,vertices, weighted = False, solver = None, verbose = 0):
         r"""
         Returns a tree of minimum weight connecting the given
         set of vertices.
@@ -3305 +3305 @@
           ``None`` as a weight of `1`. If ``weighted=False`` (default)
           all edges are considered to have a weight of `1`.
 
+        - ``solver`` -- (default: ``None``) Specify a Linear Program (LP)
+          solver to be used. If set to ``None``, the default one is used. For
+          more information on LP solvers and which default solver is used, see
+          the method
+          :meth:`solve <sage.numerical.mip.MixedIntegerLinearProgram.solve>`
+          of the class
+          :class:`MixedIntegerLinearProgram <sage.numerical.mip.MixedIntegerLinearProgram>`.
+
+        - ``verbose`` -- integer (default: ``0``). Sets the level of
+          verbosity. Set to 0 by default, which means quiet.
+
+
         .. NOTE::
 
             * This problem being defined on undirected graphs, the
@@ -3376 +3388 @@
 
         # Then, LP formulation
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
-        p = MixedIntegerLinearProgram(maximization = False)
+        p = MixedIntegerLinearProgram(maximization = False, solver = solver)
 
         # Reorder an edge
         R = lambda (x,y) : (x,y) if x<y else (y,x)
@@ -3419 +3431 @@
         p.set_objective(Sum([w(e)*edges[R(e)] for e in g.edges(labels = False)]))
 
         p.set_binary(edges)            
-        p.solve()
+        p.solve(log = verbose)
 
         edges = p.get_values(edges)
 
@@ -3427 +3439 @@
         st.delete_vertices([v for v in g if st.degree(v) == 0])
         return st
 
-    def edge_disjoint_spanning_trees(self,k, root=None, **kwds):
+    def edge_disjoint_spanning_trees(self,k, root=None, solver = None, verbose = 0):
         r"""
         Returns the desired number of edge-disjoint spanning 
         trees/arborescences.
@@ -3441 +3453 @@
           when the graph is directed.
           If set to ``None``, the first vertex in the graph is picked.
 
-        - ``**kwds`` -- arguments to be passed down to the ``solve``
-          function of ``MixedIntegerLinearProgram``. See the documentation
-          of ``MixedIntegerLinearProgram.solve`` for more informations.
+        - ``solver`` -- (default: ``None``) Specify a Linear Program (LP)
+          solver to be used. If set to ``None``, the default one is used. For
+          more information on LP solvers and which default solver is used, see
+          the method
+          :meth:`solve <sage.numerical.mip.MixedIntegerLinearProgram.solve>`
+          of the class
+          :class:`MixedIntegerLinearProgram <sage.numerical.mip.MixedIntegerLinearProgram>`.
+
+        - ``verbose`` -- integer (default: ``0``). Sets the level of
+          verbosity. Set to 0 by default, which means quiet.
           
         ALGORITHM:
 
@@ -3514 +3533 @@
         """
 
         from sage.numerical.mip import MixedIntegerLinearProgram, MIPSolverException, Sum
-        p = MixedIntegerLinearProgram()
+        p = MixedIntegerLinearProgram(solver = solver)
         p.set_objective(None)
 
         # The colors we can use
@@ -3605 +3624 @@
         p.set_binary(edges)                
 
         try:
-            p.solve(**kwds)
+            p.solve(log = verbose)
 
         except MIPSolverException:
             raise ValueError("This graph does not contain the required number of trees/arborescences !")
@@ -3779 +3798 @@
 
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
         g = self
-        p = MixedIntegerLinearProgram(maximization=False)
+        p = MixedIntegerLinearProgram(maximization=False, solver=solver)
         b = p.new_variable(dim=2)
         v = p.new_variable()
 
@@ -3810 +3829 @@
         p.set_binary(b)
 
         if value_only:
-            return p.solve(objective_only=True, solver=solver, log=verbose)
-        else:
-            obj = p.solve(solver=solver, log=verbose)
+            return p.solve(objective_only=True, log=verbose)
+        else:
+            obj = p.solve(log=verbose)
             b = p.get_values(b)
             answer = [obj]
             if g.is_directed():
@@ -3902 +3921 @@
         if vertices:
             value_only = False
 
-        p = MixedIntegerLinearProgram(maximization=False)
+        p = MixedIntegerLinearProgram(maximization=False, solver=solver)
         b = p.new_variable()
         v = p.new_variable()
 
@@ -3935 +3954 @@
         p.set_binary(v)
 
         if value_only:
-            return p.solve(objective_only=True, solver=solver, log=verbose)
-        else:
-            obj = p.solve(solver=solver, log=verbose)
+            return p.solve(objective_only=True, log=verbose)
+        else:
+            obj = p.solve(log=verbose)
             b = p.get_values(b)
             answer = [obj,[x for x in g if b[x] == 1]]
             if vertices:
@@ -3955 +3974 @@
             return tuple(answer)
 
 
-    def multiway_cut(self, vertices, value_only = False, use_edge_labels = False, **kwds):
+    def multiway_cut(self, vertices, value_only = False, use_edge_labels = False, solver = None, verbose = 0):
         r"""
         Returns a minimum edge multiway cut corresponding to the
         given set of vertices
@@ -3987 +4006 @@
               an edge has no label, `1` is assumed )
 
             - when set to ``False`` (default), each edge has weight `1`.
-            
-        - ``**kwds`` -- arguments to be passed down to the ``solve``  
-          function of ``MixedIntegerLinearProgram``. See the documentation  
-          of ``MixedIntegerLinearProgram.solve`` for more information.
+
+        - ``solver`` -- (default: ``None``) Specify a Linear Program (LP)
+          solver to be used. If set to ``None``, the default one is used. For
+          more information on LP solvers and which default solver is used, see
+          the method
+          :meth:`solve <sage.numerical.mip.MixedIntegerLinearProgram.solve>`
+          of the class
+          :class:`MixedIntegerLinearProgram <sage.numerical.mip.MixedIntegerLinearProgram>`.
+
+        - ``verbose`` -- integer (default: ``0``). Sets the level of
+          verbosity. Set to 0 by default, which means quiet.
     
         EXAMPLES:
 
@@ -4033 +4059 @@
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
         from itertools import combinations, chain
 
-        p = MixedIntegerLinearProgram(maximization = False)
+        p = MixedIntegerLinearProgram(maximization = False, solver= solver)
 
         # height[c][v] represents the height of vertex v for commodity c
         height = p.new_variable(dim = 2)
@@ -4084 +4110 @@
 
         p.set_binary(cut)        
         if value_only:
-            return p.solve(objective_only = True, **kwds)
-
-        p.solve(**kwds)
+            return p.solve(objective_only = True, log = verbose)
+
+        p.solve(log = verbose)
 
         cut = p.get_values(cut)
 
@@ -4179 +4205 @@
 
             from sage.numerical.mip import MixedIntegerLinearProgram, Sum
             g = self
-            p = MixedIntegerLinearProgram(maximization=False)
+            p = MixedIntegerLinearProgram(maximization=False, solver=solver)
             b = p.new_variable()
     
             # minimizes the number of vertices in the set
@@ -4192 +4218 @@
             p.set_binary(b)
     
             if value_only:
-                return p.solve(objective_only=True, solver=solver, log=verbose)
+                return p.solve(objective_only=True, log=verbose)
             else:
-                p.solve(solver=solver, log=verbose)
+                p.solve(log=verbose)
                 b = p.get_values(b)
                 return set([v for v in g.vertices() if b[v] == 1])
         else:
@@ -4279 +4305 @@
 
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
 
-        p = MixedIntegerLinearProgram(maximization=True)
+        p = MixedIntegerLinearProgram(maximization=True, solver=solver)
 
         in_set = p.new_variable(dim=2)
         in_cut = p.new_variable(dim=1)
@@ -4320 +4346 @@
         p.set_objective(Sum([weight(l ) * in_cut[reorder_edge(u,v)] for (u,v,l ) in g.edge_iterator()]))
 
         if value_only:
-            obj = p.solve(objective_only=True, solver=solver, log=verbose)
+            obj = p.solve(objective_only=True, log=verbose)
             return obj if use_edge_labels else round(obj)
         else:
-            obj = p.solve(solver=solver, log=verbose)
+            obj = p.solve(log=verbose)
             val = [obj if use_edge_labels else round(obj)]
 
             in_cut = p.get_values(in_cut)
@@ -4348 +4374 @@
 
             return val
 
-    def traveling_salesman_problem(self, weighted = True):
+    def traveling_salesman_problem(self, weighted = True, solver = None, verbose = 0):
         r"""
         Solves the traveling salesman problem (TSP)
 
@@ -4373 +4399 @@
                 account, and the edges whose weight is ``None``
                 are assumed to be set to `1`
 
+        - ``solver`` -- (default: ``None``) Specify a Linear Program (LP)
+          solver to be used. If set to ``None``, the default one is used. For
+          more information on LP solvers and which default solver is used, see
+          the method
+          :meth:`solve <sage.numerical.mip.MixedIntegerLinearProgram.solve>`
+          of the class
+          :class:`MixedIntegerLinearProgram <sage.numerical.mip.MixedIntegerLinearProgram>`.
+
+        - ``verbose`` -- integer (default: ``0``). Sets the level of
+          verbosity. Set to 0 by default, which means quiet.
+
+
         OUTPUT:
 
         A solution to the TSP, as a ``Graph`` object whose vertex
@@ -4458 +4496 @@
         
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
 
-        p = MixedIntegerLinearProgram(maximization = False)
+        p = MixedIntegerLinearProgram(maximization = False, solver = solver)
 
         f = p.new_variable()
         r = p.new_variable()
@@ -4561 +4599 @@
         from sage.numerical.mip import MIPSolverException
 
         try:
-            obj = p.solve()
+            obj = p.solve(log = verbose)
             f = p.get_values(f)
             tsp.add_vertices(g.vertices())
             tsp.set_pos(g.get_pos())
@@ -4824 +4862 @@
 
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
         g=self
-        p=MixedIntegerLinearProgram(maximization=True)
+        p=MixedIntegerLinearProgram(maximization=True, solver = solver)
         flow=p.new_variable(dim=1)
 
         if use_edge_labels:
@@ -4876 +4914 @@
 
 
         if value_only:
-            return p.solve(objective_only=True)
-
-        obj=p.solve()
+            return p.solve(objective_only=True, log = verbose)
+
+        obj=p.solve(log = verbose)
 
         flow=p.get_values(flow)
         # Builds a clean flow Draph 
@@ -5132 +5170 @@
          
         from sage.numerical.mip import MixedIntegerLinearProgram , Sum
         g=self 
-        p=MixedIntegerLinearProgram(maximization=True) 
+        p=MixedIntegerLinearProgram(maximization=True, solver = solver) 
  
         # Adding the intensity if not present 
         terminals = [(x if len(x) == 3 else (x[0],x[1],1)) for x in terminals] 
@@ -5216 +5254 @@
         from sage.numerical.mip import MIPSolverException 
  
         try: 
-            obj=p.solve() 
+            obj=p.solve(log = verbose) 
         except MIPSolverException: 
             raise ValueError("The multiflow problem has no solution") 
  
@@ -5552 +5590 @@
             g = self
             # returns the weight of an edge considering it may not be
             # weighted ...
-            p = MixedIntegerLinearProgram(maximization=True)
+            p = MixedIntegerLinearProgram(maximization=True, solver=solver)
             b = p.new_variable(dim=2)
             p.set_objective(
                 Sum([weight(w) * b[min(u, v)][max(u, v)]
@@ -5565 +5603 @@
                          for u in g.neighbors(v)]), max=1)
             p.set_binary(b)
             if value_only:
-                return p.solve(objective_only=True, solver=solver, log=verbose)
+                return p.solve(objective_only=True, log=verbose)
             else:
-                p.solve(solver=solver, log=verbose)
+                p.solve(log=verbose)
                 b = p.get_values(b)
                 return [(u, v, w) for u, v, w in g.edges()
                         if b[min(u, v)][max(u, v)] == 1]
@@ -5642 +5680 @@
         """
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
         g=self
-        p=MixedIntegerLinearProgram(maximization=False)
+        p=MixedIntegerLinearProgram(maximization=False, solver=solver)
         b=p.new_variable()
         
         # For any vertex v, one of its neighbors or v itself is in
@@ -5662 +5700 @@
         p.set_integer(b)
 
         if value_only:
-            return p.solve(objective_only=True, solver=solver, log=verbose)
-        else:
-            p.solve(solver=solver, log=verbose)
+            return p.solve(objective_only=True, log=verbose)
+        else:
+            p.solve(log=verbose)
             b=p.get_values(b)
             return [v for v in g.vertices() if b[v]==1]
 
@@ -5812 +5850 @@
 
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
 
-        p = MixedIntegerLinearProgram(maximization=False)
+        p = MixedIntegerLinearProgram(maximization=False, solver=solver)
 
         in_set = p.new_variable(dim=2)
         in_cut = p.new_variable(dim=1)
@@ -5847 +5885 @@
         p.set_objective(Sum([weight(l ) * in_cut[reorder_edge(u,v)] for (u,v,l) in g.edge_iterator()]))
 
         if value_only:
-            obj = p.solve(objective_only=True, solver=solver, log=verbose)
+            obj = p.solve(objective_only=True, log=verbose)
             return obj if use_edge_labels else round(obj)
             
         else:
-            obj = p.solve(solver=solver, log=verbose)
+            obj = p.solve(log=verbose)
             val = [obj if use_edge_labels else round(obj)]
 
             in_cut = p.get_values(in_cut)
@@ -5988 +6026 @@
 
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
 
-        p = MixedIntegerLinearProgram(maximization=False)
+        p = MixedIntegerLinearProgram(maximization=False, solver=solver)
 
         # Sets 0 and 2 are "real" sets while set 1 represents the cut
         in_set = p.new_variable(dim=2)
@@ -6022 +6060 @@
         p.set_objective(Sum([in_set[1][v] for v in g]))
 
         if value_only:
-            return p.solve(objective_only=True, solver=solver, log=verbose)
-        else:
-            val = [int(p.solve(solver=solver, log=verbose))]
+            return p.solve(objective_only=True, log=verbose)
+        else:
+            val = [int(p.solve(log=verbose))]
 
             in_set = p.get_values(in_set)
 
@@ -7815 +7853 @@
 
         return 2*Integer(self.size())/Integer(self.order())
 
-    def maximum_average_degree(self, value_only=True):
+    def maximum_average_degree(self, value_only=True, solver = None, verbose = 0):
         r"""
         Returns the Maximum Average Degree (MAD) of the current graph.
 
@@ -7836 +7874 @@
             - Else, the subgraph of `G` realizing the `MAD`
               is returned.
 
+        - ``solver`` -- (default: ``None``) Specify a Linear Program (LP)
+          solver to be used. If set to ``None``, the default one is used. For
+          more information on LP solvers and which default solver is used, see
+          the method
+          :meth:`solve <sage.numerical.mip.MixedIntegerLinearProgram.solve>`
+          of the class
+          :class:`MixedIntegerLinearProgram <sage.numerical.mip.MixedIntegerLinearProgram>`.
+
+        - ``verbose`` -- integer (default: ``0``). Sets the level of
+          verbosity. Set to 0 by default, which means quiet.
+
         EXAMPLES:
 
         In any graph, the `Mad` is always larger than the average
@@ -7874 +7923 @@
         g = self
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
 
-        p = MixedIntegerLinearProgram(maximization=True)
+        p = MixedIntegerLinearProgram(maximization=True, solver = solver)
 
         d = p.new_variable()
         one = p.new_variable()
@@ -7891 +7940 @@
         
         p.set_objective( Sum([ one[reorder(u,v)] for u,v in g.edge_iterator(labels=False)]) )
 
-        obj = p.solve()
+        obj = p.solve(log = verbose)
         
         # Paying attention to numerical error :
         # The zero values could be something like 0.000000000001

sage/graphs/graph.py

@@ -1910 +1910 @@
 
         from sage.numerical.mip import MixedIntegerLinearProgram, MIPSolverException, Sum
 
-        p = MixedIntegerLinearProgram(maximization=False)
+        p = MixedIntegerLinearProgram(maximization=False, solver=solver)
         b = p.new_variable()
 
         reorder = lambda x,y: (x,y) if x<y else (y,x)
@@ -1937 +1937 @@
         p.set_binary(b)
 
         try:
-            p.solve(solver=solver, log=verbose)
+            p.solve(log=verbose)
             g = self.copy()
             b = p.get_values(b)
             g.delete_edges([(x,y) for x,y,_ in g.edge_iterator() if b[reorder(x,y)] < 0.5])
@@ -2352 +2352 @@
         """
 
         from sage.numerical.mip import MixedIntegerLinearProgram, Sum
-        p=MixedIntegerLinearProgram()
+        p=MixedIntegerLinearProgram(solver=solver)
         
         # Boolean variable indicating whether the vertex
         # is the representative of some set
@@ -2392 +2392 @@
         p.set_binary(classss)
 
         try:
-            p.solve(solver=solver, log=verbose)
+            p.solve(log=verbose)
         except:
             return None
 
@@ -2495 +2495 @@
         """
 
         from sage.numerical.mip import MixedIntegerLinearProgram, MIPSolverException, Sum
-        p = MixedIntegerLinearProgram()
+        p = MixedIntegerLinearProgram(solver=solver)
         
         # sorts an edge
         S = lambda (x,y) : (x,y) if x<y else (y,x)
@@ -2560 +2560 @@
         p.set_objective(None)
 
         try:
-            p.solve(solver=solver, log=verbose)
+            p.solve(log=verbose)
         except MIPSolverException:
             raise ValueError("This graph has no minor isomorphic to H !")
 

sage/graphs/graph_coloring.py

@@ -250 +250 @@
         for C in all_graph_colorings(G,n):
             return n
 
-def vertex_coloring(g, k=None, value_only=False, hex_colors=False, log=0):
+def vertex_coloring(g, k=None, value_only=False, hex_colors=False, solver = None, verbose = 0):
     r"""
     Computes the chromatic number of the given graph or tests its
     `k`-colorability. See http://en.wikipedia.org/wiki/Graph_coloring for
@@ -275 +275 @@
       partition returned is a dictionary whose keys are colors and whose
       values are the color classes (ideal for plotting).
 
-    - ``log`` -- (default: ``0``) as vertex-coloring is an `NP`-complete
-      problem, this function may take some time depending on the graph.
-      Use ``log`` to define the level of verbosity you want from the
-      linear program solver. By default ``log=0``, meaning that there will
-      be no message printed by the solver.
+    - ``solver`` -- (default: ``None``) Specify a Linear Program (LP)
+      solver to be used. If set to ``None``, the default one is
+      used. For more information on LP solvers and which default
+      solver is used, see the method :meth:`solve
+      <sage.numerical.mip.MixedIntegerLinearProgram.solve>` of the
+      class :class:`MixedIntegerLinearProgram
+      <sage.numerical.mip.MixedIntegerLinearProgram>`.
+
+    - ``verbose`` -- integer (default: ``0``). Sets the level of
+       verbosity. Set to 0 by default, which means quiet.
+
 
     OUTPUT:
 
@@ -331 +337 @@
         while True:
             # tries to color the graph, increasing k each time it fails.
             tmp = vertex_coloring(g, k=k, value_only=value_only,
-                                  hex_colors=hex_colors, log=log)
+                                  hex_colors=hex_colors, verbose=verbose)
             if tmp is not False:
                 if value_only:
                     return k
@@ -359 +365 @@
                     tmp = vertex_coloring(g.subgraph(component), k=k,
                                           value_only=value_only,
                                           hex_colors=hex_colors,
-                                          log=log)
+                                          verbose=verbose)
                     if tmp is False:
                         return False
                 return True
@@ -367 +373 @@
             for component in g.connected_components():
                 tmp = vertex_coloring(g.subgraph(component), k=k,
                                       value_only=value_only,
-                                      hex_colors=False, log=log)
+                                      hex_colors=False, verbose=verbose)
                 if tmp is False:
                     return False
                 colorings.append(tmp)
@@ -398 +404 @@
                 return vertex_coloring(g.subgraph(list(vertices)), k=k,
                                        value_only=value_only,
                                        hex_colors=hex_colors,
-                                       log=log)
+                                       verbose=verbose)
             value = vertex_coloring(g.subgraph(list(vertices)), k=k,
                                     value_only=value_only,
                                     hex_colors=False,
-                                    log=log)
+                                    verbose=verbose)
             if value is False:
                 return False
             while len(deg) > 0:
@@ -416 +422 @@
             else:
                 return value
 
-        p = MixedIntegerLinearProgram(maximization=True)
+        p = MixedIntegerLinearProgram(maximization=True, solver = solver)
         color = p.new_variable(dim=2)
         # a vertex has exactly one color
         [p.add_constraint(Sum([color[v][i] for i in xrange(k)]), min=1, max=1)
@@ -432 +438 @@
         from sage.numerical.mip import MIPSolverException
         try:
             if value_only:
-                p.solve(objective_only=True, log=log)
+                p.solve(objective_only=True, log=verbose)
                 return True
             else:
-                chi = p.solve(log=log)
+                chi = p.solve(log=verbose)
         except MIPSolverException:
             return False
 
@@ -534 +540 @@
     from sage.numerical.mip import MixedIntegerLinearProgram
     from sage.numerical.mip import MIPSolverException, Sum
 
-    p = MixedIntegerLinearProgram()
+    p = MixedIntegerLinearProgram(solver = solver)
 
     # List of colors
     classes = range(k)
@@ -581 +587 @@
     p.set_objective( Sum( is_used[i] for i in classes ) )
     
     try:
-        obj = p.solve(solver = solver, log = verbose, objective_only = value_only)
+        obj = p.solve(log = verbose, objective_only = value_only)
         from sage.rings.integer import Integer
         obj = Integer(obj)
 
@@ -720 +726 @@
         k = m
 
     
-    p = MixedIntegerLinearProgram()
+    p = MixedIntegerLinearProgram(solver = solver)
 
     # List of possible colors
     classes = range(k)
@@ -786 +792 @@
   
 
     try:
-        obj = p.solve(solver = solver, log = verbose, objective_only = value_only)
+        obj = p.solve(log = verbose, objective_only = value_only)
         from sage.rings.integer import Integer
         obj = Integer(obj)
 
@@ -810 +816 @@
 
     return obj, coloring
 
-def edge_coloring(g, value_only=False, vizing=False, hex_colors=False, log=0):
+def edge_coloring(g, value_only=False, vizing=False, hex_colors=False, solver = None,verbose = 0):
     r"""
     Properly colors the edges of a graph. See the URL
     http://en.wikipedia.org/wiki/Edge_coloring for further details on
@@ -841 +847 @@
       partition returned is a dictionary whose keys are colors and whose
       values are the color classes (ideal for plotting).
 
-    - ``log`` -- (default: ``0``) as edge-coloring is an `NP`-complete
-      problem, this function may take some time depending on the graph. Use
-      ``log`` to define the level of verbosity you wantfrom the linear
-      program solver. By default ``log=0``, meaning that there will be no
-      message printed by the solver.
+    - ``solver`` -- (default: ``None``) Specify a Linear Program (LP)
+      solver to be used. If set to ``None``, the default one is
+      used. For more information on LP solvers and which default
+      solver is used, see the method :meth:`solve
+      <sage.numerical.mip.MixedIntegerLinearProgram.solve>` of the
+      class :class:`MixedIntegerLinearProgram
+      <sage.numerical.mip.MixedIntegerLinearProgram>`.
+
+    - ``verbose`` -- integer (default: ``0``). Sets the level of
+       verbosity. Set to 0 by default, which means quiet.
 
     OUTPUT:
 
@@ -908 +919 @@
     if value_only and g.is_overfull():
         return max(g.degree())+1
 
-    p = MixedIntegerLinearProgram(maximization=True)
+    p = MixedIntegerLinearProgram(maximization=True, solver = solver)
     color = p.new_variable(dim=2)
     obj = {}
     k = max(g.degree())
@@ -932 +943 @@
     p.set_binary(color)
     try:
         if value_only:
-            p.solve(objective_only=True, log=log)
+            p.solve(objective_only=True, log=verbose)
         else:
-            chi = p.solve(log=log)
+            chi = p.solve(log=verbose)
     except MIPSolverException:
         if value_only:
             return k + 1
         else:
             # if the coloring with Delta colors fails, tries Delta + 1
-            return edge_coloring(g, vizing=True, hex_colors=hex_colors, log=log)
+            return edge_coloring(g, 
+                                 vizing=True, 
+                                 hex_colors=hex_colors, 
+                                 verbose=verbose, 
+                                 solver = solver)
     if value_only:
         return k
     # Builds the color classes
@@ -1023 +1038 @@
         g.delete_vertex(n)
         return g
 
-def linear_arboricity(g, hex_colors=False, value_only=False, k=1, **kwds):
+def linear_arboricity(g, k=1, hex_colors=False, value_only=False, solver = None, verbose = 0):
     r"""
     Computes the linear arboricity of the given graph.
 
@@ -1070 +1085 @@
         - If ``k=None``, computes a decomposition using the
           least possible number of colors.
 
-    - ``**kwds`` -- arguments to be passed down to the ``solve`` 
-      function of ``MixedIntegerLinearProgram``. See the documentation 
-      of ``MixedIntegerLinearProgram.solve`` for more informations. 
+    - ``solver`` -- (default: ``None``) Specify a Linear Program (LP)
+      solver to be used. If set to ``None``, the default one is
+      used. For more information on LP solvers and which default
+      solver is used, see the method :meth:`solve
+      <sage.numerical.mip.MixedIntegerLinearProgram.solve>` of the
+      class :class:`MixedIntegerLinearProgram
+      <sage.numerical.mip.MixedIntegerLinearProgram>`.
+
+    - ``verbose`` -- integer (default: ``0``). Sets the level of
+       verbosity. Set to 0 by default, which means quiet.
 
     ALGORITHM:
 
@@ -1119 +1141 @@
 
     if k is None:
         try:
-            return linear_arboricity(g, value_only = value_only,hex_colors = hex_colors, k = (Integer(max(g.degree()))/2).ceil() )
+            return linear_arboricity(g, 
+                                     k = (Integer(max(g.degree()))/2).ceil(),
+                                     value_only = value_only,
+                                     hex_colors = hex_colors, 
+                                     solver = solver,
+                                     verbose = verbose)
         except ValueError:
-            return linear_arboricity(g, value_only = value_only,hex_colors = hex_colors, k = 0)
+            return linear_arboricity(g, 
+                                     k = 0,
+                                     value_only = value_only,
+                                     hex_colors = hex_colors, 
+                                     solver = solver,
+                                     verbose = verbose)
     elif k==1:
         k = (Integer(1+max(g.degree()))/2).ceil()
     elif k==0:
@@ -1130 +1162 @@
     from sage.numerical.mip import MixedIntegerLinearProgram, MIPSolverException, Sum
     from sage.plot.colors import rainbow
 
-    p = MixedIntegerLinearProgram()
+    p = MixedIntegerLinearProgram(solver = solver)
 
 
     # c is a boolean value such that c[i][(u,v)] = 1 if and only if (u,v) is colored with i
@@ -1167 +1199 @@
 
     try:
         if value_only:
-            return p.solve(objective_only = True)
+            return p.solve(objective_only = True, log = verbose)
         else:
-            p.solve()
+            p.solve(log = verbose)
 
     except MIPSolverException:
         if k == (Integer(max(g.degree()))/2).ceil():
@@ -1198 +1230 @@
     else:
         return answer
 
-def acyclic_edge_coloring(g, hex_colors=False, value_only=False, k=0, **kwds):
+def acyclic_edge_coloring(g, hex_colors=False, value_only=False, k=0, solver = None, verbose = 0):
     r"""
     Computes an acyclic edge coloring of the current graph.
 
@@ -1252 +1284 @@
         - If ``k=None``, computes a decomposition using the
           least possible number of colors.
 
-    - ``**kwds`` -- arguments to be passed down to the ``solve`` 
-      function of ``MixedIntegerLinearProgram``. See the documentation 
-      of ``MixedIntegerLinearProgram.solve`` for more informations. 
+    - ``solver`` -- (default: ``None``) Specify a Linear Program (LP)
+      solver to be used. If set to ``None``, the default one is
+      used. For more information on LP solvers and which default
+      solver is used, see the method :meth:`solve
+      <sage.numerical.mip.MixedIntegerLinearProgram.solve>` of the
+      class :class:`MixedIntegerLinearProgram
+      <sage.numerical.mip.MixedIntegerLinearProgram>`.
+
+    - ``verbose`` -- integer (default: ``0``). Sets the level of
+       verbosity. Set to 0 by default, which means quiet.
 
     ALGORITHM:
 
@@ -1311 +1350 @@
 
         while True:
             try:
-                return acyclic_edge_coloring(g, value_only = value_only,hex_colors = hex_colors, k = k)
+                return acyclic_edge_coloring(g, 
+                                             value_only = value_only,
+                                             hex_colors = hex_colors, 
+                                             k = k,
+                                             solver = solver,
+                                             verbose = verbose)
             except ValueError:
                 k = k+1
 
@@ -1323 +1367 @@
     from sage.numerical.mip import MixedIntegerLinearProgram, MIPSolverException, Sum
     from sage.plot.colors import rainbow
 
-    p = MixedIntegerLinearProgram()
+    p = MixedIntegerLinearProgram(solver = solver)
 
     # c is a boolean value such that c[i][(u,v)] = 1 if and only if (u,v) is colored with i
     c = p.new_variable(dim=2)
@@ -1360 +1404 @@
 
     try:
         if value_only:
-            return p.solve(objective_only = True, **kwds)
+            return p.solve(objective_only = True, log = verbose)
         else:
-            p.solve(**kwds)
+            p.solve(log = verbose)
 
     except MIPSolverException:
         if k == max(g.degree()) + 2:

sage/numerical/all.py

@@ -2 +2 @@
                       find_minimum_on_interval,minimize,minimize_constrained,
                       linear_program, find_fit) 
 from sage.numerical.mip import MixedIntegerLinearProgram
+from sage.numerical.backends.generic_backend import default_mip_solver

sage/numerical/backends/generic_backend.pyx

@@ -783 +783 @@
 
         raise NotImplementedError()
     
+default_solver = None
+
+def default_mip_solver(solver = None):
+    r"""
+    Returns/Sets the default MILP Solver used by Sage
+
+    INPUT:
+
+    - ``solver`` -- defines the solver to use:
+    
+        - GLPK (``solver="GLPK"``). See the `GLPK
+          <http://www.gnu.org/software/glpk/>`_ web site.
+
+        - COIN Branch and Cut (``solver="Coin"``). See the `COIN-OR
+          <http://www.coin-or.org>`_ web site.
+
+        - CPLEX (``solver="CPLEX"``). See the
+          `CPLEX <http://www.ilog.com/products/cplex/>`_ web site.
+          An interface to CPLEX is not yet implemented.
+
+        ``solver`` should then be equal to one of ``"GLPK"``,
+        ``"Coin"``, ``"CPLEX"``.
+
+        - If ``solver=None`` (default), the current default solver's name is
+          returned.
+
+    OUTPUT:
+
+    This function returns the current default solver's name if ``solver = None``
+    (default). Otherwise, it sets the default solver to the one given. If this
+    solver does not exist, or is not available, a ``ValueError`` exception is
+    raised.
+
+    EXAMPLE::
+
+        sage: former_solver = default_mip_solver()
+        sage: default_mip_solver("GLPK")
+        sage: default_mip_solver()
+        'GLPK'
+        sage: default_mip_solver("Yeahhhhhhhhhhh")
+        Traceback (most recent call last):
+        ...
+        ValueError: 'solver' should be set to 'GLPK', 'Coin', 'CPLEX' or None.
+        sage: default_mip_solver(former_solver)
+    """
+    global default_solver
+
+    if solver is None:
+
+        if default_solver is not None:
+            return default_solver
+
+        else:
+            for s in ["CPLEX", "Coin", "GLPK"]:
+                try:
+                    default_mip_solver(s)
+                    return s
+                except ValueError:
+                    pass
+
+    elif solver == "CPLEX":
+        try:
+            from sage.numerical.backends.cplex_backend import CPLEXBackend
+            default_solver = solver
+        except ImportError:
+            raise ValueError("CPLEX is not available. Please refer to the documentation to install it.")
+
+    elif solver == "Coin":
+        try:
+            from sage.numerical.backends.coin_backend import CoinBackend
+            default_solver = solver
+        except ImportError:
+            raise ValueError("COIN is not available. Please refer to the documentation to install it.")
+
+    elif solver == "GLPK":
+        default_solver = solver
+
+    else:
+        raise ValueError("'solver' should be set to 'GLPK', 'Coin', 'CPLEX' or None.")
 
 cpdef GenericBackend get_solver(constraint_generation = False, solver = None):
     r"""
@@ -802 +881 @@
           `CPLEX <http://www.ilog.com/products/cplex/>`_ web site.
           An interface to CPLEX is not yet implemented.
 
-        ``solver`` should then be equal to one of ``"GLPK"``,
-        ``"Coin"``, ``"CPLEX"``, or ``None``. If ``solver=None``
-        (default), the solvers are tried in this order :
-    
-            * CPLEX
-            * Coin
-            * GLPK
-
-        A backend corresponding to the first solver available is then
-        returned
+        ``solver`` should then be equal to one of ``"GLPK"``, ``"Coin"``,
+        ``"CPLEX"``, or ``None``. If ``solver=None`` (default), the default
+        solver is used (see ``default_mip_solver`` method.
 
     - ``constraint_generation`` (boolean) -- whether the solver
       returned is to be used for constraint/variable generation. As
@@ -820 +892 @@
       ensures that the backend to Coin is not returned when ``solver =
       None``. This is set to ``False`` by default.
 
+    .. SEEALSO::
+
+    - :func:`default_mip_solver` -- Returns/Sets the default MIP solver.
+
     EXAMPLE::
 
         sage: from sage.numerical.backends.generic_backend import get_solver
         sage: p = get_solver()
-
     """
 
     if solver is None:
+        solver = default_mip_solver()
+        
+        # We do not want to use Coin for constraint_generation. It just does not
+        # work with it.
+        if solver == "Coin" and constraint_generation:
+            solver = "GLPK"
 
-        try:
-            from sage.numerical.backends.cplex_backend import CPLEXBackend
-            return CPLEXBackend()
-        except ImportError:
-            pass
-
-        try:
-            if not constraint_generation:
-                from sage.numerical.backends.coin_backend import CoinBackend
-                return CoinBackend()
-        except ImportError:
-            pass
-        
-        from sage.numerical.backends.glpk_backend import GLPKBackend
-        return GLPKBackend()
-
-    elif solver == "Coin":
+    if solver == "Coin":
         from sage.numerical.backends.coin_backend import CoinBackend
         return CoinBackend()
 

sage/numerical/mip.pyx

@@ -92 +92 @@
 cdef class MixedIntegerLinearProgram:
     r"""
     The ``MixedIntegerLinearProgram`` class is the link between Sage, linear
-    programming (LP) and  mixed integer programming (MIP) solvers. See the
-    Wikipedia article on
-    `linear programming <http://en.wikipedia.org/wiki/Linear_programming>`_
-    for further information. A mixed integer program consists of variables,
-    linear constraints on these variables, and an objective function which is
-    to be maximised or minimised under these constraints. An instance of
-    ``MixedIntegerLinearProgram`` also requires the information on the
-    direction of the optimization.
+    programming (LP) and mixed integer programming (MIP) solvers.
 
-    A ``MixedIntegerLinearProgram`` (or ``LP``) is defined as a maximization
-    if ``maximization=True`` and is a minimization if ``maximization=False``.
+    See the Wikipedia article on `linear programming
+    <http://en.wikipedia.org/wiki/Linear_programming>`_ for further information.
+
+    A mixed integer program consists of variables, linear constraints on these
+    variables, and an objective function which is to be maximised or minimised
+    under these constraints. An instance of ``MixedIntegerLinearProgram`` also
+    requires the information on the direction of the optimization.
 
     INPUT:
 
+    - ``solver`` -- 3 solvers should be available through this class:
+
+      - GLPK (``solver="GLPK"``). See the `GLPK
+        <http://www.gnu.org/software/glpk/>`_ web site.
+
+      - COIN Branch and Cut (``solver="Coin"``). See the `COIN-OR
+        <http://www.coin-or.org>`_ web site.
+
+      - CPLEX (``solver="CPLEX"``). See the `CPLEX
+        <http://www.ilog.com/products/cplex/>`_ web site.  An interface to
+        CPLEX is not yet implemented.
+
+        ``solver`` should then be equal to one of ``"GLPK"``, ``"Coin"``,
+        ``"CPLEX"``, or ``None``. 
+
+      - If ``solver=None`` (default), the default solver is used (see
+        ``default_mip_solver`` method.
+
     - ``maximization``
 
-      - When set to ``True`` (default), the ``MixedIntegerLinearProgram`` is
-        defined as a maximization.
-      - When set to ``False``, the ``MixedIntegerLinearProgram`` is defined as
-        a minimization.
+      - When set to ``True`` (default), the ``MixedIntegerLinearProgram``
+        is defined as a maximization.
+
+      - When set to ``False``, the ``MixedIntegerLinearProgram`` is
+        defined as a minimization.
+
+    .. SEEALSO::
+
+     - :func:`default_mip_solver` -- Returns/Sets the default MIP solver.
 
     EXAMPLES:
 
@@ -136 +157 @@
 
         - ``solver`` -- 3 solvers should be available through this class:
 
-          - GLPK (``solver="GLPK"``). See the
-            `GLPK <http://www.gnu.org/software/glpk/>`_ web site.
+          - GLPK (``solver="GLPK"``). See the `GLPK
+            <http://www.gnu.org/software/glpk/>`_ web site.
 
-          - COIN Branch and Cut  (``solver="Coin"``). See the
-            `COIN-OR <http://www.coin-or.org>`_ web site.
+          - COIN Branch and Cut (``solver="Coin"``). See the `COIN-OR
+            <http://www.coin-or.org>`_ web site.
 
-          - CPLEX (``solver="CPLEX"``). See the
-            `CPLEX <http://www.ilog.com/products/cplex/>`_ web site.
-            An interface to CPLEX is not yet implemented.
+          - CPLEX (``solver="CPLEX"``). See the `CPLEX
+            <http://www.ilog.com/products/cplex/>`_ web site.  An interface to
+            CPLEX is not yet implemented.
 
-            ``solver`` should then be equal to one of ``"GLPK"``,
-            ``"Coin"``, ``"CPLEX"``, or ``None``. If ``solver=None``
-            (default), the solvers are tried in this order :
-        
-                * CPLEX
-                * Coin
-                * GLPK
-    
-            A backend corresponding to the first solver available is
-            then returned
-
-
+            ``solver`` should then be equal to one of ``"GLPK"``, ``"Coin"``,
+            ``"CPLEX"``, or ``None``. If ``solver=None`` (default), the default
+            solver is used (see ``default_mip_solver`` method.
 
         - ``maximization``
 
@@ -166 +178 @@
           - When set to ``False``, the ``MixedIntegerLinearProgram`` is
             defined as a minimization.
 
+        .. SEEALSO::
+
+        - :meth:`default_mip_solver` -- Returns/Sets the default MIP solver.
+
+
         EXAMPLE::
 
             sage: p = MixedIntegerLinearProgram(maximization=True)