rebase and whitespace

Author: mo271

src/sage/geometry/polyhedron/parent.py

@@ -110,9 +110,8 @@ def Polyhedra(base_ring, ambient_dim, backend=None):
             raise ValueError("the 'field' backend for polyhedron can not be used with non-exact fields")
         return Polyhedra_field(base_ring.fraction_field(), ambient_dim)
     else:
-        raise ValueError('No such backend (='+str(backend)+
-                         ') implemented for given basering (='+str(base_ring)+').')
-
+        raise ValueError('No such backend (=' + str(backend) +
+                         ') implemented for given basering (=' + str(base_ring)+').')
 
 
 class Polyhedra_base(UniqueRepresentation, Parent):
@@ -222,14 +221,14 @@ def an_element(self):
             A 4-dimensional polyhedron in QQ^4 defined as the convex hull of 5 vertices
         """
         zero = self.base_ring().zero()
-        one  = self.base_ring().one()
+        one = self.base_ring().one()
         p = [zero] * self.ambient_dim()
         points = [p]
-        for i in range(0,self.ambient_dim()):
+        for i in range(0, self.ambient_dim()):
             p = [zero] * self.ambient_dim()
             p[i] = one
             points.append(p)
-        return self.element_class(self, [points,[],[]], None)
+        return self.element_class(self, [points, [], []], None)
 
     @cached_method
     def some_elements(self):
@@ -251,16 +250,16 @@ def some_elements(self):
         if self.ambient_dim() == 0:
             return [
                 self.element_class(self, None, None),
-                self.element_class(self, None, [[],[]]) ]
+                self.element_class(self, None, [[], []])]
         points = []
         R = self.base_ring()
-        for i in range(0,self.ambient_dim()+5):
-            points.append([R(i*j^2) for j in range(0,self.ambient_dim())])
+        for i in range(0, self.ambient_dim() + 5):
+            points.append([R(i*j^2) for j in range(0, self.ambient_dim())])
         return [
             self.element_class(self, [points[0:self.ambient_dim()+1], [], []], None),
             self.element_class(self, [points[0:1], points[1:self.ambient_dim()+1], []], None),
             self.element_class(self, [points[0:3], points[4:5], []], None),
-            self.element_class(self, None, None) ]
+            self.element_class(self, None, None)]
 
     @cached_method
     def zero(self):
@@ -432,7 +431,7 @@ def _element_constructor_(self, *args, **kwds):
 
             sage: from sage.geometry.polyhedron.parent import Polyhedra
             sage: P = Polyhedra(QQ, 3)
-            sage: P._element_constructor_([[(0,0,0),(1,0,0),(0,1,0),(0,0,1)], [], []], None)
+            sage: P._element_constructor_([[(0, 0, 0), (1, 0, 0), (0, 1, 0), (0,0,1)], [], []], None)
             A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 4 vertices
             sage: P([[(0,0,0),(1,0,0),(0,1,0),(0,0,1)], [], []], None)
             A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 4 vertices
@@ -448,47 +447,49 @@ def _element_constructor_(self, *args, **kwds):
             sage: P = b.interactive_lp_problem()
             sage: p = P.plot()
 
-            sage: Q=Polyhedron(ieqs=[[-499999,1000000],[1499999,-1000000]])
-            sage: P=Polyhedron(ieqs=[[0,1.0],[1.0,-1.0]], base_ring=RDF)
+            sage: Q = Polyhedron(ieqs=[[-499999, 1000000], [1499999, -1000000]])
+            sage: P = Polyhedron(ieqs=[[0, 1.0], [1.0, -1.0]], base_ring=RDF)
             sage: Q.intersection(P)
             A 1-dimensional polyhedron in RDF^1 defined as the convex hull of 2 vertices
             sage: P.intersection(Q)
             A 1-dimensional polyhedron in RDF^1 defined as the convex hull of 2 vertices
         """
         nargs = len(args)
         convert = kwds.pop('convert', True)
+
         def convert_base_ring(lstlst):
-            return [ [self.base_ring()(x) for x in lst] for lst in lstlst]
+            return [[self.base_ring()(x) for x in lst] for lst in lstlst]
+
         # renormalize before converting when going from QQ to RDF, see trac 21270
         def convert_base_ring_Hrep(lstlst):
             newlstlst = []
             for lst in lstlst:
                 if all(c in QQ for c in lst):
-                    m=max(abs(w) for w in lst)
+                    m = max(abs(w) for w in lst)
                     if m == 0:
                         newlstlst.append(lst)
                     else:
                         newlstlst.append([q/m for q in lst])
                 else:
                     newlstlst.append(lst)
             return convert_base_ring(newlstlst)
-        if nargs==2:
+        if nargs == 2:
             Vrep, Hrep = args
             if convert and Hrep:
-                if self.base_ring==RDF:
+                if self.base_ring == RDF:
                     Hrep = [convert_base_ring_Hrep(_) for _ in Hrep]
                 else:
                     Hrep = [convert_base_ring(_) for _ in Hrep]
             if convert and Vrep:
                 Vrep = [convert_base_ring(_) for _ in Vrep]
             return self.element_class(self, Vrep, Hrep, **kwds)
-        if nargs==1 and is_Polyhedron(args[0]):
+        if nargs == 1 and is_Polyhedron(args[0]):
             polyhedron = args[0]
-            Hrep = [ polyhedron.inequality_generator(), polyhedron.equation_generator() ]
-            if self.base_ring()==RDF:
+            Hrep = [polyhedron.inequality_generator(), polyhedron.equation_generator()]
+            if self.base_ring() == RDF:
                 Hrep = [convert_base_ring_Hrep(_) for _ in Hrep]
             return self.element_class(self, None, Hrep, **kwds)
-        if nargs==1 and args[0]==0:
+        if nargs == 1 and args[0] == 0:
             return self.zero()
         raise ValueError('Cannot convert to polyhedron object.')
 
@@ -874,4 +875,3 @@ class Polyhedra_RDF_cdd(Polyhedra_base):
 
 class Polyhedra_field(Polyhedra_base):
     Element = Polyhedron_field
-