[Scipy-svn] r4618 - in trunk/scipy: . cluster integrate interpolate interpolate/tests io/tests ndimage ndimage/tests optimize sandbox/exmplpackage/benchmarks sandbox/mkufunc sandbox/mkufunc/examples sandbox/mkufunc/mkufunc signal signal/tests sparse sparse/linalg/eigen/lobpcg sparse/linalg/isolve sparse/sparsetools sparse/tests special/tests stats

scipy-svn@scip... scipy-svn@scip...
Fri Aug 8 01:17:51 CDT 2008


Author: jarrod.millman
Date: 2008-08-08 01:17:26 -0500 (Fri, 08 Aug 2008)
New Revision: 4618

Modified:
   trunk/scipy/__init__.py
   trunk/scipy/cluster/distance.py
   trunk/scipy/cluster/info.py
   trunk/scipy/integrate/odepack.py
   trunk/scipy/interpolate/fitpack.py
   trunk/scipy/interpolate/fitpack2.py
   trunk/scipy/interpolate/info.py
   trunk/scipy/interpolate/interpolate.py
   trunk/scipy/interpolate/polyint.py
   trunk/scipy/interpolate/tests/test_fitpack.py
   trunk/scipy/interpolate/tests/test_interpolate.py
   trunk/scipy/interpolate/tests/test_polyint.py
   trunk/scipy/io/tests/test_mmio.py
   trunk/scipy/ndimage/_registration.py
   trunk/scipy/ndimage/tests/test_registration.py
   trunk/scipy/ndimage/tests/test_regression.py
   trunk/scipy/optimize/minpack.py
   trunk/scipy/sandbox/exmplpackage/benchmarks/bench_foo.py
   trunk/scipy/sandbox/mkufunc/examples/benchmark.py
   trunk/scipy/sandbox/mkufunc/examples/mandel_c.py
   trunk/scipy/sandbox/mkufunc/examples/mandel_mkImage.py
   trunk/scipy/sandbox/mkufunc/examples/mandel_py.py
   trunk/scipy/sandbox/mkufunc/examples/primes.py
   trunk/scipy/sandbox/mkufunc/mkufunc/api.py
   trunk/scipy/sandbox/mkufunc/mkufunc/driver.py
   trunk/scipy/sandbox/mkufunc/mkufunc/interactive.py
   trunk/scipy/sandbox/mkufunc/mkufunc/test_func_hash.py
   trunk/scipy/sandbox/mkufunc/mkufunc/test_mkufunc.py
   trunk/scipy/sandbox/mkufunc/setup.py
   trunk/scipy/signal/signaltools.py
   trunk/scipy/signal/tests/test_signaltools.py
   trunk/scipy/sparse/base.py
   trunk/scipy/sparse/bsr.py
   trunk/scipy/sparse/compressed.py
   trunk/scipy/sparse/construct.py
   trunk/scipy/sparse/coo.py
   trunk/scipy/sparse/data.py
   trunk/scipy/sparse/dia.py
   trunk/scipy/sparse/extract.py
   trunk/scipy/sparse/lil.py
   trunk/scipy/sparse/linalg/eigen/lobpcg/lobpcg.py
   trunk/scipy/sparse/linalg/isolve/utils.py
   trunk/scipy/sparse/sparsetools/bsr.py
   trunk/scipy/sparse/sparsetools/coo.py
   trunk/scipy/sparse/sparsetools/csc.py
   trunk/scipy/sparse/sparsetools/csr.py
   trunk/scipy/sparse/sparsetools/dia.py
   trunk/scipy/sparse/tests/test_base.py
   trunk/scipy/special/tests/test_basic.py
   trunk/scipy/stats/mstats.py
Log:
ran reindent


Modified: trunk/scipy/__init__.py
===================================================================
--- trunk/scipy/__init__.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/__init__.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -63,7 +63,7 @@
 pkgload = PackageLoader()
 pkgload(verbose=SCIPY_IMPORT_VERBOSE,postpone=True)
 
-# Remove subpackage names from __all__ such that they are not imported via 
+# Remove subpackage names from __all__ such that they are not imported via
 # "from scipy import *". This works around a numpy bug present in < 1.2.
 subpackages = """cluster constants fftpack integrate interpolate io lib linalg
 linsolve maxentropy misc ndimage odr optimize sandbox signal sparse special

Modified: trunk/scipy/cluster/distance.py
===================================================================
--- trunk/scipy/cluster/distance.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/cluster/distance.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -179,7 +179,7 @@
     u = np.asarray(u)
     v = np.asarray(v)
     return (np.double(np.bitwise_and((u != v),
-                     np.bitwise_or(u != 0, v != 0)).sum()) 
+                     np.bitwise_or(u != 0, v != 0)).sum())
             /  np.double(np.bitwise_or(u != 0, v != 0).sum()))
 
 def kulsinski(u, v):
@@ -281,7 +281,7 @@
 def _nbool_correspond_all(u, v):
     if u.dtype != v.dtype:
         raise TypeError("Arrays being compared must be of the same data type.")
-    
+
     if u.dtype == np.int or u.dtype == np.float_ or u.dtype == np.double:
         not_u = 1.0 - u
         not_v = 1.0 - v

Modified: trunk/scipy/cluster/info.py
===================================================================
--- trunk/scipy/cluster/info.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/cluster/info.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -3,17 +3,17 @@
 ============================
 
     Clustering algorithms are useful in information theory, target detection,
-    communications, compression, and other areas. The vq module only 
-    supports vector quantization and the k-means algorithms. Development 
+    communications, compression, and other areas. The vq module only
+    supports vector quantization and the k-means algorithms. Development
     of self-organizing maps (SOM) and other approaches is underway.
 
 Hierarchical Clustering
 =======================
 
-    The hierarchy module provides functions for hierarchical and agglomerative 
-    clustering. Its features include generating hierarchical clusters from 
-    distance matrices, computing distance matrices from observation vectors, 
-    calculating statistics on clusters, cutting linkages to generate flat 
+    The hierarchy module provides functions for hierarchical and agglomerative
+    clustering. Its features include generating hierarchical clusters from
+    distance matrices, computing distance matrices from observation vectors,
+    calculating statistics on clusters, cutting linkages to generate flat
     clusters, and visualizing clusters with dendrograms.
 
 Distance Computation

Modified: trunk/scipy/integrate/odepack.py
===================================================================
--- trunk/scipy/integrate/odepack.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/integrate/odepack.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -28,7 +28,7 @@
 
     Solves the initial value problem for stiff or non-stiff systems
     of first order ode-s::
-    
+
         dy/dt = func(y,t0,...)
 
     where y can be a vector.
@@ -59,10 +59,10 @@
     y : array, shape (len(y0), len(t))
         Array containing the value of y for each desired time in t,
         with the initial value y0 in the first row.
-    
+
     infodict : dict, only returned if full_output == True
         Dictionary containing additional output information
-        
+
         =======  ============================================================
         key      meaning
         =======  ============================================================
@@ -85,7 +85,7 @@
         'mused'  a vector of method indicators for each successful time step:
                  1: adams (nonstiff), 2: bdf (stiff)
         =======  ============================================================
-    
+
     Other Parameters
     ----------------
     ml, mu : integer
@@ -100,7 +100,7 @@
         The input parameters rtol and atol determine the error
         control performed by the solver.  The solver will control the
         vector, e, of estimated local errors in y, according to an
-        inequality of the form::         
+        inequality of the form::
             max-norm of (e / ewt) <= 1
         where ewt is a vector of positive error weights computed as::
             ewt = rtol * abs(y) + atol
@@ -130,7 +130,7 @@
     --------
     ode : a more object-oriented integrator based on VODE
     quad : for finding the area under a curve
-    
+
     """
 
     if ml is None:

Modified: trunk/scipy/interpolate/fitpack.py
===================================================================
--- trunk/scipy/interpolate/fitpack.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/interpolate/fitpack.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -702,7 +702,7 @@
       splprep, splrep, splint, sproot, splev - evaluation, roots, integral
       UnivariateSpline, BivariateSpline - an alternative wrapping
               of the FITPACK functions
-    
+
     Notes:
     Based on algorithms from:
        Dierckx P. : An algorithm for surface fitting with spline functions
@@ -844,7 +844,7 @@
 
 def dblint(xa,xb,ya,yb,tck):
     """Evaluate the integral of a spline over area [xa,xb] x [ya,yb].
-    
+
     Parameters
     ----------
     xa, xb : float
@@ -892,7 +892,7 @@
         In case of a periodic spline (per != 0) there must be
            either at least k interior knots t(j) satisfying t(k+1)<t(j)<=x
            or at least k interior knots t(j) satisfying x<=t(j)<t(n-k).
-    
+
     Notes:
     Based on algorithms from:
         Boehm W : Inserting new knots into b-spline curves. Computer Aided

Modified: trunk/scipy/interpolate/fitpack2.py
===================================================================
--- trunk/scipy/interpolate/fitpack2.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/interpolate/fitpack2.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -352,23 +352,23 @@
             assert ier==0,'Invalid input: ier='+`ier`
             return z
         raise NotImplementedError
-    
+
     def integral(self, xa, xb, ya, yb):
         """
         Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
-        
+
         Parameters
         ----------
         xa, xb : float
             The end-points of the x integration interval.
         ya, yb : float
             The end-points of the y integration interval.
-        
+
         Returns
         -------
         integ : float
             The value of the resulting integral.
-        
+
         """
         tx,ty,c = self.tck[:3]
         kx,ky = self.degrees

Modified: trunk/scipy/interpolate/info.py
===================================================================
--- trunk/scipy/interpolate/info.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/interpolate/info.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -28,14 +28,14 @@
 
   interp1d -- Create a class whose instances can linearly interpolate
                to compute unknown values of a univariate function.
-  BarycentricInterpolator -- Compute with a numerically-stable version 
+  BarycentricInterpolator -- Compute with a numerically-stable version
                of the Lagrange interpolating polynomial.
   barycentric_interpolate -- procedural interface to the above
   KroghInterpolator -- Compute with the Hermite interpolating polynomial
                (allows the specification of derivatives at some points).
   krogh_interpolate -- procedural interface to the above
   PiecewisePolynomial -- Spline that is specified by giving positions and
-               derivatives at every knot; allows high orders and 
+               derivatives at every knot; allows high orders and
                efficient appending.
   piecewise_polynomial_interpolate -- procedural interface to the above
 

Modified: trunk/scipy/interpolate/interpolate.py
===================================================================
--- trunk/scipy/interpolate/interpolate.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/interpolate/interpolate.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -328,7 +328,7 @@
             axes = range(nx, ny)
             axes[self.axis:self.axis] = range(nx)
             return y_new.transpose(axes)
-    
+
     def _check_bounds(self, x_new):
         """ Check the inputs for being in the bounds of the interpolated data.
 

Modified: trunk/scipy/interpolate/polyint.py
===================================================================
--- trunk/scipy/interpolate/polyint.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/interpolate/polyint.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -7,44 +7,44 @@
 class KroghInterpolator(object):
     """The interpolating polynomial for a set of points
 
-    Constructs a polynomial that passes through a given set of points,         
+    Constructs a polynomial that passes through a given set of points,
     optionally with specified derivatives at those points.
     Allows evaluation of the polynomial and all its derivatives.
     For reasons of numerical stability, this function does not compute
     the coefficients of the polynomial, although they can be obtained
     by evaluating all the derivatives.
 
-    Be aware that the algorithms implemented here are not necessarily 
-    the most numerically stable known. Moreover, even in a world of 
-    exact computation, unless the x coordinates are chosen very 
-    carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice - 
-    polynomial interpolation itself is a very ill-conditioned process 
-    due to the Runge phenomenon. In general, even with well-chosen 
+    Be aware that the algorithms implemented here are not necessarily
+    the most numerically stable known. Moreover, even in a world of
+    exact computation, unless the x coordinates are chosen very
+    carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice -
+    polynomial interpolation itself is a very ill-conditioned process
+    due to the Runge phenomenon. In general, even with well-chosen
     x values, degrees higher than about thirty cause problems with
     numerical instability in this code.
 
-    Based on Krogh 1970, "Efficient Algorithms for Polynomial Interpolation 
+    Based on Krogh 1970, "Efficient Algorithms for Polynomial Interpolation
     and Numerical Differentiation"
     """
     def __init__(self, xi, yi):
         """Construct an interpolator passing through the specified points
 
         The polynomial passes through all the pairs (xi,yi). One may additionally
-        specify a number of derivatives at each point xi; this is done by 
-        repeating the value xi and specifying the derivatives as successive 
-        yi values.  
+        specify a number of derivatives at each point xi; this is done by
+        repeating the value xi and specifying the derivatives as successive
+        yi values.
 
         Parameters
         ----------
         xi : array-like, length N
-            known x-coordinates 
+            known x-coordinates
         yi : array-like, N by R
             known y-coordinates, interpreted as vectors of length R,
             or scalars if R=1
 
         Example
         -------
-        To produce a polynomial that is zero at 0 and 1 and has 
+        To produce a polynomial that is zero at 0 and 1 and has
         derivative 2 at 0, call
 
         >>> KroghInterpolator([0,0,1],[0,2,0])
@@ -86,7 +86,7 @@
 
     def __call__(self,x):
         """Evaluate the polynomial at the point x
-        
+
         Parameters
         ----------
         x : scalar or array-like of length N
@@ -101,7 +101,7 @@
         if np.isscalar(x):
             scalar = True
             m = 1
-        else: 
+        else:
             scalar = False
             m = len(x)
         x = np.asarray(x)
@@ -125,11 +125,11 @@
             else:
                 return p
 
-    def derivatives(self,x,der=None): 
+    def derivatives(self,x,der=None):
         """Evaluate many derivatives of the polynomial at the point x
 
         Produce an array of all derivative values at the point x.
-        
+
         Parameters
         ----------
         x : scalar or array-like of length N
@@ -142,9 +142,9 @@
         Returns
         -------
         d : array
-            If the interpolator's values are R-dimensional then the 
-            returned array will be der by N by R. If x is a scalar, 
-            the middle dimension will be dropped; if R is 1 then the 
+            If the interpolator's values are R-dimensional then the
+            returned array will be der by N by R. If x is a scalar,
+            the middle dimension will be dropped; if R is 1 then the
             last dimension will be dropped.
 
         Example
@@ -159,7 +159,7 @@
         if np.isscalar(x):
             scalar = True
             m = 1
-        else: 
+        else:
             scalar = False
             m = len(x)
         x = np.asarray(x)
@@ -201,7 +201,7 @@
                 return cn[:der,0]
             else:
                 return cn[:der]
-    def derivative(self,x,der): 
+    def derivative(self,x,der):
         """Evaluate one derivative of the polynomial at the point x
 
         Parameters
@@ -209,19 +209,19 @@
         x : scalar or array-like of length N
             Point or points at which to evaluate the derivatives
         der : None or integer
-            Which derivative to extract. This number includes the 
+            Which derivative to extract. This number includes the
             function value as 0th derivative.
         Returns
         -------
         d : array
-            If the interpolator's values are R-dimensional then the 
-            returned array will be N by R. If x is a scalar, 
-            the middle dimension will be dropped; if R is 1 then the 
+            If the interpolator's values are R-dimensional then the
+            returned array will be N by R. If x is a scalar,
+            the middle dimension will be dropped; if R is 1 then the
             last dimension will be dropped.
 
         Notes
         -----
-        This is computed by evaluating all derivatives up to the desired 
+        This is computed by evaluating all derivatives up to the desired
         one (using self.derivatives()) and then discarding the rest.
         """
         return self.derivatives(x,der=der+1)[der]
@@ -229,34 +229,34 @@
 def krogh_interpolate(xi,yi,x,der=0):
     """Convenience function for polynomial interpolation.
 
-    Constructs a polynomial that passes through a given set of points,         
+    Constructs a polynomial that passes through a given set of points,
     optionally with specified derivatives at those points.
     Evaluates the polynomial or some of its derivatives.
     For reasons of numerical stability, this function does not compute
     the coefficients of the polynomial, although they can be obtained
     by evaluating all the derivatives.
 
-    Be aware that the algorithms implemented here are not necessarily 
-    the most numerically stable known. Moreover, even in a world of 
-    exact computation, unless the x coordinates are chosen very 
-    carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice - 
-    polynomial interpolation itself is a very ill-conditioned process 
-    due to the Runge phenomenon. In general, even with well-chosen 
+    Be aware that the algorithms implemented here are not necessarily
+    the most numerically stable known. Moreover, even in a world of
+    exact computation, unless the x coordinates are chosen very
+    carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice -
+    polynomial interpolation itself is a very ill-conditioned process
+    due to the Runge phenomenon. In general, even with well-chosen
     x values, degrees higher than about thirty cause problems with
     numerical instability in this code.
 
-    Based on Krogh 1970, "Efficient Algorithms for Polynomial Interpolation 
+    Based on Krogh 1970, "Efficient Algorithms for Polynomial Interpolation
     and Numerical Differentiation"
 
     The polynomial passes through all the pairs (xi,yi). One may additionally
-    specify a number of derivatives at each point xi; this is done by 
-    repeating the value xi and specifying the derivatives as successive 
-    yi values.  
+    specify a number of derivatives at each point xi; this is done by
+    repeating the value xi and specifying the derivatives as successive
+    yi values.
 
     Parameters
     ----------
     xi : array-like, length N
-        known x-coordinates 
+        known x-coordinates
     yi : array-like, N by R
         known y-coordinates, interpreted as vectors of length R,
         or scalars if R=1
@@ -265,19 +265,19 @@
     der : integer or list
         How many derivatives to extract; None for all potentially
         nonzero derivatives (that is a number equal to the number
-        of points), or a list of derivatives to extract. This number 
+        of points), or a list of derivatives to extract. This number
         includes the function value as 0th derivative.
     Returns
     -------
     d : array
-        If the interpolator's values are R-dimensional then the 
-        returned array will be the number of derivatives by N by R. 
-        If x is a scalar, the middle dimension will be dropped; if 
-        the yi are scalars then the last dimension will be dropped. 
+        If the interpolator's values are R-dimensional then the
+        returned array will be the number of derivatives by N by R.
+        If x is a scalar, the middle dimension will be dropped; if
+        the yi are scalars then the last dimension will be dropped.
 
     Notes
     -----
-    Construction of the interpolating polynomial is a relatively expensive 
+    Construction of the interpolating polynomial is a relatively expensive
     process. If you want to evaluate it repeatedly consider using the class
     KroghInterpolator (which is what this function uses).
     """
@@ -295,7 +295,7 @@
 def approximate_taylor_polynomial(f,x,degree,scale,order=None):
     """Estimate the Taylor polynomial of f at x by polynomial fitting
 
-    A polynomial 
+    A polynomial
     Parameters
     ----------
     f : callable
@@ -310,24 +310,24 @@
         Function values spread over a range this wide are used to fit the
         polynomial. Must be chosen carefully.
     order : integer or None
-        The order of the polynomial to be used in the fitting; f will be     
+        The order of the polynomial to be used in the fitting; f will be
         evaluated order+1 times. If None, use degree.
 
     Returns
     -------
     p : poly1d
-        the Taylor polynomial (translated to the origin, so that 
+        the Taylor polynomial (translated to the origin, so that
         for example p(0)=f(x)).
 
     Notes
     -----
-    The appropriate choice of "scale" is a tradeoff - too large and the 
-    function differs from its Taylor polynomial too much to get a good 
+    The appropriate choice of "scale" is a tradeoff - too large and the
+    function differs from its Taylor polynomial too much to get a good
     answer, too small and roundoff errors overwhelm the higher-order terms.
-    The algorithm used becomes numerically unstable around order 30 even 
+    The algorithm used becomes numerically unstable around order 30 even
     under ideal circumstances.
 
-    Choosing order somewhat larger than degree may improve the higher-order 
+    Choosing order somewhat larger than degree may improve the higher-order
     terms.
     """
     if order is None:
@@ -351,17 +351,17 @@
     """The interpolating polynomial for a set of points
 
     Constructs a polynomial that passes through a given set of points.
-    Allows evaluation of the polynomial, efficient changing of the y 
-    values to be interpolated, and updating by adding more x values.  
-    For reasons of numerical stability, this function does not compute 
+    Allows evaluation of the polynomial, efficient changing of the y
+    values to be interpolated, and updating by adding more x values.
+    For reasons of numerical stability, this function does not compute
     the coefficients of the polynomial.
 
     This class uses a "barycentric interpolation" method that treats
     the problem as a special case of rational function interpolation.
-    This algorithm is quite stable, numerically, but even in a world of 
-    exact computation, unless the x coordinates are chosen very 
-    carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice - 
-    polynomial interpolation itself is a very ill-conditioned process 
+    This algorithm is quite stable, numerically, but even in a world of
+    exact computation, unless the x coordinates are chosen very
+    carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice -
+    polynomial interpolation itself is a very ill-conditioned process
     due to the Runge phenomenon.
 
     Based on Berrut and Trefethen 2004, "Barycentric Lagrange Interpolation".
@@ -379,7 +379,7 @@
             The x coordinates of the points the polynomial should pass through
         yi : array-like N by R or None
             The y coordinates of the points the polynomial should pass through;
-            if R>1 the polynomial is vector-valued. If None the y values 
+            if R>1 the polynomial is vector-valued. If None the y values
             will be supplied later.
         """
         self.n = len(xi)
@@ -393,19 +393,19 @@
             self.wi[:j]*=(self.xi[j]-self.xi[:j])
             self.wi[j] = np.multiply.reduce(self.xi[:j]-self.xi[j])
         self.wi**=-1
-            
+
     def set_yi(self, yi):
         """Update the y values to be interpolated
 
-        The barycentric interpolation algorithm requires the calculation 
-        of weights, but these depend only on the xi. The yi can be changed 
+        The barycentric interpolation algorithm requires the calculation
+        of weights, but these depend only on the xi. The yi can be changed
         at any time.
 
         Parameters
         ----------
         yi : array-like N by R
             The y coordinates of the points the polynomial should pass through;
-            if R>1 the polynomial is vector-valued. If None the y values 
+            if R>1 the polynomial is vector-valued. If None the y values
             will be supplied later.
         """
         if yi is None:
@@ -425,12 +425,12 @@
             raise ValueError("yi dimensions do not match xi dimensions")
         self.yi = yi
         self.r = r
-        
 
+
     def add_xi(self, xi, yi=None):
         """Add more x values to the set to be interpolated
 
-        The barycentric interpolation algorithm allows easy updating by 
+        The barycentric interpolation algorithm allows easy updating by
         adding more points for the polynomial to pass through.
 
         Parameters
@@ -439,8 +439,8 @@
             The x coordinates of the points the polynomial should pass through
         yi : array-like N1 by R or None
             The y coordinates of the points the polynomial should pass through;
-            if R>1 the polynomial is vector-valued. If None the y values 
-            will be supplied later. The yi should be specified if and only if 
+            if R>1 the polynomial is vector-valued. If None the y values
+            will be supplied later. The yi should be specified if and only if
             the interpolator has y values specified.
         """
         if yi is not None:
@@ -489,8 +489,8 @@
 
         Notes
         -----
-        Currently the code computes an outer product between x and the 
-        weights, that is, it constructs an intermediate array of size 
+        Currently the code computes an outer product between x and the
+        weights, that is, it constructs an intermediate array of size
         N by M, where N is the degree of the polynomial.
         """
         scalar = np.isscalar(x)
@@ -516,15 +516,15 @@
     """Convenience function for polynomial interpolation
 
     Constructs a polynomial that passes through a given set of points,
-    then evaluates the polynomial. For reasons of numerical stability, 
+    then evaluates the polynomial. For reasons of numerical stability,
     this function does not compute the coefficients of the polynomial.
 
     This function uses a "barycentric interpolation" method that treats
     the problem as a special case of rational function interpolation.
-    This algorithm is quite stable, numerically, but even in a world of 
-    exact computation, unless the x coordinates are chosen very 
-    carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice - 
-    polynomial interpolation itself is a very ill-conditioned process 
+    This algorithm is quite stable, numerically, but even in a world of
+    exact computation, unless the x coordinates are chosen very
+    carefully - Chebyshev zeros (e.g. cos(i*pi/n)) are a good choice -
+    polynomial interpolation itself is a very ill-conditioned process
     due to the Runge phenomenon.
 
     Based on Berrut and Trefethen 2004, "Barycentric Lagrange Interpolation".
@@ -547,9 +547,9 @@
     Notes
     -----
 
-    Construction of the interpolation weights is a relatively slow process. 
-    If you want to call this many times with the same xi (but possibly 
-    varying yi or x) you should use the class BarycentricInterpolator. 
+    Construction of the interpolation weights is a relatively slow process.
+    If you want to call this many times with the same xi (but possibly
+    varying yi or x) you should use the class BarycentricInterpolator.
     This is what this function uses internally.
     """
     return BarycentricInterpolator(xi, yi)(x)
@@ -558,10 +558,10 @@
 class PiecewisePolynomial(object):
     """Piecewise polynomial curve specified by points and derivatives
 
-    This class represents a curve that is a piecewise polynomial. It 
-    passes through a list of points and has specified derivatives at 
-    each point. The degree of the polynomial may very from segment to 
-    segment, as may the number of derivatives available. The degree 
+    This class represents a curve that is a piecewise polynomial. It
+    passes through a list of points and has specified derivatives at
+    each point. The degree of the polynomial may very from segment to
+    segment, as may the number of derivatives available. The degree
     should not exceed about thirty.
 
     Appending points to the end of the curve is efficient.
@@ -585,12 +585,12 @@
 
         Notes
         -----
-        If orders is None, or orders[i] is None, then the degree of the 
+        If orders is None, or orders[i] is None, then the degree of the
         polynomial segment is exactly the degree required to match all i
-        available derivatives at both endpoints. If orders[i] is not None, 
-        then some derivatives will be ignored. The code will try to use an     
-        equal number of derivatives from each end; if the total number of 
-        derivatives needed is odd, it will prefer the rightmost endpoint. If 
+        available derivatives at both endpoints. If orders[i] is not None,
+        then some derivatives will be ignored. The code will try to use an
+        equal number of derivatives from each end; if the total number of
+        derivatives needed is odd, it will prefer the rightmost endpoint. If
         not enough derivatives are available, an exception is raised.
         """
         yi0 = np.asarray(yi[0])
@@ -606,7 +606,7 @@
         self.xi = [xi[0]]
         self.yi = [yi0]
         self.n = 1
-        
+
         self.direction = direction
         self.orders = []
         self.polynomials = []
@@ -614,12 +614,12 @@
 
     def _make_polynomial(self,x1,y1,x2,y2,order,direction):
         """Construct the interpolating polynomial object
-        
+
         Deduces the number of derivatives to match at each end
         from order and the number of derivatives available. If
-        possible it uses the same number of derivatives from 
+        possible it uses the same number of derivatives from
         each end; if the number is odd it tries to take the
-        extra one from y2. In any case if not enough derivatives 
+        extra one from y2. In any case if not enough derivatives
         are available at one end or another it draws enough to
         make up the total from the other end.
         """
@@ -647,14 +647,14 @@
 
     def append(self, xi, yi, order=None):
         """Append a single point with derivatives to the PiecewisePolynomial
-        
+
         Parameters
         ----------
         xi : float
         yi : array-like
             yi is the list of derivatives known at xi
         order : integer or None
-            a polynomial order, or instructions to use the highest 
+            a polynomial order, or instructions to use the highest
             possible order
         """
 
@@ -668,7 +668,7 @@
 
         if self.direction is None:
             self.direction = np.sign(xi-self.xi[-1])
-        elif (xi-self.xi[-1])*self.direction < 0: 
+        elif (xi-self.xi[-1])*self.direction < 0:
             raise ValueError("x coordinates must be in the %d direction: %s" % (self.direction, self.xi))
 
         self.xi.append(xi)
@@ -719,7 +719,7 @@
         Parameters
         ----------
         x : scalar or array-like of length N
-        
+
         Returns
         -------
         y : scalar or array-like of length R or length N or N by R
@@ -748,31 +748,31 @@
         x : scalar or array-like of length N
         der : integer
             which single derivative to extract
-        
+
         Returns
         -------
         y : scalar or array-like of length R or length N or N by R
 
         Notes
         -----
-        This currently computes (using self.derivatives()) all derivatives 
-        of the curve segment containing each x but returns only one. 
+        This currently computes (using self.derivatives()) all derivatives
+        of the curve segment containing each x but returns only one.
         """
         return self.derivatives(x,der=der+1)[der]
 
     def derivatives(self, x, der):
-        """Evaluate a derivative of the piecewise polynomial 
+        """Evaluate a derivative of the piecewise polynomial
         Parameters
         ----------
         x : scalar or array-like of length N
         der : integer
-            how many derivatives (including the function value as 
+            how many derivatives (including the function value as
             0th derivative) to extract
-        
+
         Returns
         -------
         y : array-like of shape der by R or der by N or der by N by R
-        
+
         """
         if np.isscalar(x):
             pos = np.clip(np.searchsorted(self.xi, x) - 1, 0, self.n-2)
@@ -805,19 +805,19 @@
         a list of polynomial orders, or a single universal order
     der : integer
         which single derivative to extract
-    
+
     Returns
     -------
     y : scalar or array-like of length R or length M or M by R
 
     Notes
     -----
-    If orders is None, or orders[i] is None, then the degree of the 
+    If orders is None, or orders[i] is None, then the degree of the
     polynomial segment is exactly the degree required to match all i
-    available derivatives at both endpoints. If orders[i] is not None, 
-    then some derivatives will be ignored. The code will try to use an     
-    equal number of derivatives from each end; if the total number of 
-    derivatives needed is odd, it will prefer the rightmost endpoint. If 
+    available derivatives at both endpoints. If orders[i] is not None,
+    then some derivatives will be ignored. The code will try to use an
+    equal number of derivatives from each end; if the total number of
+    derivatives needed is odd, it will prefer the rightmost endpoint. If
     not enough derivatives are available, an exception is raised.
 
     Construction of these piecewise polynomials can be an expensive process;

Modified: trunk/scipy/interpolate/tests/test_fitpack.py
===================================================================
--- trunk/scipy/interpolate/tests/test_fitpack.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/interpolate/tests/test_fitpack.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -116,20 +116,20 @@
         x = [1,1,1,2,2,2,4,4,4]
         y = [1,2,3,1,2,3,1,2,3]
         z = array([0,7,8,3,4,7,1,3,4])
- 
+
         lut = SmoothBivariateSpline(x,y,z,kx=1,ky=1,s=0)
         tx = [1,2,4]
         ty = [1,2,3]
- 
+
         tz = lut(tx, ty)
         trpz = .25*(diff(tx)[:,None]*diff(ty)[None,:]
                     *(tz[:-1,:-1]+tz[1:,:-1]+tz[:-1,1:]+tz[1:,1:])).sum()
         assert_almost_equal(lut.integral(tx[0], tx[-1], ty[0], ty[-1]), trpz)
- 
+
         lut2 = SmoothBivariateSpline(x,y,z,kx=2,ky=2,s=0)
         assert_almost_equal(lut2.integral(tx[0], tx[-1], ty[0], ty[-1]), trpz,
                             decimal=0) # the quadratures give 23.75 and 23.85
-        
+
         tz = lut(tx[:-1], ty[:-1])
         trpz = .25*(diff(tx[:-1])[:,None]*diff(ty[:-1])[None,:]
                     *(tz[:-1,:-1]+tz[1:,:-1]+tz[:-1,1:]+tz[1:,1:])).sum()

Modified: trunk/scipy/interpolate/tests/test_interpolate.py
===================================================================
--- trunk/scipy/interpolate/tests/test_interpolate.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/interpolate/tests/test_interpolate.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -29,7 +29,7 @@
 
         self.y210 = np.arange(20.).reshape((2, 10))
         self.y102 = np.arange(20.).reshape((10, 2))
-        
+
         self.fill_value = -100.0
 
     def test_validation(self):
@@ -181,7 +181,7 @@
             interp10(np.array([[3.4, 5.6], [2.4, 7.8]])),
             np.array([[3.4, 5.6], [2.4, 7.8]]),
         )
-        
+
         # Multidimensional outputs.
         interp210 = interp1d(self.x10, self.y210, kind=kind)
         assert_array_almost_equal(
@@ -217,7 +217,7 @@
             np.array([[[6.8, 7.8], [11.2, 12.2]],
                       [[4.8, 5.8], [15.6, 16.6]]]),
         )
-        
+
         # Check large ndim output
         a = [4, 5, 6, 7]
         y = np.arange(np.prod(a)).reshape(*a)
@@ -225,7 +225,7 @@
             x = np.arange(s)
             z = interp1d(x, y, axis=n, kind=kind)
             assert_array_almost_equal(z(x), y)
-            
+
             x2 = np.arange(2*3*1).reshape((2,3,1)) / 12.
             b = list(a)
             b[n:n+1] = [2,3,1]

Modified: trunk/scipy/interpolate/tests/test_polyint.py
===================================================================
--- trunk/scipy/interpolate/tests/test_polyint.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/interpolate/tests/test_polyint.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -11,7 +11,7 @@
 class CheckKrogh(TestCase):
     def setUp(self):
         self.true_poly = scipy.poly1d([-2,3,1,5,-4])
-        self.test_xs = np.linspace(-1,1,100) 
+        self.test_xs = np.linspace(-1,1,100)
         self.xs = np.linspace(-1,1,5)
         self.ys = self.true_poly(self.xs)
 
@@ -122,7 +122,7 @@
 class CheckBarycentric(TestCase):
     def setUp(self):
         self.true_poly = scipy.poly1d([-2,3,1,5,-4])
-        self.test_xs = np.linspace(-1,1,100) 
+        self.test_xs = np.linspace(-1,1,100)
         self.xs = np.linspace(-1,1,5)
         self.ys = self.true_poly(self.xs)
 
@@ -203,7 +203,7 @@
         xs = [0, 1, 2]
         ys = [[[0,1]],[[1,0],[-1,-1]],[[2,1]]]
         P = PiecewisePolynomial(xs,ys)
-        Pi = [PiecewisePolynomial(xs,[[yd[i] for yd in y] for y in ys]) 
+        Pi = [PiecewisePolynomial(xs,[[yd[i] for yd in y] for y in ys])
             for i in xrange(len(ys[0][0]))]
         test_xs = np.linspace(-1,3,100)
         assert_almost_equal(P(test_xs),

Modified: trunk/scipy/io/tests/test_mmio.py
===================================================================
--- trunk/scipy/io/tests/test_mmio.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/io/tests/test_mmio.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -293,13 +293,13 @@
 
     def test_sparse_formats(self):
         mats = []
-        
+
         I = array([0, 0, 1, 2, 3, 3, 3, 4])
         J = array([0, 3, 1, 2, 1, 3, 4, 4])
 
         V = array([  1.0,   6.0,   10.5, 0.015,   250.5,  -280.0, 33.32, 12.0 ])
         mats.append( scipy.sparse.coo_matrix((V,(I,J)),shape=(5,5)) )
-        
+
         V = array([  1.0 + 3j,    6.0 + 2j,  10.50 + 0.9j, 0.015 + -4.4j,
                    250.5 + 0j, -280.0 + 5j,  33.32 + 6.4j, 12.00 + 0.8j])
         mats.append( scipy.sparse.coo_matrix((V,(I,J)),shape=(5,5)) )
@@ -309,7 +309,7 @@
             for fmt in ['csr','csc','coo']:
                 fn = mktemp()
                 mmwrite(fn, mat.asformat(fmt))
-        
+
                 result = mmread(fn).todense()
                 assert_array_almost_equal(result, expected)
 

Modified: trunk/scipy/ndimage/_registration.py
===================================================================
--- trunk/scipy/ndimage/_registration.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/ndimage/_registration.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -116,7 +116,7 @@
     --------
         image = fmri_series[i]
         x[0:6] = measures[i]['align_rotate'][0:6]
-	M = get_inverse_mappings(x)
+        M = get_inverse_mappings(x)
         # overwrite the fMRI volume with the aligned volume
         fmri_series[i] = remap_image(image, M, resample='cubic')
 
@@ -175,7 +175,7 @@
 
 def register(image1, image1_mat, image2, image2_mat, multires=[4, 2], histo_fwhm=3, 
              ftype=1, lite=0, smhist=0, method='nmi', opt_method='hybrid',
-	     optimize_function=None):
+             optimize_function=None):
 
     """
     parm_vector = register(image1, image1_mat, image2, image2_mat, multires=[4, 2], histo_fwhm=3,
@@ -198,7 +198,7 @@
         image2_mat is the source image MAT 
     multires: {list}, optional
         the volume subsample values for each pass of the registration.
-	the default is 2 passes with subsample 4 in pass 1 and subsample 2 in pass 2
+        the default is 2 passes with subsample 4 in pass 1 and subsample 2 in pass 2
     histo_fwhm : {int}, optional
         used for the filter kernel in the low pass filter of the joint histogram 
     ftype : {0, 1}, optional
@@ -214,7 +214,7 @@
         flag for type of registration metric. nmi is normalized mutual
         information; mi is mutual information; ecc is entropy cross
         correlation; ncc is normalized cross correlation. mse is mean
-	squared error.
+        squared error.
     opt_method: {'powell', 'cg', 'hybrid'}, optional
         registration is two pass. Pass 1 is low res to get close to alignment
         and pass 2 starts at the pass 1 optimal alignment. In powell pass 1 and
@@ -292,12 +292,12 @@
         optimize_function = cost_function
 
     parm_vector = multires_registration(optimize_function, image1, image1_mat, image2, image2_mat,
-		                        multires, histo_fwhm, lite, smhist, method, opt_method)
+                                        multires, histo_fwhm, lite, smhist, method, opt_method)
 
     return parm_vector
 
 def multires_registration(optimize_function, image1, image1_mat, image2, image2_mat,
-		          multires, histo_fwhm, lite, smhist, method, opt_method):
+                          multires, histo_fwhm, lite, smhist, method, opt_method):
 
     """
 
@@ -315,7 +315,7 @@
         image2_mat is the source image MAT 
     multires: {list}, optional
         the volume subsample values for each pass of the registration.
-	the default is 2 passes with subsample 4 in pass 1 and subsample 2 in pass 2
+        the default is 2 passes with subsample 4 in pass 1 and subsample 2 in pass 2
     histo_fwhm : {int}, optional
         used for the filter kernel in the low pass filter of the joint histogram 
     ftype : {0, 1}, optional
@@ -331,7 +331,7 @@
         flag for type of registration metric. nmi is normalized mutual
         information; mi is mutual information; ecc is entropy cross
         correlation; ncc is normalized cross correlation. mse is mean
-	squared error.
+        squared error.
     opt_method: {'powell', 'cg', 'hybrid'}, optional
         registration is two pass. Pass 1 is low res to get close to alignment
         and pass 2 starts at the pass 1 optimal alignment. In powell pass 1 and
@@ -364,12 +364,12 @@
     # the kernel fwhm value for the x and y joint histogram filter
     fwhm[:] = histo_fwhm
     for i in loop:
-	# this is the volume subsample
-	step[:] = multires[i]
-	# optfunc_args is specific to the cost_function in this file
-	# this will need to change if you use another optimize_function.
+        # this is the volume subsample
+        step[:] = multires[i]
+        # optfunc_args is specific to the cost_function in this file
+        # this will need to change if you use another optimize_function.
         optfunc_args = (image1, image1_mat, image2, image2_mat, step, histo_fwhm,
-			lite, smhist, method, ret_histo)
+                        lite, smhist, method, ret_histo)
         p_args = (optfunc_args,)
         if opt_method=='powell':
             print 'POWELL multi-res registration step size ', step
@@ -694,7 +694,7 @@
         # trilinear interpolation mapping.
         reg.register_linear_resample(image_F, remap_image_F, composite, sample_vector)
         cost = (np.square(image_G-remap_image_F)).mean()
-	# cost is min when G and F are aligned so keep cost positive
+        # cost is min when G and F are aligned so keep cost positive
 
         return cost
 
@@ -718,7 +718,7 @@
             hkernel = smooth_kernel(fwhm, x)
             output=None
             # 2D filter in 1D separable stages using the same kernel. SPM
-	    # has options for a 2D fwhm kernel yet only uses 1 element
+            # has options for a 2D fwhm kernel yet only uses 1 element
             axis = 0
             joint_histogram = correlate1d(joint_histogram, hkernel, axis, output)
             axis = 1
@@ -919,7 +919,7 @@
 
     threshold : float (default 0.999)
         the value of the normalized integrated histogram
-	that when reached sets the high threshold index
+        that when reached sets the high threshold index
 
     Returns 
     -------
@@ -927,7 +927,7 @@
         the scaled volume
     ih : {nd_array}
         the integrated histogram. can be used for image display 
-	purpose (histogram equalization)
+        purpose (histogram equalization)
 
     """
 
@@ -1011,8 +1011,8 @@
 
     step = np.array([1, 1, 1], dtype=np.int32)
     optfunc_args = (image1, image1_mat, image2, image2_mat, step, histo_fwhm, lite,
-		    smhist, method, ret_histo)
-			
+                    smhist, method, ret_histo)
+                        
     if ret_histo:
         cost, joint_histogram = cost_function(P, optfunc_args)
         return cost, joint_histogram 

Modified: trunk/scipy/ndimage/tests/test_registration.py
===================================================================
--- trunk/scipy/ndimage/tests/test_registration.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/ndimage/tests/test_registration.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -62,125 +62,125 @@
 class TestRegistration(TestCase):
 
     def test_affine_matrix_build_1(self):
-	"test_affine_matrix_build_1"
+        "test_affine_matrix_build_1"
         P = np.zeros(6)
-	M = reg.build_rotate_matrix(P)
-	E = np.eye(4)
-	match = (E==M).all()
-	assert_equal(match, True)
-	return
+        M = reg.build_rotate_matrix(P)
+        E = np.eye(4)
+        match = (E==M).all()
+        assert_equal(match, True)
+        return
 
     def test_affine_matrix_build_2(self):
-	"test_affine_matrix_build_2"
+        "test_affine_matrix_build_2"
         P = np.zeros(6)
-	P[0] = 1.0
-	M = reg.build_rotate_matrix(P)
-	E = np.array([
-		     [ 1. ,  0.        , 0.        , 0. ],
-       		     [ 0. ,  0.9998477 , 0.01745241, 0. ],
-       		     [ 0. , -0.01745241, 0.9998477 , 0. ],
-       		     [ 0. ,  0.        , 0.        , 1. ]
-		     ])
-	assert_array_almost_equal(E, M, decimal=6)
-	return
+        P[0] = 1.0
+        M = reg.build_rotate_matrix(P)
+        E = np.array([
+                     [ 1. ,  0.        , 0.        , 0. ],
+                     [ 0. ,  0.9998477 , 0.01745241, 0. ],
+                     [ 0. , -0.01745241, 0.9998477 , 0. ],
+                     [ 0. ,  0.        , 0.        , 1. ]
+                     ])
+        assert_array_almost_equal(E, M, decimal=6)
+        return
 
     def test_affine_matrix_build_3(self):
-	"test_affine_matrix_build_3"
+        "test_affine_matrix_build_3"
         P = np.zeros(6)
-	P[0] = 1.0
-	P[1] = 1.0
-	P[2] = 1.0
-	M = reg.build_rotate_matrix(P)
-	E = np.array([
+        P[0] = 1.0
+        P[1] = 1.0
+        P[2] = 1.0
+        M = reg.build_rotate_matrix(P)
+        E = np.array([
                      [ 0.99969541,  0.01744975,  0.01745241,  0. ],
                      [-0.01775429,  0.9996901 ,  0.01744975,  0. ],
                      [-0.0171425 , -0.01775429,  0.99969541,  0. ],
                      [ 0.        ,  0.        ,  0.        ,  1. ]
-		     ])
-	assert_array_almost_equal(E, M, decimal=6)
-	return
+                     ])
+        assert_array_almost_equal(E, M, decimal=6)
+        return
 
     @dec.slow
     def test_autoalign_histogram_1(self):
-	"test_autoalign_histogram_1"
-	desc = load_desc()
-	gvol = build_volume(desc)
+        "test_autoalign_histogram_1"
+        desc = load_desc()
+        gvol = build_volume(desc)
         mat  = np.eye(4)
-	cost, joint = reg.check_alignment(gvol, mat, gvol, mat, ret_histo=1, lite=1)
-	# confirm that with lite=1 only have non-zero on the main diagonal
+        cost, joint = reg.check_alignment(gvol, mat, gvol, mat, ret_histo=1, lite=1)
+        # confirm that with lite=1 only have non-zero on the main diagonal
         j_diag = joint.diagonal()
         Z = np.diag(j_diag)
         W = joint - Z
-	# clip the near-zero fuzz
+        # clip the near-zero fuzz
         W[abs(W) < 1e-10] = 0.0
-	assert_equal(W.max(), 0.0)
-	return
+        assert_equal(W.max(), 0.0)
+        return
 
     @dec.slow
     def test_autoalign_histogram_2(self):
-	"test_autoalign_histogram_2"
-	desc = load_desc()
-	gvol = build_volume(desc)
+        "test_autoalign_histogram_2"
+        desc = load_desc()
+        gvol = build_volume(desc)
         mat  = np.eye(4)
-	cost, joint = reg.check_alignment(gvol, mat, gvol, mat, ret_histo=1, lite=0)
-	# confirm that with lite=0 DO have non-zero on the main diagonal
+        cost, joint = reg.check_alignment(gvol, mat, gvol, mat, ret_histo=1, lite=0)
+        # confirm that with lite=0 DO have non-zero on the main diagonal
         j_diag = joint.diagonal()
         Z = np.diag(j_diag)
         W = joint - Z
-	# clip the near-zero fuzz
+        # clip the near-zero fuzz
         W[abs(W) < 1e-10] = 0.0
-	s = (W.max() > 0.0)
-	# make sure there are off-diagonal values
-	assert_equal(s, True)
-	return
+        s = (W.max() > 0.0)
+        # make sure there are off-diagonal values
+        assert_equal(s, True)
+        return
 
     @dec.slow
     def test_autoalign_ncc_value_1(self):
-	"test_autoalign_ncc_value_1"
-	desc = load_desc()
-	gvol = build_volume(desc)
+        "test_autoalign_ncc_value_1"
+        desc = load_desc()
+        gvol = build_volume(desc)
         mat  = np.eye(4)
-	cost = reg.check_alignment(gvol, mat, gvol, mat, method='ncc', lite=1)
-	# confirm the cross correlation is near 1.0 
-	t = abs(cost) + 0.0001
-	s = (t >= 1.0)
-	assert_equal(s, True)
-	return
+        cost = reg.check_alignment(gvol, mat, gvol, mat, method='ncc', lite=1)
+        # confirm the cross correlation is near 1.0 
+        t = abs(cost) + 0.0001
+        s = (t >= 1.0)
+        assert_equal(s, True)
+        return
 
     @dec.slow
     def test_autoalign_ncc_value_2(self):
-	"test_autoalign_ncc_value_2"
-	desc = load_desc()
-	gvol = build_volume(desc)
+        "test_autoalign_ncc_value_2"
+        desc = load_desc()
+        gvol = build_volume(desc)
         mat  = np.eye(4)
-	cost = reg.check_alignment(gvol, mat, gvol, mat, method='ncc', lite=0)
-	# confirm the cross correlation is near 1.0 
-	t = abs(cost) + 0.0001
-	s = (t >= 1.0)
-	assert_equal(s, True)
-	return
+        cost = reg.check_alignment(gvol, mat, gvol, mat, method='ncc', lite=0)
+        # confirm the cross correlation is near 1.0 
+        t = abs(cost) + 0.0001
+        s = (t >= 1.0)
+        assert_equal(s, True)
+        return
 
     @dec.slow
     def test_autoalign_nmi_value_1(self):
-	"test_autoalign_nmi_value_1"
-	desc = load_desc()
-	gvol = build_volume(desc)
+        "test_autoalign_nmi_value_1"
+        desc = load_desc()
+        gvol = build_volume(desc)
         mat  = np.eye(4)
-	cost = reg.check_alignment(gvol, mat, gvol, mat, method='nmi', lite=1)
-	# confirm the normalized mutual information is near -2.0 
-	assert_almost_equal(cost, -2.0, decimal=6)
-	return
+        cost = reg.check_alignment(gvol, mat, gvol, mat, method='nmi', lite=1)
+        # confirm the normalized mutual information is near -2.0 
+        assert_almost_equal(cost, -2.0, decimal=6)
+        return
 
     @dec.slow
     def test_autoalign_nmi_value_2(self):
-	"test_autoalign_nmi_value_2"
-	desc = load_desc()
-	gvol = build_volume(desc)
+        "test_autoalign_nmi_value_2"
+        desc = load_desc()
+        gvol = build_volume(desc)
         mat  = np.eye(4)
-	cost = reg.check_alignment(gvol, mat, gvol, mat, method='nmi', lite=0)
-	# confirm the normalized mutual information is near -2.0 
-	assert_almost_equal(cost, -1.7973048186515352, decimal=6)
-	return
+        cost = reg.check_alignment(gvol, mat, gvol, mat, method='nmi', lite=0)
+        # confirm the normalized mutual information is near -2.0 
+        assert_almost_equal(cost, -1.7973048186515352, decimal=6)
+        return
 
 
 

Modified: trunk/scipy/ndimage/tests/test_regression.py
===================================================================
--- trunk/scipy/ndimage/tests/test_regression.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/ndimage/tests/test_regression.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -1,6 +1,6 @@
 import numpy as np
 from numpy.testing import *
-    
+
 import scipy.ndimage as ndimage
 
 def test_byte_order_median():

Modified: trunk/scipy/optimize/minpack.py
===================================================================
--- trunk/scipy/optimize/minpack.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/optimize/minpack.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -257,7 +257,7 @@
 
       brentq, brenth, ridder, bisect, newton -- one-dimensional root-finding
 
-      fixed_point -- scalar and vector fixed-point finder      
+      fixed_point -- scalar and vector fixed-point finder
 
     """
     x0 = array(x0,ndmin=1)
@@ -374,7 +374,7 @@
       brentq, brenth, ridder, bisect, newton -- one-dimensional root-finding
 
       fixed_point -- scalar and vector fixed-point finder
-            
+
     """
 
     if fprime is not None:
@@ -414,7 +414,7 @@
 # Steffensen's Method using Aitken's Del^2 convergence acceleration.
 def fixed_point(func, x0, args=(), xtol=1e-8, maxiter=500):
     """Find the point where func(x) == x
-    
+
     Given a function of one or more variables and a starting point, find a
     fixed-point of the function: i.e. where func(x)=x.
 
@@ -452,7 +452,7 @@
     """
     if not isscalar(x0):
         x0 = asarray(x0)
-        p0 = x0                  
+        p0 = x0
         for iter in range(maxiter):
             p1 = func(p0, *args)
             p2 = func(p1, *args)
@@ -468,7 +468,7 @@
             p1 = func(p0, *args)
             p2 = func(p1, *args)
             d = p2 - 2.0 * p1 + p0
-            if d == 0.0:            
+            if d == 0.0:
                 return p2
             else:
                 p = p0 - (p1 - p0)*(p1-p0) / d

Modified: trunk/scipy/sandbox/exmplpackage/benchmarks/bench_foo.py
===================================================================
--- trunk/scipy/sandbox/exmplpackage/benchmarks/bench_foo.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/exmplpackage/benchmarks/bench_foo.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -16,4 +16,3 @@
 
     def bench_simple(self):
         print 'A long timed benchmark here'
-

Modified: trunk/scipy/sandbox/mkufunc/examples/benchmark.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/examples/benchmark.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/examples/benchmark.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -28,11 +28,11 @@
         char *op = args[1];
         n = dimensions[0];
         double x;
-        
+
         for(i = 0; i < n; i++) {
                 x = *(double *)ip0;
                 double *out = (double *)op;
-                
+
                 *out = 4.2 * x*x + 3.7 * x + 1.5;
 
                 ip0 += is0;

Modified: trunk/scipy/sandbox/mkufunc/examples/mandel_c.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/examples/mandel_c.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/examples/mandel_c.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -32,7 +32,7 @@
         char *ip1 = args[1];
         char *op = args[2];
         n = dimensions[0];
-        
+
         for(i = 0; i < n; i++) {
                 *(long *)op = iterations(*(double *)ip0,
                                          *(double *)ip1);

Modified: trunk/scipy/sandbox/mkufunc/examples/mandel_mkImage.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/examples/mandel_mkImage.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/examples/mandel_mkImage.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -14,7 +14,7 @@
 @mkufunc(int)
 def color(i):
     return (i * 10) % 256
-    
+
     n = i % 3
     if n == 0:
         c = (255, 127, 128)
@@ -39,7 +39,7 @@
 img = color(img)
 img.dtype = numpy.uint8
 img = img.reshape(h, w, 4)
-    
+
 print img.dtype
 print img.shape
 

Modified: trunk/scipy/sandbox/mkufunc/examples/mandel_py.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/examples/mandel_py.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/examples/mandel_py.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -20,8 +20,8 @@
     else:
         return -1
 
-    
 
+
 if __name__ == '__main__':
 
     assert mandel(-1, .3) == 36

Modified: trunk/scipy/sandbox/mkufunc/examples/primes.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/examples/primes.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/examples/primes.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -5,9 +5,9 @@
 src = 0
 if len(sys.argv) == 2 and sys.argv[1] == 's':
     src = 1
-    
 
 
+
 from mkufunc.api import mkufunc
 
 

Modified: trunk/scipy/sandbox/mkufunc/mkufunc/api.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/mkufunc/api.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/mkufunc/api.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -33,16 +33,16 @@
                                    'pypy_%s.c' % func_hash(f, salt=argtypes))
     try:
         return open(cache_file_name).read()
-    
+
     except IOError:
         from interactive import Translation
-        
+
         t = Translation(f, backend='c')
         t.annotate(argtypes)
         t.source()
-        
+
         os.rename(t.driver.c_source_filename, cache_file_name)
-        
+
         return translate(f, argtypes)
 
 
@@ -64,7 +64,7 @@
     ...     return x * x
 
     >>> signature = [int, int] # only the input arguments are used here
-    
+
     compilation is done upon initialization
     >>> x = Cfunc(sqr, signature, 123)
     ...
@@ -74,7 +74,7 @@
     1
     >>> x.sig
     [<type 'int'>, <type 'int'>]
-    
+
     Attributes:
         f           -- the Python function object
         n           -- id number
@@ -97,9 +97,9 @@
         self.nin = f.func_code.co_argcount
         self.nout = len(self.sig) - self.nin
         assert self.nout == 1                  # for now
-        
+
         src = translate(f, signature[:self.nin])
-        
+
         self._prefix = 'f%i_' % self.n
         self._allCsrc = src.replace('pypy_', self._prefix + 'pypy_')
         self.cname = self._prefix + 'pypy_g_' + f.__name__
@@ -116,7 +116,7 @@
             \{.*?\n\}\n          # function body ending with } in single line
             ''' % self.cname,
             re.DOTALL | re.MULTILINE | re.VERBOSE)
-        
+
         found = p.findall(self._allCsrc)
         assert len(found) == 1
         res = found[0]
@@ -125,9 +125,9 @@
             print '------------------'
             print res
             print '------------------'
-        
+
         return 'inline %s\n' % res
-    
+
     def ufunc_support_code(self):
         # Unfortunately the code in here is very hard to read.
         # In order to make the code clearer, one would need a real template
@@ -139,33 +139,33 @@
 
         def varname(i):
             return chr(i + ord('a'))
-        
+
         declargs = ', '.join('%s %s' % (typedict[self.sig[i]].c, varname(i))
                              for i in xrange(self.nin))
-        
+
         args = ', '.join(varname(i) for i in xrange(self.nin))
-        
+
         isn_steps = '\n\t'.join('npy_intp is%i = steps[%i];' % (i, i)
                                 for i in xrange(self.nin))
-        
+
         ipn_args = '\n\t'.join('char *ip%i = args[%i];' % (i, i)
                                for i in xrange(self.nin))
-        
+
         body1d_in = '\n\t\t'.join('%s *in%i = (%s *)ip%i;' %
                                   (2*(typedict[self.sig[i]].c, i))
                                   for i in xrange(self.nin))
-        
+
         body1d_add = '\n\t\t'.join('ip%i += is%i;' % (i, i)
                                    for i in xrange(self.nin))
-        
+
         ptrargs = ', '.join('*in%i' % i for i in xrange(self.nin))
-        
+
         rettype = typedict[self.sig[-1]].c
-        
+
         return '''
 static %(rettype)s wrap_%(cname)s(%(declargs)s)
 {
-	return %(cname)s(%(args)s);
+        return %(cname)s(%(args)s);
 }
 
 typedef %(rettype)s Func_%(n)i(%(declargs)s);
@@ -173,23 +173,23 @@
 static void
 PyUFunc_%(n)i(char **args, npy_intp *dimensions, npy_intp *steps, void *func)
 {
-	npy_intp i, n;
+        npy_intp i, n;
         %(isn_steps)s
-	npy_intp os = steps[%(nin)s];
+        npy_intp os = steps[%(nin)s];
         %(ipn_args)s
-	char *op = args[%(nin)s];
-	Func_%(n)i *f = (Func_%(n)i *) func;
-	n = dimensions[0];
-        
-	for(i = 0; i < n; i++) {
-		%(body1d_in)s
-		%(rettype)s *out = (%(rettype)s *)op;
-		
-		*out = (%(rettype)s) f(%(ptrargs)s);
+        char *op = args[%(nin)s];
+        Func_%(n)i *f = (Func_%(n)i *) func;
+        n = dimensions[0];
 
+        for(i = 0; i < n; i++) {
+                %(body1d_in)s
+                %(rettype)s *out = (%(rettype)s *)op;
+
+                *out = (%(rettype)s) f(%(ptrargs)s);
+
                 %(body1d_add)s
                 op += os;
-	}
+        }
 }
 ''' % locals()
 
@@ -198,26 +198,26 @@
     """ Given a list of Cfunc instances, return the support code for weave.
     """
     acc = cStringIO.StringIO()
-    
+
     acc.write('/********************* start pypy.h  **************/\n\n')
     acc.write(open(os.path.join(os.path.dirname(__file__),
                                 'pypy.h')).read())
     acc.write('/********************** end pypy.h ****************/\n\n')
-    
+
     for cf in cfuncs:
         acc.write(cf.cfunc())
         acc.write(cf.ufunc_support_code())
-        
+
     fname = cfuncs[0].f.__name__
-    
+
     pyufuncs = ''.join('\tPyUFunc_%i,\n' % cf.n for cf in cfuncs)
-    
+
     data = ''.join('\t(void *) wrap_%s,\n' % cf.cname for cf in cfuncs)
-    
+
     types = ''.join('\t%s  /* %i */\n' %
                     (''.join(typedict[t].npy + ', ' for t in cf.sig), cf.n)
                     for cf in cfuncs)
-    
+
     acc.write('''
 static PyUFuncGenericFunction %(fname)s_functions[] = {
 %(pyufuncs)s};
@@ -233,7 +233,7 @@
         print '------------------ start support_code -----------------'
         print acc.getvalue()
         print '------------------- end support_code ------------------'
-        
+
     return acc.getvalue()
 
 
@@ -244,7 +244,7 @@
     ntypes = len(signatures)
     fname = f.__name__
     fhash = func_hash(f)
-    
+
     res = '''
 import_ufunc();
 
@@ -280,14 +280,14 @@
     """
     if len(signatures) == 0:
         raise ValueError("At least one signature needed")
-    
+
     signatures.sort(key=lambda sig: [numpy.dtype(typ).num for typ in sig])
-    
+
     cfuncs = [Cfunc(f, sig, n) for n, sig in enumerate(signatures)]
-    
+
     ufunc_info = weave.base_info.custom_info()
     ufunc_info.add_header('"numpy/ufuncobject.h"')
-    
+
     return weave.inline(code(f, signatures),
                         verbose=verbose,
                         support_code=support_code(cfuncs),
@@ -296,7 +296,7 @@
 
 def mkufunc(arg0=[float], src=0):
     """ Python decorator which returns compiled UFunc of the function given.
-    
+
     >>> from numpy import arange
     >>> from mkufunc.api import mkufunc
     >>> @mkufunc
@@ -310,7 +310,7 @@
     array([  6.3,   9.5,  21.1,  41.1,  69.5])
     """
     class UFunc(object):
-        
+
         def __init__(self, f):
             nin = f.func_code.co_argcount
             nout = 1
@@ -321,7 +321,7 @@
                     signatures[i] = (nin + nout) * (sig,)
                 else:
                     raise TypeError("no match for %r" % sig)
-                
+
             for sig in signatures:
                 assert isinstance(sig, tuple)
                 if len(sig) != nin + nout:
@@ -331,28 +331,28 @@
                 for t in sig:
                     if t not in typedict.keys():
                         raise TypeError("no match for %r" % t)
-            
+
             self.ufunc = genufunc(f, signatures)
-            
+
         def __call__(self, *args):
             return self.ufunc(*args)
 
     global showC
     showC = src
-    
+
     if isinstance(arg0, FunctionType):
         f = arg0
         signatures = [float]
         return UFunc(f)
-    
+
     elif isinstance(arg0, list):
         signatures = arg0
         return UFunc
-    
+
     elif arg0 in typedict.keys():
         signatures = [arg0]
         return UFunc
-    
+
     else:
         raise TypeError("first argument has to be a function, a type, or "
                         "a list of signatures")

Modified: trunk/scipy/sandbox/mkufunc/mkufunc/driver.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/mkufunc/driver.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/mkufunc/driver.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -74,7 +74,7 @@
         env = os.environ.copy()
         env['_INSTRUMENT_COUNTERS'] = str(self.datafile)
         subprocess.call("'%s' %s" % (exe, args), env=env, shell=True)
-        
+
     def after(self):
         # xxx
         os._exit(0)
@@ -100,7 +100,7 @@
 
         if setopts is not None:
             self.config.set(**setopts)
-        
+
         self.exe_name = exe_name
         self.extmod_name = extmod_name
 
@@ -112,7 +112,7 @@
             default_goal, = self.backend_select_goals([default_goal])
             if default_goal in self._maybe_skip():
                 default_goal = None
-        
+
         self.default_goal = default_goal
         self.extra_goals = []
         self.exposed = []
@@ -176,7 +176,7 @@
                     new_goal = cand
                     break
             else:
-                raise Exception, "cannot infer complete goal from: %r" % goal 
+                raise Exception, "cannot infer complete goal from: %r" % goal
             l.append(new_goal)
         return l
 
@@ -186,8 +186,8 @@
     def _maybe_skip(self):
         maybe_skip = []
         if self._disabled:
-             for goal in  self.backend_select_goals(self._disabled):
-                 maybe_skip.extend(self._depending_on_closure(goal))
+            for goal in  self.backend_select_goals(self._disabled):
+                maybe_skip.extend(self._depending_on_closure(goal))
         return dict.fromkeys(maybe_skip).keys()
 
 
@@ -228,7 +228,7 @@
             raise Exception("instrumentation requires the c backend"
                             " and unix for now")
         from pypy.tool.udir import udir
-        
+
         datafile = udir.join('_instrument_counters')
         makeProfInstrument = lambda compiler: ProfInstrument(datafile, compiler)
 
@@ -299,7 +299,7 @@
         policy = self.policy
         self.log.info('with policy: %s.%s' %
                       (policy.__class__.__module__, policy.__class__.__name__))
-        
+
         annmodel.DEBUG = self.config.translation.debug
         annotator = translator.buildannotator(policy=policy)
 
@@ -447,7 +447,7 @@
         from pypy.translator.backendopt.all import backend_optimizations
         backend_optimizations(self.translator)
     #
-    task_backendopt_ootype = taskdef(task_backendopt_ootype, 
+    task_backendopt_ootype = taskdef(task_backendopt_ootype,
                                         [OOTYPE], "ootype back-end optimisations")
     OOBACKENDOPT = 'backendopt_ootype'
 
@@ -456,7 +456,7 @@
         from pypy.translator.transform import insert_ll_stackcheck
         count = insert_ll_stackcheck(self.translator)
         self.log.info("inserted %d stack checks." % (count,))
-        
+
     task_stackcheckinsertion_lltype = taskdef(
         task_stackcheckinsertion_lltype,
         ['?'+BACKENDOPT, RTYPE, 'annotate'],
@@ -495,10 +495,10 @@
         self.database = database
     #
     task_database_c = taskdef(task_database_c,
-                            [STACKCHECKINSERTION, '?'+BACKENDOPT, RTYPE, '?annotate'], 
+                            [STACKCHECKINSERTION, '?'+BACKENDOPT, RTYPE, '?annotate'],
                             "Creating database for generating c source",
                             earlycheck = possibly_check_for_boehm)
-    
+
     def task_source_c(self):  # xxx messy
         translator = self.translator
         cbuilder = self.cbuilder
@@ -512,7 +512,7 @@
     def task_compile_c(self): # xxx messy
         cbuilder = self.cbuilder
         cbuilder.compile()
-        
+
         if self.standalone:
             self.c_entryp = cbuilder.executable_name
             self.create_exe()
@@ -520,19 +520,19 @@
             self.c_entryp = cbuilder.get_entry_point()
     #
     task_compile_c = taskdef(task_compile_c, ['source_c'], "Compiling c source")
-    
-    
+
+
     def task_run_c(self):
         self.backend_run('c')
     #
-    task_run_c = taskdef(task_run_c, ['compile_c'], 
+    task_run_c = taskdef(task_run_c, ['compile_c'],
                          "Running compiled c source",
                          idemp=True)
 
     def task_llinterpret_lltype(self):
         from pypy.rpython.llinterp import LLInterpreter
         py.log.setconsumer("llinterp operation", None)
-        
+
         translator = self.translator
         interp = LLInterpreter(translator.rtyper)
         bk = translator.annotator.bookkeeper
@@ -543,8 +543,8 @@
 
         log.llinterpret.event("result -> %s" % v)
     #
-    task_llinterpret_lltype = taskdef(task_llinterpret_lltype, 
-                                      [STACKCHECKINSERTION, '?'+BACKENDOPT, RTYPE], 
+    task_llinterpret_lltype = taskdef(task_llinterpret_lltype,
+                                      [STACKCHECKINSERTION, '?'+BACKENDOPT, RTYPE],
                                       "LLInterpreting")
 
     def task_source_llvm(self):
@@ -559,8 +559,8 @@
         llvm_filename = self.llvmgen.gen_source(self.entry_point)
         self.log.info("written: %s" % (llvm_filename,))
     #
-    task_source_llvm = taskdef(task_source_llvm, 
-                               [STACKCHECKINSERTION, BACKENDOPT, RTYPE], 
+    task_source_llvm = taskdef(task_source_llvm,
+                               [STACKCHECKINSERTION, BACKENDOPT, RTYPE],
                                "Generating llvm source")
 
     def task_compile_llvm(self):
@@ -572,14 +572,14 @@
         else:
             self.c_module, self.c_entryp = gen.compile_module()
     #
-    task_compile_llvm = taskdef(task_compile_llvm, 
-                                ['source_llvm'], 
+    task_compile_llvm = taskdef(task_compile_llvm,
+                                ['source_llvm'],
                                 "Compiling llvm source")
 
     def task_run_llvm(self):
         self.backend_run('llvm')
     #
-    task_run_llvm = taskdef(task_run_llvm, ['compile_llvm'], 
+    task_run_llvm = taskdef(task_run_llvm, ['compile_llvm'],
                             "Running compiled llvm source",
                             idemp=True)
 
@@ -589,7 +589,7 @@
                       stackless=self.config.translation.stackless)
         filename = self.gen.write_source()
         self.log.info("Wrote %s" % (filename,))
-    task_source_js = taskdef(task_source_js, 
+    task_source_js = taskdef(task_source_js,
                         [OOTYPE],
                         'Generating Javascript source')
 
@@ -630,7 +630,7 @@
         # restore original os values
         if hasattr(self, 'old_cli_defs'):
             unpatch_os(self.old_cli_defs)
-        
+
         self.log.info("Compiled %s" % filename)
         if self.standalone and self.exe_name:
             self.copy_cli_exe()
@@ -641,7 +641,7 @@
         pass
     task_run_cli = taskdef(task_run_cli, ['compile_cli'],
                               'XXX')
-    
+
     def task_source_jvm(self):
         from pypy.translator.jvm.genjvm import GenJvm
         from pypy.translator.jvm.node import EntryPoint
@@ -702,7 +702,7 @@
         if backend in ('cli', 'jvm'):
             from pypy.translator.oosupport.support import patch_os
             driver.old_cli_defs = patch_os()
-        
+
         target = targetspec_dic['target']
         spec = target(driver, args)
 
@@ -712,8 +712,8 @@
             entry_point, inputtypes = spec
             policy = None
 
-        driver.setup(entry_point, inputtypes, 
-                     policy=policy, 
+        driver.setup(entry_point, inputtypes,
+                     policy=policy,
                      extra=targetspec_dic,
                      empty_translator=empty_translator)
 
@@ -725,4 +725,4 @@
         assert 'pypy.rpython.rmodel' not in sys.modules, (
             "cannot fork because the rtyper has already been imported")
     prereq_checkpt_rtype_lltype = prereq_checkpt_rtype
-    prereq_checkpt_rtype_ootype = prereq_checkpt_rtype    
+    prereq_checkpt_rtype_ootype = prereq_checkpt_rtype

Modified: trunk/scipy/sandbox/mkufunc/mkufunc/interactive.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/mkufunc/interactive.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/mkufunc/interactive.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -17,7 +17,7 @@
 
         self.entry_point = entry_point
         self.context = TranslationContext(config=self.config)
-        
+
         # hook into driver events
         driver_own_event = self.driver._event
         def _event(kind, goal, func):
@@ -25,7 +25,7 @@
             driver_own_event(kind, goal, func)
         self.driver._event = _event
         self.driver_setup = False
-        
+
         self.update_options(argtypes, kwds)
         # for t.view() to work just after construction
         graph = self.context.buildflowgraph(entry_point)
@@ -33,8 +33,8 @@
 
     def driver_event(self, kind, goal, func):
         if kind == 'pre':
-             self.ensure_setup()
-            
+            self.ensure_setup()
+
     def ensure_setup(self, argtypes=None, policy=None, standalone=False):
         if not self.driver_setup:
             if standalone:
@@ -82,7 +82,7 @@
         if self.config.translation.backend is not None:
             return self.ensure_opt('type_system')
         return self.ensure_opt('type_system', type_system, 'lltype')
-        
+
     def ensure_backend(self, backend=None):
         backend = self.ensure_opt('backend', backend)
         self.ensure_type_system()
@@ -99,7 +99,7 @@
     def rtype(self, argtypes=None, **kwds):
         self.update_options(argtypes, kwds)
         ts = self.ensure_type_system()
-        return getattr(self.driver, 'rtype_'+ts)()        
+        return getattr(self.driver, 'rtype_'+ts)()
 
     # backend depedent
 
@@ -107,7 +107,7 @@
         self.update_options(argtypes, kwds)
         backend = self.ensure_backend()
         self.driver.source_c()
-       
+
     def compile(self, argtypes=None, **kwds):
         self.update_options(argtypes, kwds)
         backend = self.ensure_backend()

Modified: trunk/scipy/sandbox/mkufunc/mkufunc/test_func_hash.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/mkufunc/test_func_hash.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/mkufunc/test_func_hash.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -4,42 +4,42 @@
 
 
 class Tests(unittest.TestCase):
-    
+
     # These tests are very (Python) version specific.
-    
+
     def test_simple(self):
-        
+
         def f(x):
             return 2.5 * x * x + 4.7 * x
-        
+
         self.assertEqual(func_hash(f),
                          '5f12e97debf1d2cb9e0a2f92e045b1fb')
-        
-        
+
+
     def test_extra(self):
-        
+
         def f(x):
             return 2.5 * x * x + 4.7 * x
-        
+
         self.assertEqual(func_hash(f, salt=[(int, int), (float, float)]),
                          'e637d9825ef20cb56d364041118ca72e')
-        
+
     def test_const(self):
-        
+
         def add_a(b):
             return a + b   # a in globals
-        
+
         self.assertEqual(func_hash(add_a),
                          '9ff237f372bf233470ce940edd58f60d')
-        
+
     def test_inner(self):
-        
+
         def foo(x):
             inner1 = lambda t: t/3.0
             def inner2(n):
                 return n + 3
             return inner1(x) + inner2(int(x))
-        
+
         self.assertEqual(func_hash(foo),
                          '814c113dfc77e7ebb52915dd3ce9c37a')
 

Modified: trunk/scipy/sandbox/mkufunc/mkufunc/test_mkufunc.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/mkufunc/test_mkufunc.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/mkufunc/test_mkufunc.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -10,10 +10,10 @@
 
     def assertClose(self, x, y):
         self.assert_(allclose(x, y), '%s != %s' % (x, y))
-            
 
+
 class Internal_Tests(unittest.TestCase, Util):
-    
+
     def test_Cfunc(self):
         def sqr(x):
             return x * x
@@ -34,7 +34,7 @@
         y = uf(x)
         self.assertClose(y, [18.1, 19.3])
         self.assert_(str(y.dtype).startswith('float'))
-        
+
         x = array([1, 4])
         y = uf(x)
         self.assertEqual(list(y), [18, 21])
@@ -42,13 +42,13 @@
 
 
 class Arg_Tests(unittest.TestCase, Util):
-    
+
     def check_ufunc(self, f):
         for arg in (array([0.0, 1.0, 2.5]),
                     [0.0, 1.0, 2.5],
                     (0.0, 1.0, 2.5)):
             self.assertClose(f(arg), [0.0, 1.0, 6.25])
-            
+
         self.assertEqual(f(3), 9)
         self.assert_(f(-2.5) - 6.25 < 1E-10)
 
@@ -57,13 +57,13 @@
         def f(x):
             return x * x
         self.check_ufunc(f)
-        
+
     def test_noargs(self):
         @mkufunc()
         def f(x):
             return x * x
         self.check_ufunc(f)
-        
+
     def test_varargs(self):
         for arg in (float,
                     [float],
@@ -79,20 +79,20 @@
             return x * x
         self.assertEqual(f(3), 9)
         self.assert_(isinstance(f(42), int))
-        
+
     def test_mixed(self):
         @mkufunc([(int, float, int), float])
         def f(n, x):
             return n + x * x
-        
+
         y = f(2, 3.9)            # Note that int(2 + 3.9 * 3.9) = 17
         self.assertEqual(y, 17)
         self.assert_(isinstance(y, int))
-        
+
         y = f(2.0, 3.9)
         self.assertClose(y, 17.21)
         self.assert_(isinstance(y, float))
-        
+
     def test_exceptions(self):
         def f(x):
             return x
@@ -103,10 +103,10 @@
         self.assertRaises(TypeError, mkufunc([{}]), f)
         self.assertRaises(TypeError, mkufunc([(int, {})]), f)
         self.assertRaises(ValueError, mkufunc([]), f)
-        
 
+
 class Math_Tests(unittest.TestCase, Util):
-    
+
     def assertFuncsEqual(self, uf, f):
         x = 0.4376
         a = uf(x)
@@ -116,7 +116,7 @@
         a = uf(xx)
         b = [f(x) for x in xx]
         self.assertClose(a, b)
-        
+
     def test_pi(self):
         @mkufunc
         def f(x): return math.pi * x
@@ -126,7 +126,7 @@
         @mkufunc
         def f(x): return math.e * x
         self.assertFuncsEqual(f, lambda x: math.e * x)
-        
+
     def test_exp(self):
         @mkufunc
         def f(x): return math.exp(x)
@@ -146,22 +146,22 @@
         @mkufunc
         def f(x): return math.sqrt(x)
         self.assertFuncsEqual(f, math.sqrt)
-        
+
     def test_cos(self):
         @mkufunc
         def f(x): return math.cos(x)
         self.assertFuncsEqual(f, math.cos)
-        
+
     def test_sin(self):
         @mkufunc
         def f(x): return math.sin(x)
         self.assertFuncsEqual(f, math.sin)
-        
+
     def test_tan(self):
         @mkufunc
         def f(x): return math.tan(x)
         self.assertFuncsEqual(f, math.tan)
-        
+
     def test_cosh(self):
         @mkufunc
         def f(x): return math.cosh(x)
@@ -171,12 +171,12 @@
         @mkufunc
         def f(x): return math.sinh(x)
         self.assertFuncsEqual(f, math.sinh)
-        
+
     def test_tanh(self):
         @mkufunc
         def f(x): return math.tanh(x)
         self.assertFuncsEqual(f, math.tanh)
-        
+
     def test_acos(self):
         @mkufunc
         def f(x): return math.acos(x)
@@ -198,7 +198,7 @@
             return math.atan2(x, y)
 
         self.assertClose(f(4, 5), math.atan2(4, 5))
-        
+
         xx = array([1.0, 3.0, -2.4,  3.1, -2.3, -1.0])
         yy = array([1.0, 2.0,  7.5, -8.7,  0.0, -3.2])
         a = f(xx, yy)
@@ -209,28 +209,28 @@
         @mkufunc
         def f(x, y):
             return math.pow(x, y)
-        
+
         self.assertClose(f(2, 3), 8)
-        
+
         xx = array([1.0, 3.0, 2.4, 0.0, 0.0, 0.0, 2.3,  2.0])
         yy = array([1.0, 2.0, 7.5, 0.0, 0.5, 1.0, 0.0, -1.0])
         a = f(xx, yy)
         b = [math.pow(x, y) for x, y in zip(xx, yy)]
         self.assertClose(a, b)
-        
+
     def test_hypot(self):
         @mkufunc
         def f(x, y):
             return math.hypot(x, y)
-        
+
         self.assertClose(f(3, 4), 5)
-        
+
         xx = array([3.0, 2.4, -2.4,  3.1, -2.3, -1.0])
         yy = array([4.0, 7.5,  7.5, -8.7,  0.0, -3.2])
         a = f(xx, yy)
         b = [math.hypot(x, y) for x, y in zip(xx, yy)]
         self.assertClose(a, b)
-       
+
     def test_arithmetic(self):
         def f(x):
             return (4 * x + 2) / (x * x - 7 * x + 1)
@@ -242,7 +242,7 @@
         @mkufunc(int)
         def f(i):
             return i % 5
-        
+
         self.assert_(all(f(range(7)) == array([0, 1, 2, 3, 4, 0, 1])))
         self.assert_(all(f(arange(8)) == array([0, 1, 2, 3, 4, 0, 1, 2])))
 
@@ -296,7 +296,7 @@
         @mkufunc
         def f(x):
             return a * x
-        
+
         x = arange(0, 1, 0.1)
         self.assertClose(f(x), a * x)
 
@@ -305,18 +305,18 @@
 
     def test_lambda(self):
         self.assertRaises(AssertionError, mkufunc, lambda x: x*x + 2)
-    
+
     def test_angle(self):
         from math import sin, pi, sqrt
         @mkufunc
         def sin_deg(angle):
             return sin(angle / 180.0 * pi)
-        
+
         self.assertClose(sin_deg([0, 30, 45, 60, 90, 180, 270, 360]),
                          [0, 0.5, 1/sqrt(2), sqrt(3)/2, 1, 0, -1, 0])
-  
 
 
 
+
 if __name__ == '__main__':
     unittest.main()

Modified: trunk/scipy/sandbox/mkufunc/setup.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/setup.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sandbox/mkufunc/setup.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -7,7 +7,7 @@
 
     name         = "mkufunc",
     version      = "0.1",
-    
+
     zip_safe = False,
     package_data = {'': ['*.h']},
     packages = find_packages(),

Modified: trunk/scipy/signal/signaltools.py
===================================================================
--- trunk/scipy/signal/signaltools.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/signal/signaltools.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -1467,10 +1467,10 @@
 
     zi=lfilter_zi(b,a)
 
-    #Grow the signal to have edges for stabilizing 
+    #Grow the signal to have edges for stabilizing
     #the filter with inverted replicas of the signal
     s=r_[2*x[0]-x[edge:1:-1],x,2*x[-1]-x[-1:-edge:-1]]
-    #in the case of one go we only need one of the extrems 
+    #in the case of one go we only need one of the extrems
     # both are needed for filtfilt
 
     (y,zf)=lfilter(b,a,s,-1,zi*s[0])

Modified: trunk/scipy/signal/tests/test_signaltools.py
===================================================================
--- trunk/scipy/signal/tests/test_signaltools.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/signal/tests/test_signaltools.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -57,4 +57,3 @@
 
 if __name__ == "__main__":
     run_module_suite()
-

Modified: trunk/scipy/sparse/base.py
===================================================================
--- trunk/scipy/sparse/base.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/base.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -216,7 +216,7 @@
     #   and operations return in csr format
     #  thus, a new sparse matrix format just needs to define
     #  a tocsr method
-    
+
     def multiply(self, other):
         """Point-wise multiplication by another matrix
         """
@@ -237,7 +237,7 @@
 
     def __rsub__(self, other):  # other - self
         return self.tocsr().__rsub__(other)
-    
+
     # old __mul__ interfaces
     def matvec(self, other):
         return self * other
@@ -256,11 +256,11 @@
         """
 
         M,N = self.shape
-        
+
         if isscalarlike(other):
             # scalar value
             return self._mul_scalar(other)
-       
+
         if issparse(other):
             return self._mul_sparse_matrix(other)
 
@@ -284,7 +284,7 @@
             if other.ndim == 2 and other.shape[1] == 1:
                 # If 'other' was an (nx1) column vector, reshape the result
                 result = result.reshape(-1,1)
-            
+
             return result
 
         elif len(other.shape) == 2:
@@ -293,7 +293,7 @@
 
             if other.shape[0] != self.shape[1]:
                 raise ValueError('dimension mismatch')
-        
+
             result = self._mul_dense_matrix(asarray(other))
 
             if isinstance(other, matrix):
@@ -414,7 +414,7 @@
 
     def nonzero(self):
         """nonzero indices
-        
+
         Returns a tuple of arrays (row,col) containing the indices
         of the non-zero elements of the matrix.
 
@@ -430,7 +430,7 @@
 
         # convert to COOrdinate format
         A = self.tocoo()
-        nz_mask = A.data != 0 
+        nz_mask = A.data != 0
         return (A.row[nz_mask],A.col[nz_mask])
 
 

Modified: trunk/scipy/sparse/bsr.py
===================================================================
--- trunk/scipy/sparse/bsr.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/bsr.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -296,11 +296,11 @@
         result = zeros( self.shape[0], dtype=upcast(self.dtype, other.dtype) )
 
         bsr_matvec(M/R, N/C, R, C, \
-            self.indptr, self.indices, self.data.ravel(), 
+            self.indptr, self.indices, self.data.ravel(),
             other, result)
 
         return result
-    
+
     def _mul_dense_matrix(self,other):
         R,C = self.blocksize
         M,N = self.shape
@@ -318,7 +318,7 @@
     #    # TODO make sparse * dense matrix multiplication more efficient
     #    # matvec each column of other
     #    result = hstack( [ self * col.reshape(-1,1) for col in asarray(other).T ] )
-    #    return result                
+    #    return result
 
     def _mul_sparse_matrix(self, other):
         M, K1 = self.shape

Modified: trunk/scipy/sparse/compressed.py
===================================================================
--- trunk/scipy/sparse/compressed.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/compressed.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -275,11 +275,11 @@
 
         #output array
         result = zeros( self.shape[0], dtype=upcast(self.dtype,other.dtype) )
- 
+
         # csr_matvec or csc_matvec
         fn = getattr(sparsetools,self.format + '_matvec')
         fn(M, N, self.indptr, self.indices, self.data, other, result)
- 
+
         return result
 
 
@@ -295,7 +295,7 @@
 
         return result
 
-    
+
     def _mul_sparse_matrix(self, other):
         M, K1 = self.shape
         K2, N = other.shape
@@ -319,10 +319,10 @@
                   indptr, indices, data)
 
         return self.__class__((data,indices,indptr),shape=(M,N))
-    
+
     def matvec(self,other):
         return self * other
-    
+
     def matmat(self,other):
         return self * other
 
@@ -358,12 +358,12 @@
 
     #    elif isdense(other):
     #        # TODO make sparse * dense matrix multiplication more efficient
-    #        
+    #
     #        # matvec each column of other
     #        result = hstack( [ self * col.reshape(-1,1) for col in asarray(other).T ] )
     #        if isinstance(other, matrix):
     #            result = asmatrix(result)
-    #        return result                
+    #        return result
 
     #    else:
     #        raise TypeError, "need a dense or sparse matrix"

Modified: trunk/scipy/sparse/construct.py
===================================================================
--- trunk/scipy/sparse/construct.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/construct.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -61,7 +61,7 @@
 
 def identity(n, dtype='d', format=None):
     """Identity matrix in sparse format
-    
+
     Returns an identity matrix with shape (n,n) using a given
     sparse format and dtype.
 

Modified: trunk/scipy/sparse/coo.py
===================================================================
--- trunk/scipy/sparse/coo.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/coo.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -338,7 +338,7 @@
         result = zeros( self.shape[0], dtype=upcast(self.dtype,other.dtype) )
         coo_matvec(self.nnz, self.row, self.col, self.data, other, result)
         return result
-    
+
     def _mul_dense_matrix(self, other):
         return hstack( [ self._mul_vector(col).reshape(-1,1) for col in other.T ] )
 

Modified: trunk/scipy/sparse/data.py
===================================================================
--- trunk/scipy/sparse/data.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/data.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -66,4 +66,3 @@
 
     def _mul_scalar(self, other):
         return self._with_data(self.data * other)
-

Modified: trunk/scipy/sparse/dia.py
===================================================================
--- trunk/scipy/sparse/dia.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/dia.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -157,7 +157,7 @@
 
     def _mul_dense_matrix(self, other):
         return hstack( [ self._mul_vector(col).reshape(-1,1) for col in other.T ] )
-    
+
     def todia(self,copy=False):
         if copy:
             return self.copy()

Modified: trunk/scipy/sparse/extract.py
===================================================================
--- trunk/scipy/sparse/extract.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/extract.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -11,7 +11,7 @@
 def tril(A, k=0, format=None):
     """Return the lower triangular portion of a matrix in sparse format
 
-    Returns the elements on or below the k-th diagonal of the matrix A.  
+    Returns the elements on or below the k-th diagonal of the matrix A.
         - k = 0 corresponds to the main diagonal
         - k > 0 is above the main diagonal
         - k < 0 is below the main diagonal
@@ -77,7 +77,7 @@
 def triu(A, k=0, format=None):
     """Return the upper triangular portion of a matrix in sparse format
 
-    Returns the elements on or above the k-th diagonal of the matrix A.  
+    Returns the elements on or above the k-th diagonal of the matrix A.
         - k = 0 corresponds to the main diagonal
         - k > 0 is above the main diagonal
         - k < 0 is below the main diagonal
@@ -138,6 +138,3 @@
     data = A.data[mask]
 
     return coo_matrix( (data,(row,col)), shape=A.shape ).asformat(format)
-
-
-

Modified: trunk/scipy/sparse/lil.py
===================================================================
--- trunk/scipy/sparse/lil.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/lil.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -332,7 +332,7 @@
             new.data = numpy.array([[val*other for val in rowvals] for
                                     rowvals in new.data], dtype=object)
         return new
-    
+
     def __truediv__(self, other):           # self / other
         if isscalarlike(other):
             new = self.copy()

Modified: trunk/scipy/sparse/linalg/eigen/lobpcg/lobpcg.py
===================================================================
--- trunk/scipy/sparse/linalg/eigen/lobpcg/lobpcg.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/linalg/eigen/lobpcg/lobpcg.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -141,7 +141,7 @@
     else:
         return blockVectorV, blockVectorBV
 
-def lobpcg( A, X,  
+def lobpcg( A, X,
             B=None, M=None, Y=None,
             tol= None, maxiter=20,
             largest = True, verbosityLevel = 0,
@@ -151,14 +151,14 @@
     This function implements the Locally Optimal Block Preconditioned
     Conjugate Gradient Method (LOBPCG).
 
-    
+
     Parameters
     ----------
     A : {sparse matrix, dense matrix, LinearOperator}
-        The symmetric linear operator of the problem, usually a 
+        The symmetric linear operator of the problem, usually a
         sparse matrix.  Often called the "stiffness matrix".
     X : array_like
-        Initial approximation to the k eigenvectors. If A has 
+        Initial approximation to the k eigenvectors. If A has
         shape=(n,n) then X should have shape shape=(n,k).
 
     Returns

Modified: trunk/scipy/sparse/linalg/isolve/utils.py
===================================================================
--- trunk/scipy/sparse/linalg/isolve/utils.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/linalg/isolve/utils.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -1,6 +1,6 @@
 __docformat__ = "restructuredtext en"
 
-__all__ = [] 
+__all__ = []
 
 from warnings import warn
 
@@ -54,7 +54,7 @@
         b : rank 1 ndarray
             right hand side
         postprocess : function
-            converts the solution vector to the appropriate 
+            converts the solution vector to the appropriate
             type and dimensions (e.g. (N,1) matrix)
 
     """

Modified: trunk/scipy/sparse/sparsetools/bsr.py
===================================================================
--- trunk/scipy/sparse/sparsetools/bsr.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/sparsetools/bsr.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -51,484 +51,483 @@
 
 
 def bsr_diagonal(*args):
-  """
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        signed char Ax, signed char Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned char Ax, unsigned char Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        short Ax, short Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned short Ax, unsigned short Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        int Ax, int Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned int Ax, unsigned int Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long long Ax, long long Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax, unsigned long long Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        float Ax, float Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        double Ax, double Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long double Ax, long double Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax, npy_cfloat_wrapper Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax, npy_cdouble_wrapper Yx)
-    bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax, npy_clongdouble_wrapper Yx)
     """
-  return _bsr.bsr_diagonal(*args)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          signed char Ax, signed char Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned char Ax, unsigned char Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          short Ax, short Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned short Ax, unsigned short Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          int Ax, int Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned int Ax, unsigned int Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long long Ax, long long Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned long long Ax, unsigned long long Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          float Ax, float Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          double Ax, double Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long double Ax, long double Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax, npy_cfloat_wrapper Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax, npy_cdouble_wrapper Yx)
+      bsr_diagonal(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax, npy_clongdouble_wrapper Yx)
+      """
+    return _bsr.bsr_diagonal(*args)
 
 def bsr_scale_rows(*args):
-  """
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        signed char Ax, signed char Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned char Ax, unsigned char Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        short Ax, short Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned short Ax, unsigned short Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        int Ax, int Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned int Ax, unsigned int Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long long Ax, long long Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax, unsigned long long Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        float Ax, float Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        double Ax, double Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long double Ax, long double Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax, npy_cfloat_wrapper Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax, npy_cdouble_wrapper Xx)
-    bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax, npy_clongdouble_wrapper Xx)
     """
-  return _bsr.bsr_scale_rows(*args)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          signed char Ax, signed char Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned char Ax, unsigned char Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          short Ax, short Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned short Ax, unsigned short Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          int Ax, int Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned int Ax, unsigned int Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long long Ax, long long Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned long long Ax, unsigned long long Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          float Ax, float Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          double Ax, double Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long double Ax, long double Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax, npy_cfloat_wrapper Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax, npy_cdouble_wrapper Xx)
+      bsr_scale_rows(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax, npy_clongdouble_wrapper Xx)
+      """
+    return _bsr.bsr_scale_rows(*args)
 
 def bsr_scale_columns(*args):
-  """
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        signed char Ax, signed char Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned char Ax, unsigned char Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        short Ax, short Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned short Ax, unsigned short Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        int Ax, int Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned int Ax, unsigned int Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long long Ax, long long Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax, unsigned long long Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        float Ax, float Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        double Ax, double Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long double Ax, long double Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax, npy_cfloat_wrapper Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax, npy_cdouble_wrapper Xx)
-    bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax, npy_clongdouble_wrapper Xx)
     """
-  return _bsr.bsr_scale_columns(*args)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          signed char Ax, signed char Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned char Ax, unsigned char Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          short Ax, short Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned short Ax, unsigned short Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          int Ax, int Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned int Ax, unsigned int Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long long Ax, long long Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned long long Ax, unsigned long long Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          float Ax, float Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          double Ax, double Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long double Ax, long double Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax, npy_cfloat_wrapper Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax, npy_cdouble_wrapper Xx)
+      bsr_scale_columns(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax, npy_clongdouble_wrapper Xx)
+      """
+    return _bsr.bsr_scale_columns(*args)
 
 def bsr_transpose(*args):
-  """
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        signed char Ax, int Bp, int Bj, signed char Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned char Ax, int Bp, int Bj, unsigned char Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        short Ax, int Bp, int Bj, short Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned short Ax, int Bp, int Bj, unsigned short Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        int Ax, int Bp, int Bj, int Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned int Ax, int Bp, int Bj, unsigned int Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long long Ax, int Bp, int Bj, long long Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax, int Bp, int Bj, unsigned long long Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        float Ax, int Bp, int Bj, float Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        double Ax, int Bp, int Bj, double Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long double Ax, int Bp, int Bj, long double Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx)
-    bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax, int Bp, int Bj, 
-        npy_clongdouble_wrapper Bx)
     """
-  return _bsr.bsr_transpose(*args)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          signed char Ax, int Bp, int Bj, signed char Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned char Ax, int Bp, int Bj, unsigned char Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          short Ax, int Bp, int Bj, short Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned short Ax, int Bp, int Bj, unsigned short Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          int Ax, int Bp, int Bj, int Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned int Ax, int Bp, int Bj, unsigned int Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long long Ax, int Bp, int Bj, long long Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned long long Ax, int Bp, int Bj, unsigned long long Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          float Ax, int Bp, int Bj, float Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          double Ax, int Bp, int Bj, double Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long double Ax, int Bp, int Bj, long double Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx)
+      bsr_transpose(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax, int Bp, int Bj,
+          npy_clongdouble_wrapper Bx)
+      """
+    return _bsr.bsr_transpose(*args)
 
 def bsr_matmat_pass2(*args):
-  """
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, signed char Ax, int Bp, int Bj, signed char Bx, 
-        int Cp, int Cj, signed char Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, unsigned char Ax, int Bp, int Bj, unsigned char Bx, 
-        int Cp, int Cj, unsigned char Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, short Ax, int Bp, int Bj, short Bx, 
-        int Cp, int Cj, short Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, unsigned short Ax, int Bp, int Bj, 
-        unsigned short Bx, int Cp, int Cj, unsigned short Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, int Ax, int Bp, int Bj, int Bx, int Cp, 
-        int Cj, int Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, unsigned int Ax, int Bp, int Bj, unsigned int Bx, 
-        int Cp, int Cj, unsigned int Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, long long Ax, int Bp, int Bj, long long Bx, 
-        int Cp, int Cj, long long Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, unsigned long long Ax, int Bp, int Bj, 
-        unsigned long long Bx, int Cp, int Cj, unsigned long long Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, float Ax, int Bp, int Bj, float Bx, 
-        int Cp, int Cj, float Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, double Ax, int Bp, int Bj, double Bx, 
-        int Cp, int Cj, double Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, long double Ax, int Bp, int Bj, long double Bx, 
-        int Cp, int Cj, long double Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, npy_cfloat_wrapper Ax, int Bp, int Bj, 
-        npy_cfloat_wrapper Bx, int Cp, int Cj, npy_cfloat_wrapper Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, npy_cdouble_wrapper Ax, int Bp, int Bj, 
-        npy_cdouble_wrapper Bx, int Cp, int Cj, 
-        npy_cdouble_wrapper Cx)
-    bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap, 
-        int Aj, npy_clongdouble_wrapper Ax, int Bp, 
-        int Bj, npy_clongdouble_wrapper Bx, int Cp, 
-        int Cj, npy_clongdouble_wrapper Cx)
     """
-  return _bsr.bsr_matmat_pass2(*args)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, signed char Ax, int Bp, int Bj, signed char Bx,
+          int Cp, int Cj, signed char Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, unsigned char Ax, int Bp, int Bj, unsigned char Bx,
+          int Cp, int Cj, unsigned char Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, short Ax, int Bp, int Bj, short Bx,
+          int Cp, int Cj, short Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, unsigned short Ax, int Bp, int Bj,
+          unsigned short Bx, int Cp, int Cj, unsigned short Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, int Ax, int Bp, int Bj, int Bx, int Cp,
+          int Cj, int Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, unsigned int Ax, int Bp, int Bj, unsigned int Bx,
+          int Cp, int Cj, unsigned int Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, long long Ax, int Bp, int Bj, long long Bx,
+          int Cp, int Cj, long long Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, unsigned long long Ax, int Bp, int Bj,
+          unsigned long long Bx, int Cp, int Cj, unsigned long long Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, float Ax, int Bp, int Bj, float Bx,
+          int Cp, int Cj, float Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, double Ax, int Bp, int Bj, double Bx,
+          int Cp, int Cj, double Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, long double Ax, int Bp, int Bj, long double Bx,
+          int Cp, int Cj, long double Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, npy_cfloat_wrapper Ax, int Bp, int Bj,
+          npy_cfloat_wrapper Bx, int Cp, int Cj, npy_cfloat_wrapper Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, npy_cdouble_wrapper Ax, int Bp, int Bj,
+          npy_cdouble_wrapper Bx, int Cp, int Cj,
+          npy_cdouble_wrapper Cx)
+      bsr_matmat_pass2(int n_brow, int n_bcol, int R, int C, int N, int Ap,
+          int Aj, npy_clongdouble_wrapper Ax, int Bp,
+          int Bj, npy_clongdouble_wrapper Bx, int Cp,
+          int Cj, npy_clongdouble_wrapper Cx)
+      """
+    return _bsr.bsr_matmat_pass2(*args)
 
 def bsr_matvec(*args):
-  """
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        signed char Ax, signed char Xx, signed char Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned char Ax, unsigned char Xx, unsigned char Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        short Ax, short Xx, short Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned short Ax, unsigned short Xx, unsigned short Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        int Ax, int Xx, int Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned int Ax, unsigned int Xx, unsigned int Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long long Ax, long long Xx, long long Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax, unsigned long long Xx, 
-        unsigned long long Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        float Ax, float Xx, float Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        double Ax, double Xx, double Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long double Ax, long double Xx, long double Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax, npy_cfloat_wrapper Xx, 
-        npy_cfloat_wrapper Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax, npy_cdouble_wrapper Xx, 
-        npy_cdouble_wrapper Yx)
-    bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax, npy_clongdouble_wrapper Xx, 
-        npy_clongdouble_wrapper Yx)
     """
-  return _bsr.bsr_matvec(*args)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          signed char Ax, signed char Xx, signed char Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned char Ax, unsigned char Xx, unsigned char Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          short Ax, short Xx, short Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned short Ax, unsigned short Xx, unsigned short Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          int Ax, int Xx, int Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned int Ax, unsigned int Xx, unsigned int Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long long Ax, long long Xx, long long Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned long long Ax, unsigned long long Xx,
+          unsigned long long Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          float Ax, float Xx, float Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          double Ax, double Xx, double Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long double Ax, long double Xx, long double Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax, npy_cfloat_wrapper Xx,
+          npy_cfloat_wrapper Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax, npy_cdouble_wrapper Xx,
+          npy_cdouble_wrapper Yx)
+      bsr_matvec(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax, npy_clongdouble_wrapper Xx,
+          npy_clongdouble_wrapper Yx)
+      """
+    return _bsr.bsr_matvec(*args)
 
 def bsr_matvecs(*args):
-  """
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, signed char Ax, signed char Xx, 
-        signed char Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, unsigned char Ax, unsigned char Xx, 
-        unsigned char Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, short Ax, short Xx, short Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, unsigned short Ax, unsigned short Xx, 
-        unsigned short Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, int Ax, int Xx, int Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, unsigned int Ax, unsigned int Xx, 
-        unsigned int Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, long long Ax, long long Xx, long long Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, unsigned long long Ax, unsigned long long Xx, 
-        unsigned long long Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, float Ax, float Xx, float Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, double Ax, double Xx, double Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, long double Ax, long double Xx, 
-        long double Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, npy_cfloat_wrapper Ax, npy_cfloat_wrapper Xx, 
-        npy_cfloat_wrapper Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, npy_cdouble_wrapper Ax, npy_cdouble_wrapper Xx, 
-        npy_cdouble_wrapper Yx)
-    bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap, 
-        int Aj, npy_clongdouble_wrapper Ax, npy_clongdouble_wrapper Xx, 
-        npy_clongdouble_wrapper Yx)
     """
-  return _bsr.bsr_matvecs(*args)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, signed char Ax, signed char Xx,
+          signed char Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, unsigned char Ax, unsigned char Xx,
+          unsigned char Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, short Ax, short Xx, short Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, unsigned short Ax, unsigned short Xx,
+          unsigned short Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, int Ax, int Xx, int Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, unsigned int Ax, unsigned int Xx,
+          unsigned int Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, long long Ax, long long Xx, long long Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, unsigned long long Ax, unsigned long long Xx,
+          unsigned long long Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, float Ax, float Xx, float Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, double Ax, double Xx, double Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, long double Ax, long double Xx,
+          long double Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, npy_cfloat_wrapper Ax, npy_cfloat_wrapper Xx,
+          npy_cfloat_wrapper Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, npy_cdouble_wrapper Ax, npy_cdouble_wrapper Xx,
+          npy_cdouble_wrapper Yx)
+      bsr_matvecs(int n_brow, int n_bcol, int n_vecs, int R, int C, int Ap,
+          int Aj, npy_clongdouble_wrapper Ax, npy_clongdouble_wrapper Xx,
+          npy_clongdouble_wrapper Yx)
+      """
+    return _bsr.bsr_matvecs(*args)
 
 def bsr_elmul_bsr(*args):
-  """
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        signed char Ax, int Bp, int Bj, signed char Bx, 
-        int Cp, int Cj, signed char Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned char Ax, int Bp, int Bj, unsigned char Bx, 
-        int Cp, int Cj, unsigned char Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        short Ax, int Bp, int Bj, short Bx, int Cp, 
-        int Cj, short Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned short Ax, int Bp, int Bj, unsigned short Bx, 
-        int Cp, int Cj, unsigned short Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        int Ax, int Bp, int Bj, int Bx, int Cp, int Cj, 
-        int Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned int Ax, int Bp, int Bj, unsigned int Bx, 
-        int Cp, int Cj, unsigned int Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        long long Ax, int Bp, int Bj, long long Bx, 
-        int Cp, int Cj, long long Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax, int Bp, int Bj, unsigned long long Bx, 
-        int Cp, int Cj, unsigned long long Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        float Ax, int Bp, int Bj, float Bx, int Cp, 
-        int Cj, float Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        double Ax, int Bp, int Bj, double Bx, int Cp, 
-        int Cj, double Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        long double Ax, int Bp, int Bj, long double Bx, 
-        int Cp, int Cj, long double Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx, 
-        int Cp, int Cj, npy_cfloat_wrapper Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx, 
-        int Cp, int Cj, npy_cdouble_wrapper Cx)
-    bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax, int Bp, int Bj, 
-        npy_clongdouble_wrapper Bx, int Cp, int Cj, npy_clongdouble_wrapper Cx)
     """
-  return _bsr.bsr_elmul_bsr(*args)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          signed char Ax, int Bp, int Bj, signed char Bx,
+          int Cp, int Cj, signed char Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned char Ax, int Bp, int Bj, unsigned char Bx,
+          int Cp, int Cj, unsigned char Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          short Ax, int Bp, int Bj, short Bx, int Cp,
+          int Cj, short Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned short Ax, int Bp, int Bj, unsigned short Bx,
+          int Cp, int Cj, unsigned short Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          int Ax, int Bp, int Bj, int Bx, int Cp, int Cj,
+          int Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned int Ax, int Bp, int Bj, unsigned int Bx,
+          int Cp, int Cj, unsigned int Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          long long Ax, int Bp, int Bj, long long Bx,
+          int Cp, int Cj, long long Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned long long Ax, int Bp, int Bj, unsigned long long Bx,
+          int Cp, int Cj, unsigned long long Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          float Ax, int Bp, int Bj, float Bx, int Cp,
+          int Cj, float Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          double Ax, int Bp, int Bj, double Bx, int Cp,
+          int Cj, double Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          long double Ax, int Bp, int Bj, long double Bx,
+          int Cp, int Cj, long double Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx,
+          int Cp, int Cj, npy_cfloat_wrapper Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx,
+          int Cp, int Cj, npy_cdouble_wrapper Cx)
+      bsr_elmul_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax, int Bp, int Bj,
+          npy_clongdouble_wrapper Bx, int Cp, int Cj, npy_clongdouble_wrapper Cx)
+      """
+    return _bsr.bsr_elmul_bsr(*args)
 
 def bsr_eldiv_bsr(*args):
-  """
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        signed char Ax, int Bp, int Bj, signed char Bx, 
-        int Cp, int Cj, signed char Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned char Ax, int Bp, int Bj, unsigned char Bx, 
-        int Cp, int Cj, unsigned char Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        short Ax, int Bp, int Bj, short Bx, int Cp, 
-        int Cj, short Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned short Ax, int Bp, int Bj, unsigned short Bx, 
-        int Cp, int Cj, unsigned short Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        int Ax, int Bp, int Bj, int Bx, int Cp, int Cj, 
-        int Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned int Ax, int Bp, int Bj, unsigned int Bx, 
-        int Cp, int Cj, unsigned int Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        long long Ax, int Bp, int Bj, long long Bx, 
-        int Cp, int Cj, long long Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax, int Bp, int Bj, unsigned long long Bx, 
-        int Cp, int Cj, unsigned long long Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        float Ax, int Bp, int Bj, float Bx, int Cp, 
-        int Cj, float Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        double Ax, int Bp, int Bj, double Bx, int Cp, 
-        int Cj, double Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        long double Ax, int Bp, int Bj, long double Bx, 
-        int Cp, int Cj, long double Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx, 
-        int Cp, int Cj, npy_cfloat_wrapper Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx, 
-        int Cp, int Cj, npy_cdouble_wrapper Cx)
-    bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax, int Bp, int Bj, 
-        npy_clongdouble_wrapper Bx, int Cp, int Cj, npy_clongdouble_wrapper Cx)
     """
-  return _bsr.bsr_eldiv_bsr(*args)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          signed char Ax, int Bp, int Bj, signed char Bx,
+          int Cp, int Cj, signed char Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned char Ax, int Bp, int Bj, unsigned char Bx,
+          int Cp, int Cj, unsigned char Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          short Ax, int Bp, int Bj, short Bx, int Cp,
+          int Cj, short Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned short Ax, int Bp, int Bj, unsigned short Bx,
+          int Cp, int Cj, unsigned short Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          int Ax, int Bp, int Bj, int Bx, int Cp, int Cj,
+          int Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned int Ax, int Bp, int Bj, unsigned int Bx,
+          int Cp, int Cj, unsigned int Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          long long Ax, int Bp, int Bj, long long Bx,
+          int Cp, int Cj, long long Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned long long Ax, int Bp, int Bj, unsigned long long Bx,
+          int Cp, int Cj, unsigned long long Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          float Ax, int Bp, int Bj, float Bx, int Cp,
+          int Cj, float Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          double Ax, int Bp, int Bj, double Bx, int Cp,
+          int Cj, double Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          long double Ax, int Bp, int Bj, long double Bx,
+          int Cp, int Cj, long double Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx,
+          int Cp, int Cj, npy_cfloat_wrapper Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx,
+          int Cp, int Cj, npy_cdouble_wrapper Cx)
+      bsr_eldiv_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax, int Bp, int Bj,
+          npy_clongdouble_wrapper Bx, int Cp, int Cj, npy_clongdouble_wrapper Cx)
+      """
+    return _bsr.bsr_eldiv_bsr(*args)
 
 def bsr_plus_bsr(*args):
-  """
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        signed char Ax, int Bp, int Bj, signed char Bx, 
-        int Cp, int Cj, signed char Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned char Ax, int Bp, int Bj, unsigned char Bx, 
-        int Cp, int Cj, unsigned char Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        short Ax, int Bp, int Bj, short Bx, int Cp, 
-        int Cj, short Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned short Ax, int Bp, int Bj, unsigned short Bx, 
-        int Cp, int Cj, unsigned short Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        int Ax, int Bp, int Bj, int Bx, int Cp, int Cj, 
-        int Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned int Ax, int Bp, int Bj, unsigned int Bx, 
-        int Cp, int Cj, unsigned int Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        long long Ax, int Bp, int Bj, long long Bx, 
-        int Cp, int Cj, long long Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax, int Bp, int Bj, unsigned long long Bx, 
-        int Cp, int Cj, unsigned long long Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        float Ax, int Bp, int Bj, float Bx, int Cp, 
-        int Cj, float Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        double Ax, int Bp, int Bj, double Bx, int Cp, 
-        int Cj, double Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        long double Ax, int Bp, int Bj, long double Bx, 
-        int Cp, int Cj, long double Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx, 
-        int Cp, int Cj, npy_cfloat_wrapper Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx, 
-        int Cp, int Cj, npy_cdouble_wrapper Cx)
-    bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax, int Bp, int Bj, 
-        npy_clongdouble_wrapper Bx, int Cp, int Cj, npy_clongdouble_wrapper Cx)
     """
-  return _bsr.bsr_plus_bsr(*args)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          signed char Ax, int Bp, int Bj, signed char Bx,
+          int Cp, int Cj, signed char Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned char Ax, int Bp, int Bj, unsigned char Bx,
+          int Cp, int Cj, unsigned char Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          short Ax, int Bp, int Bj, short Bx, int Cp,
+          int Cj, short Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned short Ax, int Bp, int Bj, unsigned short Bx,
+          int Cp, int Cj, unsigned short Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          int Ax, int Bp, int Bj, int Bx, int Cp, int Cj,
+          int Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned int Ax, int Bp, int Bj, unsigned int Bx,
+          int Cp, int Cj, unsigned int Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          long long Ax, int Bp, int Bj, long long Bx,
+          int Cp, int Cj, long long Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned long long Ax, int Bp, int Bj, unsigned long long Bx,
+          int Cp, int Cj, unsigned long long Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          float Ax, int Bp, int Bj, float Bx, int Cp,
+          int Cj, float Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          double Ax, int Bp, int Bj, double Bx, int Cp,
+          int Cj, double Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          long double Ax, int Bp, int Bj, long double Bx,
+          int Cp, int Cj, long double Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx,
+          int Cp, int Cj, npy_cfloat_wrapper Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx,
+          int Cp, int Cj, npy_cdouble_wrapper Cx)
+      bsr_plus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax, int Bp, int Bj,
+          npy_clongdouble_wrapper Bx, int Cp, int Cj, npy_clongdouble_wrapper Cx)
+      """
+    return _bsr.bsr_plus_bsr(*args)
 
 def bsr_minus_bsr(*args):
-  """
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        signed char Ax, int Bp, int Bj, signed char Bx, 
-        int Cp, int Cj, signed char Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned char Ax, int Bp, int Bj, unsigned char Bx, 
-        int Cp, int Cj, unsigned char Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        short Ax, int Bp, int Bj, short Bx, int Cp, 
-        int Cj, short Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned short Ax, int Bp, int Bj, unsigned short Bx, 
-        int Cp, int Cj, unsigned short Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        int Ax, int Bp, int Bj, int Bx, int Cp, int Cj, 
-        int Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned int Ax, int Bp, int Bj, unsigned int Bx, 
-        int Cp, int Cj, unsigned int Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        long long Ax, int Bp, int Bj, long long Bx, 
-        int Cp, int Cj, long long Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax, int Bp, int Bj, unsigned long long Bx, 
-        int Cp, int Cj, unsigned long long Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        float Ax, int Bp, int Bj, float Bx, int Cp, 
-        int Cj, float Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        double Ax, int Bp, int Bj, double Bx, int Cp, 
-        int Cj, double Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        long double Ax, int Bp, int Bj, long double Bx, 
-        int Cp, int Cj, long double Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx, 
-        int Cp, int Cj, npy_cfloat_wrapper Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx, 
-        int Cp, int Cj, npy_cdouble_wrapper Cx)
-    bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax, int Bp, int Bj, 
-        npy_clongdouble_wrapper Bx, int Cp, int Cj, npy_clongdouble_wrapper Cx)
     """
-  return _bsr.bsr_minus_bsr(*args)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          signed char Ax, int Bp, int Bj, signed char Bx,
+          int Cp, int Cj, signed char Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned char Ax, int Bp, int Bj, unsigned char Bx,
+          int Cp, int Cj, unsigned char Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          short Ax, int Bp, int Bj, short Bx, int Cp,
+          int Cj, short Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned short Ax, int Bp, int Bj, unsigned short Bx,
+          int Cp, int Cj, unsigned short Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          int Ax, int Bp, int Bj, int Bx, int Cp, int Cj,
+          int Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned int Ax, int Bp, int Bj, unsigned int Bx,
+          int Cp, int Cj, unsigned int Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          long long Ax, int Bp, int Bj, long long Bx,
+          int Cp, int Cj, long long Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned long long Ax, int Bp, int Bj, unsigned long long Bx,
+          int Cp, int Cj, unsigned long long Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          float Ax, int Bp, int Bj, float Bx, int Cp,
+          int Cj, float Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          double Ax, int Bp, int Bj, double Bx, int Cp,
+          int Cj, double Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          long double Ax, int Bp, int Bj, long double Bx,
+          int Cp, int Cj, long double Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx,
+          int Cp, int Cj, npy_cfloat_wrapper Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx,
+          int Cp, int Cj, npy_cdouble_wrapper Cx)
+      bsr_minus_bsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax, int Bp, int Bj,
+          npy_clongdouble_wrapper Bx, int Cp, int Cj, npy_clongdouble_wrapper Cx)
+      """
+    return _bsr.bsr_minus_bsr(*args)
 
 def bsr_sort_indices(*args):
-  """
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        signed char Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned char Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        short Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned short Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        int Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned int Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long long Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        float Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        double Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        long double Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax)
-    bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax)
     """
-  return _bsr.bsr_sort_indices(*args)
-
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          signed char Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned char Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          short Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned short Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          int Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned int Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long long Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          unsigned long long Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          float Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          double Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          long double Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax)
+      bsr_sort_indices(int n_brow, int n_bcol, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax)
+      """
+    return _bsr.bsr_sort_indices(*args)

Modified: trunk/scipy/sparse/sparsetools/coo.py
===================================================================
--- trunk/scipy/sparse/sparsetools/coo.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/sparsetools/coo.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -51,130 +51,129 @@
 
 
 def coo_tocsr(*args):
-  """
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, signed char Ax, 
-        int Bp, int Bj, signed char Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned char Ax, 
-        int Bp, int Bj, unsigned char Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, short Ax, 
-        int Bp, int Bj, short Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned short Ax, 
-        int Bp, int Bj, unsigned short Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, int Ax, 
-        int Bp, int Bj, int Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned int Ax, 
-        int Bp, int Bj, unsigned int Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, long long Ax, 
-        int Bp, int Bj, long long Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned long long Ax, 
-        int Bp, int Bj, unsigned long long Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, float Ax, 
-        int Bp, int Bj, float Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, double Ax, 
-        int Bp, int Bj, double Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, long double Ax, 
-        int Bp, int Bj, long double Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cfloat_wrapper Ax, 
-        int Bp, int Bj, npy_cfloat_wrapper Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cdouble_wrapper Ax, 
-        int Bp, int Bj, npy_cdouble_wrapper Bx)
-    coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bj, npy_clongdouble_wrapper Bx)
     """
-  return _coo.coo_tocsr(*args)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, signed char Ax,
+          int Bp, int Bj, signed char Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned char Ax,
+          int Bp, int Bj, unsigned char Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, short Ax,
+          int Bp, int Bj, short Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned short Ax,
+          int Bp, int Bj, unsigned short Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, int Ax,
+          int Bp, int Bj, int Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned int Ax,
+          int Bp, int Bj, unsigned int Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, long long Ax,
+          int Bp, int Bj, long long Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned long long Ax,
+          int Bp, int Bj, unsigned long long Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, float Ax,
+          int Bp, int Bj, float Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, double Ax,
+          int Bp, int Bj, double Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, long double Ax,
+          int Bp, int Bj, long double Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cfloat_wrapper Ax,
+          int Bp, int Bj, npy_cfloat_wrapper Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cdouble_wrapper Ax,
+          int Bp, int Bj, npy_cdouble_wrapper Bx)
+      coo_tocsr(int n_row, int n_col, int nnz, int Ai, int Aj, npy_clongdouble_wrapper Ax,
+          int Bp, int Bj, npy_clongdouble_wrapper Bx)
+      """
+    return _coo.coo_tocsr(*args)
 
 def coo_tocsc(*args):
-  """
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, signed char Ax, 
-        int Bp, int Bi, signed char Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned char Ax, 
-        int Bp, int Bi, unsigned char Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, short Ax, 
-        int Bp, int Bi, short Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned short Ax, 
-        int Bp, int Bi, unsigned short Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, int Ax, 
-        int Bp, int Bi, int Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned int Ax, 
-        int Bp, int Bi, unsigned int Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, long long Ax, 
-        int Bp, int Bi, long long Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned long long Ax, 
-        int Bp, int Bi, unsigned long long Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, float Ax, 
-        int Bp, int Bi, float Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, double Ax, 
-        int Bp, int Bi, double Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, long double Ax, 
-        int Bp, int Bi, long double Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cfloat_wrapper Ax, 
-        int Bp, int Bi, npy_cfloat_wrapper Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cdouble_wrapper Ax, 
-        int Bp, int Bi, npy_cdouble_wrapper Bx)
-    coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bi, npy_clongdouble_wrapper Bx)
     """
-  return _coo.coo_tocsc(*args)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, signed char Ax,
+          int Bp, int Bi, signed char Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned char Ax,
+          int Bp, int Bi, unsigned char Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, short Ax,
+          int Bp, int Bi, short Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned short Ax,
+          int Bp, int Bi, unsigned short Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, int Ax,
+          int Bp, int Bi, int Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned int Ax,
+          int Bp, int Bi, unsigned int Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, long long Ax,
+          int Bp, int Bi, long long Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned long long Ax,
+          int Bp, int Bi, unsigned long long Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, float Ax,
+          int Bp, int Bi, float Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, double Ax,
+          int Bp, int Bi, double Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, long double Ax,
+          int Bp, int Bi, long double Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cfloat_wrapper Ax,
+          int Bp, int Bi, npy_cfloat_wrapper Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cdouble_wrapper Ax,
+          int Bp, int Bi, npy_cdouble_wrapper Bx)
+      coo_tocsc(int n_row, int n_col, int nnz, int Ai, int Aj, npy_clongdouble_wrapper Ax,
+          int Bp, int Bi, npy_clongdouble_wrapper Bx)
+      """
+    return _coo.coo_tocsc(*args)
 
 def coo_todense(*args):
-  """
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, signed char Ax, 
-        signed char Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned char Ax, 
-        unsigned char Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, short Ax, 
-        short Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned short Ax, 
-        unsigned short Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, int Ax, 
-        int Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned int Ax, 
-        unsigned int Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, long long Ax, 
-        long long Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned long long Ax, 
-        unsigned long long Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, float Ax, 
-        float Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, double Ax, 
-        double Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, long double Ax, 
-        long double Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cfloat_wrapper Ax, 
-        npy_cfloat_wrapper Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cdouble_wrapper Ax, 
-        npy_cdouble_wrapper Bx)
-    coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, npy_clongdouble_wrapper Ax, 
-        npy_clongdouble_wrapper Bx)
     """
-  return _coo.coo_todense(*args)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, signed char Ax,
+          signed char Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned char Ax,
+          unsigned char Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, short Ax,
+          short Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned short Ax,
+          unsigned short Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, int Ax,
+          int Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned int Ax,
+          unsigned int Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, long long Ax,
+          long long Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, unsigned long long Ax,
+          unsigned long long Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, float Ax,
+          float Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, double Ax,
+          double Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, long double Ax,
+          long double Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cfloat_wrapper Ax,
+          npy_cfloat_wrapper Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, npy_cdouble_wrapper Ax,
+          npy_cdouble_wrapper Bx)
+      coo_todense(int n_row, int n_col, int nnz, int Ai, int Aj, npy_clongdouble_wrapper Ax,
+          npy_clongdouble_wrapper Bx)
+      """
+    return _coo.coo_todense(*args)
 
 def coo_matvec(*args):
-  """
-    coo_matvec(int nnz, int Ai, int Aj, signed char Ax, signed char Xx, 
-        signed char Yx)
-    coo_matvec(int nnz, int Ai, int Aj, unsigned char Ax, unsigned char Xx, 
-        unsigned char Yx)
-    coo_matvec(int nnz, int Ai, int Aj, short Ax, short Xx, short Yx)
-    coo_matvec(int nnz, int Ai, int Aj, unsigned short Ax, unsigned short Xx, 
-        unsigned short Yx)
-    coo_matvec(int nnz, int Ai, int Aj, int Ax, int Xx, int Yx)
-    coo_matvec(int nnz, int Ai, int Aj, unsigned int Ax, unsigned int Xx, 
-        unsigned int Yx)
-    coo_matvec(int nnz, int Ai, int Aj, long long Ax, long long Xx, 
-        long long Yx)
-    coo_matvec(int nnz, int Ai, int Aj, unsigned long long Ax, unsigned long long Xx, 
-        unsigned long long Yx)
-    coo_matvec(int nnz, int Ai, int Aj, float Ax, float Xx, float Yx)
-    coo_matvec(int nnz, int Ai, int Aj, double Ax, double Xx, double Yx)
-    coo_matvec(int nnz, int Ai, int Aj, long double Ax, long double Xx, 
-        long double Yx)
-    coo_matvec(int nnz, int Ai, int Aj, npy_cfloat_wrapper Ax, npy_cfloat_wrapper Xx, 
-        npy_cfloat_wrapper Yx)
-    coo_matvec(int nnz, int Ai, int Aj, npy_cdouble_wrapper Ax, npy_cdouble_wrapper Xx, 
-        npy_cdouble_wrapper Yx)
-    coo_matvec(int nnz, int Ai, int Aj, npy_clongdouble_wrapper Ax, 
-        npy_clongdouble_wrapper Xx, npy_clongdouble_wrapper Yx)
     """
-  return _coo.coo_matvec(*args)
-
+      coo_matvec(int nnz, int Ai, int Aj, signed char Ax, signed char Xx,
+          signed char Yx)
+      coo_matvec(int nnz, int Ai, int Aj, unsigned char Ax, unsigned char Xx,
+          unsigned char Yx)
+      coo_matvec(int nnz, int Ai, int Aj, short Ax, short Xx, short Yx)
+      coo_matvec(int nnz, int Ai, int Aj, unsigned short Ax, unsigned short Xx,
+          unsigned short Yx)
+      coo_matvec(int nnz, int Ai, int Aj, int Ax, int Xx, int Yx)
+      coo_matvec(int nnz, int Ai, int Aj, unsigned int Ax, unsigned int Xx,
+          unsigned int Yx)
+      coo_matvec(int nnz, int Ai, int Aj, long long Ax, long long Xx,
+          long long Yx)
+      coo_matvec(int nnz, int Ai, int Aj, unsigned long long Ax, unsigned long long Xx,
+          unsigned long long Yx)
+      coo_matvec(int nnz, int Ai, int Aj, float Ax, float Xx, float Yx)
+      coo_matvec(int nnz, int Ai, int Aj, double Ax, double Xx, double Yx)
+      coo_matvec(int nnz, int Ai, int Aj, long double Ax, long double Xx,
+          long double Yx)
+      coo_matvec(int nnz, int Ai, int Aj, npy_cfloat_wrapper Ax, npy_cfloat_wrapper Xx,
+          npy_cfloat_wrapper Yx)
+      coo_matvec(int nnz, int Ai, int Aj, npy_cdouble_wrapper Ax, npy_cdouble_wrapper Xx,
+          npy_cdouble_wrapper Yx)
+      coo_matvec(int nnz, int Ai, int Aj, npy_clongdouble_wrapper Ax,
+          npy_clongdouble_wrapper Xx, npy_clongdouble_wrapper Yx)
+      """
+    return _coo.coo_matvec(*args)

Modified: trunk/scipy/sparse/sparsetools/csc.py
===================================================================
--- trunk/scipy/sparse/sparsetools/csc.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/sparsetools/csc.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -50,357 +50,356 @@
 
 
 def csc_matmat_pass1(*args):
-  """
-    csc_matmat_pass1(int n_row, int n_col, int Ap, int Ai, int Bp, int Bi, 
-        int Cp)
     """
-  return _csc.csc_matmat_pass1(*args)
+      csc_matmat_pass1(int n_row, int n_col, int Ap, int Ai, int Bp, int Bi,
+          int Cp)
+      """
+    return _csc.csc_matmat_pass1(*args)
 
 
 def csc_diagonal(*args):
-  """
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        signed char Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        unsigned char Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, short Ax, short Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        unsigned short Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, int Ax, int Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        unsigned int Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        long long Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        unsigned long long Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, float Ax, float Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, double Ax, double Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        long double Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        npy_cfloat_wrapper Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        npy_cdouble_wrapper Yx)
-    csc_diagonal(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        npy_clongdouble_wrapper Yx)
     """
-  return _csc.csc_diagonal(*args)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          signed char Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          unsigned char Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, short Ax, short Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          unsigned short Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, int Ax, int Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          unsigned int Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          long long Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          unsigned long long Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, float Ax, float Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, double Ax, double Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          long double Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          npy_cfloat_wrapper Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          npy_cdouble_wrapper Yx)
+      csc_diagonal(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          npy_clongdouble_wrapper Yx)
+      """
+    return _csc.csc_diagonal(*args)
 
 def csc_tocsr(*args):
-  """
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, signed char Ax, 
-        int Bp, int Bj, signed char Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, unsigned char Ax, 
-        int Bp, int Bj, unsigned char Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp, 
-        int Bj, short Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, unsigned short Ax, 
-        int Bp, int Bj, unsigned short Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp, 
-        int Bj, int Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, unsigned int Ax, 
-        int Bp, int Bj, unsigned int Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, long long Ax, 
-        int Bp, int Bj, long long Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax, 
-        int Bp, int Bj, unsigned long long Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp, 
-        int Bj, float Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp, 
-        int Bj, double Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, long double Ax, 
-        int Bp, int Bj, long double Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax, 
-        int Bp, int Bj, npy_cfloat_wrapper Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax, 
-        int Bp, int Bj, npy_cdouble_wrapper Bx)
-    csc_tocsr(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bj, npy_clongdouble_wrapper Bx)
     """
-  return _csc.csc_tocsr(*args)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, signed char Ax,
+          int Bp, int Bj, signed char Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, unsigned char Ax,
+          int Bp, int Bj, unsigned char Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp,
+          int Bj, short Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, unsigned short Ax,
+          int Bp, int Bj, unsigned short Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp,
+          int Bj, int Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, unsigned int Ax,
+          int Bp, int Bj, unsigned int Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, long long Ax,
+          int Bp, int Bj, long long Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax,
+          int Bp, int Bj, unsigned long long Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp,
+          int Bj, float Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp,
+          int Bj, double Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, long double Ax,
+          int Bp, int Bj, long double Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax,
+          int Bp, int Bj, npy_cfloat_wrapper Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax,
+          int Bp, int Bj, npy_cdouble_wrapper Bx)
+      csc_tocsr(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax,
+          int Bp, int Bj, npy_clongdouble_wrapper Bx)
+      """
+    return _csc.csc_tocsr(*args)
 
 def csc_matmat_pass2(*args):
-  """
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, signed char Ax, 
-        int Bp, int Bi, signed char Bx, int Cp, int Ci, 
-        signed char Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, unsigned char Ax, 
-        int Bp, int Bi, unsigned char Bx, int Cp, 
-        int Ci, unsigned char Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp, 
-        int Bi, short Bx, int Cp, int Ci, short Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, unsigned short Ax, 
-        int Bp, int Bi, unsigned short Bx, int Cp, 
-        int Ci, unsigned short Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp, 
-        int Bi, int Bx, int Cp, int Ci, int Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, unsigned int Ax, 
-        int Bp, int Bi, unsigned int Bx, int Cp, 
-        int Ci, unsigned int Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, long long Ax, 
-        int Bp, int Bi, long long Bx, int Cp, int Ci, 
-        long long Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax, 
-        int Bp, int Bi, unsigned long long Bx, 
-        int Cp, int Ci, unsigned long long Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp, 
-        int Bi, float Bx, int Cp, int Ci, float Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp, 
-        int Bi, double Bx, int Cp, int Ci, double Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, long double Ax, 
-        int Bp, int Bi, long double Bx, int Cp, int Ci, 
-        long double Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax, 
-        int Bp, int Bi, npy_cfloat_wrapper Bx, 
-        int Cp, int Ci, npy_cfloat_wrapper Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax, 
-        int Bp, int Bi, npy_cdouble_wrapper Bx, 
-        int Cp, int Ci, npy_cdouble_wrapper Cx)
-    csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bi, npy_clongdouble_wrapper Bx, 
-        int Cp, int Ci, npy_clongdouble_wrapper Cx)
     """
-  return _csc.csc_matmat_pass2(*args)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, signed char Ax,
+          int Bp, int Bi, signed char Bx, int Cp, int Ci,
+          signed char Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, unsigned char Ax,
+          int Bp, int Bi, unsigned char Bx, int Cp,
+          int Ci, unsigned char Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp,
+          int Bi, short Bx, int Cp, int Ci, short Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, unsigned short Ax,
+          int Bp, int Bi, unsigned short Bx, int Cp,
+          int Ci, unsigned short Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp,
+          int Bi, int Bx, int Cp, int Ci, int Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, unsigned int Ax,
+          int Bp, int Bi, unsigned int Bx, int Cp,
+          int Ci, unsigned int Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, long long Ax,
+          int Bp, int Bi, long long Bx, int Cp, int Ci,
+          long long Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax,
+          int Bp, int Bi, unsigned long long Bx,
+          int Cp, int Ci, unsigned long long Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp,
+          int Bi, float Bx, int Cp, int Ci, float Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp,
+          int Bi, double Bx, int Cp, int Ci, double Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, long double Ax,
+          int Bp, int Bi, long double Bx, int Cp, int Ci,
+          long double Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax,
+          int Bp, int Bi, npy_cfloat_wrapper Bx,
+          int Cp, int Ci, npy_cfloat_wrapper Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax,
+          int Bp, int Bi, npy_cdouble_wrapper Bx,
+          int Cp, int Ci, npy_cdouble_wrapper Cx)
+      csc_matmat_pass2(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax,
+          int Bp, int Bi, npy_clongdouble_wrapper Bx,
+          int Cp, int Ci, npy_clongdouble_wrapper Cx)
+      """
+    return _csc.csc_matmat_pass2(*args)
 
 def csc_matvec(*args):
-  """
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, signed char Ax, 
-        signed char Xx, signed char Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, unsigned char Ax, 
-        unsigned char Xx, unsigned char Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, short Ax, short Xx, 
-        short Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, unsigned short Ax, 
-        unsigned short Xx, unsigned short Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, int Ax, int Xx, 
-        int Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, unsigned int Ax, 
-        unsigned int Xx, unsigned int Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, long long Ax, 
-        long long Xx, long long Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax, 
-        unsigned long long Xx, unsigned long long Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, float Ax, float Xx, 
-        float Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, double Ax, double Xx, 
-        double Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, long double Ax, 
-        long double Xx, long double Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax, 
-        npy_cfloat_wrapper Xx, npy_cfloat_wrapper Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax, 
-        npy_cdouble_wrapper Xx, npy_cdouble_wrapper Yx)
-    csc_matvec(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax, 
-        npy_clongdouble_wrapper Xx, npy_clongdouble_wrapper Yx)
     """
-  return _csc.csc_matvec(*args)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, signed char Ax,
+          signed char Xx, signed char Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, unsigned char Ax,
+          unsigned char Xx, unsigned char Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, short Ax, short Xx,
+          short Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, unsigned short Ax,
+          unsigned short Xx, unsigned short Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, int Ax, int Xx,
+          int Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, unsigned int Ax,
+          unsigned int Xx, unsigned int Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, long long Ax,
+          long long Xx, long long Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax,
+          unsigned long long Xx, unsigned long long Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, float Ax, float Xx,
+          float Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, double Ax, double Xx,
+          double Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, long double Ax,
+          long double Xx, long double Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax,
+          npy_cfloat_wrapper Xx, npy_cfloat_wrapper Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax,
+          npy_cdouble_wrapper Xx, npy_cdouble_wrapper Yx)
+      csc_matvec(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax,
+          npy_clongdouble_wrapper Xx, npy_clongdouble_wrapper Yx)
+      """
+    return _csc.csc_matvec(*args)
 
 def csc_matvecs(*args):
-  """
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, signed char Ax, 
-        signed char Xx, signed char Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, unsigned char Ax, 
-        unsigned char Xx, unsigned char Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, short Ax, 
-        short Xx, short Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, unsigned short Ax, 
-        unsigned short Xx, unsigned short Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, int Ax, 
-        int Xx, int Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, unsigned int Ax, 
-        unsigned int Xx, unsigned int Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, long long Ax, 
-        long long Xx, long long Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, unsigned long long Ax, 
-        unsigned long long Xx, 
-        unsigned long long Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, float Ax, 
-        float Xx, float Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, double Ax, 
-        double Xx, double Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, long double Ax, 
-        long double Xx, long double Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, npy_cfloat_wrapper Ax, 
-        npy_cfloat_wrapper Xx, 
-        npy_cfloat_wrapper Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, npy_cdouble_wrapper Ax, 
-        npy_cdouble_wrapper Xx, 
-        npy_cdouble_wrapper Yx)
-    csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, npy_clongdouble_wrapper Ax, 
-        npy_clongdouble_wrapper Xx, 
-        npy_clongdouble_wrapper Yx)
     """
-  return _csc.csc_matvecs(*args)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, signed char Ax,
+          signed char Xx, signed char Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, unsigned char Ax,
+          unsigned char Xx, unsigned char Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, short Ax,
+          short Xx, short Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, unsigned short Ax,
+          unsigned short Xx, unsigned short Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, int Ax,
+          int Xx, int Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, unsigned int Ax,
+          unsigned int Xx, unsigned int Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, long long Ax,
+          long long Xx, long long Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, unsigned long long Ax,
+          unsigned long long Xx,
+          unsigned long long Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, float Ax,
+          float Xx, float Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, double Ax,
+          double Xx, double Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, long double Ax,
+          long double Xx, long double Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, npy_cfloat_wrapper Ax,
+          npy_cfloat_wrapper Xx,
+          npy_cfloat_wrapper Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, npy_cdouble_wrapper Ax,
+          npy_cdouble_wrapper Xx,
+          npy_cdouble_wrapper Yx)
+      csc_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Ai, npy_clongdouble_wrapper Ax,
+          npy_clongdouble_wrapper Xx,
+          npy_clongdouble_wrapper Yx)
+      """
+    return _csc.csc_matvecs(*args)
 
 def csc_elmul_csc(*args):
-  """
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, signed char Ax, 
-        int Bp, int Bi, signed char Bx, int Cp, int Ci, 
-        signed char Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, unsigned char Ax, 
-        int Bp, int Bi, unsigned char Bx, int Cp, 
-        int Ci, unsigned char Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp, 
-        int Bi, short Bx, int Cp, int Ci, short Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, unsigned short Ax, 
-        int Bp, int Bi, unsigned short Bx, int Cp, 
-        int Ci, unsigned short Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp, 
-        int Bi, int Bx, int Cp, int Ci, int Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, unsigned int Ax, 
-        int Bp, int Bi, unsigned int Bx, int Cp, 
-        int Ci, unsigned int Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, long long Ax, 
-        int Bp, int Bi, long long Bx, int Cp, int Ci, 
-        long long Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax, 
-        int Bp, int Bi, unsigned long long Bx, 
-        int Cp, int Ci, unsigned long long Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp, 
-        int Bi, float Bx, int Cp, int Ci, float Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp, 
-        int Bi, double Bx, int Cp, int Ci, double Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, long double Ax, 
-        int Bp, int Bi, long double Bx, int Cp, int Ci, 
-        long double Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax, 
-        int Bp, int Bi, npy_cfloat_wrapper Bx, 
-        int Cp, int Ci, npy_cfloat_wrapper Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax, 
-        int Bp, int Bi, npy_cdouble_wrapper Bx, 
-        int Cp, int Ci, npy_cdouble_wrapper Cx)
-    csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bi, npy_clongdouble_wrapper Bx, 
-        int Cp, int Ci, npy_clongdouble_wrapper Cx)
     """
-  return _csc.csc_elmul_csc(*args)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, signed char Ax,
+          int Bp, int Bi, signed char Bx, int Cp, int Ci,
+          signed char Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, unsigned char Ax,
+          int Bp, int Bi, unsigned char Bx, int Cp,
+          int Ci, unsigned char Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp,
+          int Bi, short Bx, int Cp, int Ci, short Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, unsigned short Ax,
+          int Bp, int Bi, unsigned short Bx, int Cp,
+          int Ci, unsigned short Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp,
+          int Bi, int Bx, int Cp, int Ci, int Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, unsigned int Ax,
+          int Bp, int Bi, unsigned int Bx, int Cp,
+          int Ci, unsigned int Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, long long Ax,
+          int Bp, int Bi, long long Bx, int Cp, int Ci,
+          long long Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax,
+          int Bp, int Bi, unsigned long long Bx,
+          int Cp, int Ci, unsigned long long Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp,
+          int Bi, float Bx, int Cp, int Ci, float Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp,
+          int Bi, double Bx, int Cp, int Ci, double Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, long double Ax,
+          int Bp, int Bi, long double Bx, int Cp, int Ci,
+          long double Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax,
+          int Bp, int Bi, npy_cfloat_wrapper Bx,
+          int Cp, int Ci, npy_cfloat_wrapper Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax,
+          int Bp, int Bi, npy_cdouble_wrapper Bx,
+          int Cp, int Ci, npy_cdouble_wrapper Cx)
+      csc_elmul_csc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax,
+          int Bp, int Bi, npy_clongdouble_wrapper Bx,
+          int Cp, int Ci, npy_clongdouble_wrapper Cx)
+      """
+    return _csc.csc_elmul_csc(*args)
 
 def csc_eldiv_csc(*args):
-  """
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, signed char Ax, 
-        int Bp, int Bi, signed char Bx, int Cp, int Ci, 
-        signed char Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, unsigned char Ax, 
-        int Bp, int Bi, unsigned char Bx, int Cp, 
-        int Ci, unsigned char Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp, 
-        int Bi, short Bx, int Cp, int Ci, short Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, unsigned short Ax, 
-        int Bp, int Bi, unsigned short Bx, int Cp, 
-        int Ci, unsigned short Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp, 
-        int Bi, int Bx, int Cp, int Ci, int Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, unsigned int Ax, 
-        int Bp, int Bi, unsigned int Bx, int Cp, 
-        int Ci, unsigned int Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, long long Ax, 
-        int Bp, int Bi, long long Bx, int Cp, int Ci, 
-        long long Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax, 
-        int Bp, int Bi, unsigned long long Bx, 
-        int Cp, int Ci, unsigned long long Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp, 
-        int Bi, float Bx, int Cp, int Ci, float Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp, 
-        int Bi, double Bx, int Cp, int Ci, double Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, long double Ax, 
-        int Bp, int Bi, long double Bx, int Cp, int Ci, 
-        long double Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax, 
-        int Bp, int Bi, npy_cfloat_wrapper Bx, 
-        int Cp, int Ci, npy_cfloat_wrapper Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax, 
-        int Bp, int Bi, npy_cdouble_wrapper Bx, 
-        int Cp, int Ci, npy_cdouble_wrapper Cx)
-    csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bi, npy_clongdouble_wrapper Bx, 
-        int Cp, int Ci, npy_clongdouble_wrapper Cx)
     """
-  return _csc.csc_eldiv_csc(*args)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, signed char Ax,
+          int Bp, int Bi, signed char Bx, int Cp, int Ci,
+          signed char Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, unsigned char Ax,
+          int Bp, int Bi, unsigned char Bx, int Cp,
+          int Ci, unsigned char Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp,
+          int Bi, short Bx, int Cp, int Ci, short Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, unsigned short Ax,
+          int Bp, int Bi, unsigned short Bx, int Cp,
+          int Ci, unsigned short Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp,
+          int Bi, int Bx, int Cp, int Ci, int Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, unsigned int Ax,
+          int Bp, int Bi, unsigned int Bx, int Cp,
+          int Ci, unsigned int Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, long long Ax,
+          int Bp, int Bi, long long Bx, int Cp, int Ci,
+          long long Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax,
+          int Bp, int Bi, unsigned long long Bx,
+          int Cp, int Ci, unsigned long long Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp,
+          int Bi, float Bx, int Cp, int Ci, float Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp,
+          int Bi, double Bx, int Cp, int Ci, double Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, long double Ax,
+          int Bp, int Bi, long double Bx, int Cp, int Ci,
+          long double Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax,
+          int Bp, int Bi, npy_cfloat_wrapper Bx,
+          int Cp, int Ci, npy_cfloat_wrapper Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax,
+          int Bp, int Bi, npy_cdouble_wrapper Bx,
+          int Cp, int Ci, npy_cdouble_wrapper Cx)
+      csc_eldiv_csc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax,
+          int Bp, int Bi, npy_clongdouble_wrapper Bx,
+          int Cp, int Ci, npy_clongdouble_wrapper Cx)
+      """
+    return _csc.csc_eldiv_csc(*args)
 
 def csc_plus_csc(*args):
-  """
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, signed char Ax, 
-        int Bp, int Bi, signed char Bx, int Cp, int Ci, 
-        signed char Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, unsigned char Ax, 
-        int Bp, int Bi, unsigned char Bx, int Cp, 
-        int Ci, unsigned char Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp, 
-        int Bi, short Bx, int Cp, int Ci, short Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, unsigned short Ax, 
-        int Bp, int Bi, unsigned short Bx, int Cp, 
-        int Ci, unsigned short Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp, 
-        int Bi, int Bx, int Cp, int Ci, int Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, unsigned int Ax, 
-        int Bp, int Bi, unsigned int Bx, int Cp, 
-        int Ci, unsigned int Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, long long Ax, 
-        int Bp, int Bi, long long Bx, int Cp, int Ci, 
-        long long Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax, 
-        int Bp, int Bi, unsigned long long Bx, 
-        int Cp, int Ci, unsigned long long Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp, 
-        int Bi, float Bx, int Cp, int Ci, float Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp, 
-        int Bi, double Bx, int Cp, int Ci, double Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, long double Ax, 
-        int Bp, int Bi, long double Bx, int Cp, int Ci, 
-        long double Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax, 
-        int Bp, int Bi, npy_cfloat_wrapper Bx, 
-        int Cp, int Ci, npy_cfloat_wrapper Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax, 
-        int Bp, int Bi, npy_cdouble_wrapper Bx, 
-        int Cp, int Ci, npy_cdouble_wrapper Cx)
-    csc_plus_csc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bi, npy_clongdouble_wrapper Bx, 
-        int Cp, int Ci, npy_clongdouble_wrapper Cx)
     """
-  return _csc.csc_plus_csc(*args)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, signed char Ax,
+          int Bp, int Bi, signed char Bx, int Cp, int Ci,
+          signed char Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, unsigned char Ax,
+          int Bp, int Bi, unsigned char Bx, int Cp,
+          int Ci, unsigned char Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp,
+          int Bi, short Bx, int Cp, int Ci, short Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, unsigned short Ax,
+          int Bp, int Bi, unsigned short Bx, int Cp,
+          int Ci, unsigned short Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp,
+          int Bi, int Bx, int Cp, int Ci, int Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, unsigned int Ax,
+          int Bp, int Bi, unsigned int Bx, int Cp,
+          int Ci, unsigned int Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, long long Ax,
+          int Bp, int Bi, long long Bx, int Cp, int Ci,
+          long long Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax,
+          int Bp, int Bi, unsigned long long Bx,
+          int Cp, int Ci, unsigned long long Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp,
+          int Bi, float Bx, int Cp, int Ci, float Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp,
+          int Bi, double Bx, int Cp, int Ci, double Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, long double Ax,
+          int Bp, int Bi, long double Bx, int Cp, int Ci,
+          long double Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax,
+          int Bp, int Bi, npy_cfloat_wrapper Bx,
+          int Cp, int Ci, npy_cfloat_wrapper Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax,
+          int Bp, int Bi, npy_cdouble_wrapper Bx,
+          int Cp, int Ci, npy_cdouble_wrapper Cx)
+      csc_plus_csc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax,
+          int Bp, int Bi, npy_clongdouble_wrapper Bx,
+          int Cp, int Ci, npy_clongdouble_wrapper Cx)
+      """
+    return _csc.csc_plus_csc(*args)
 
 def csc_minus_csc(*args):
-  """
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, signed char Ax, 
-        int Bp, int Bi, signed char Bx, int Cp, int Ci, 
-        signed char Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, unsigned char Ax, 
-        int Bp, int Bi, unsigned char Bx, int Cp, 
-        int Ci, unsigned char Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp, 
-        int Bi, short Bx, int Cp, int Ci, short Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, unsigned short Ax, 
-        int Bp, int Bi, unsigned short Bx, int Cp, 
-        int Ci, unsigned short Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp, 
-        int Bi, int Bx, int Cp, int Ci, int Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, unsigned int Ax, 
-        int Bp, int Bi, unsigned int Bx, int Cp, 
-        int Ci, unsigned int Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, long long Ax, 
-        int Bp, int Bi, long long Bx, int Cp, int Ci, 
-        long long Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax, 
-        int Bp, int Bi, unsigned long long Bx, 
-        int Cp, int Ci, unsigned long long Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp, 
-        int Bi, float Bx, int Cp, int Ci, float Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp, 
-        int Bi, double Bx, int Cp, int Ci, double Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, long double Ax, 
-        int Bp, int Bi, long double Bx, int Cp, int Ci, 
-        long double Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax, 
-        int Bp, int Bi, npy_cfloat_wrapper Bx, 
-        int Cp, int Ci, npy_cfloat_wrapper Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax, 
-        int Bp, int Bi, npy_cdouble_wrapper Bx, 
-        int Cp, int Ci, npy_cdouble_wrapper Cx)
-    csc_minus_csc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bi, npy_clongdouble_wrapper Bx, 
-        int Cp, int Ci, npy_clongdouble_wrapper Cx)
     """
-  return _csc.csc_minus_csc(*args)
-
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, signed char Ax,
+          int Bp, int Bi, signed char Bx, int Cp, int Ci,
+          signed char Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, unsigned char Ax,
+          int Bp, int Bi, unsigned char Bx, int Cp,
+          int Ci, unsigned char Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, short Ax, int Bp,
+          int Bi, short Bx, int Cp, int Ci, short Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, unsigned short Ax,
+          int Bp, int Bi, unsigned short Bx, int Cp,
+          int Ci, unsigned short Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, int Ax, int Bp,
+          int Bi, int Bx, int Cp, int Ci, int Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, unsigned int Ax,
+          int Bp, int Bi, unsigned int Bx, int Cp,
+          int Ci, unsigned int Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, long long Ax,
+          int Bp, int Bi, long long Bx, int Cp, int Ci,
+          long long Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, unsigned long long Ax,
+          int Bp, int Bi, unsigned long long Bx,
+          int Cp, int Ci, unsigned long long Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, float Ax, int Bp,
+          int Bi, float Bx, int Cp, int Ci, float Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, double Ax, int Bp,
+          int Bi, double Bx, int Cp, int Ci, double Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, long double Ax,
+          int Bp, int Bi, long double Bx, int Cp, int Ci,
+          long double Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, npy_cfloat_wrapper Ax,
+          int Bp, int Bi, npy_cfloat_wrapper Bx,
+          int Cp, int Ci, npy_cfloat_wrapper Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, npy_cdouble_wrapper Ax,
+          int Bp, int Bi, npy_cdouble_wrapper Bx,
+          int Cp, int Ci, npy_cdouble_wrapper Cx)
+      csc_minus_csc(int n_row, int n_col, int Ap, int Ai, npy_clongdouble_wrapper Ax,
+          int Bp, int Bi, npy_clongdouble_wrapper Bx,
+          int Cp, int Ci, npy_clongdouble_wrapper Cx)
+      """
+    return _csc.csc_minus_csc(*args)

Modified: trunk/scipy/sparse/sparsetools/csr.py
===================================================================
--- trunk/scipy/sparse/sparsetools/csr.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/sparsetools/csr.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -50,569 +50,568 @@
 
 
 def expandptr(*args):
-  """expandptr(int n_row, int Ap, int Bi)"""
-  return _csr.expandptr(*args)
+    """expandptr(int n_row, int Ap, int Bi)"""
+    return _csr.expandptr(*args)
 
 def csr_count_blocks(*args):
-  """csr_count_blocks(int n_row, int n_col, int R, int C, int Ap, int Aj) -> int"""
-  return _csr.csr_count_blocks(*args)
+    """csr_count_blocks(int n_row, int n_col, int R, int C, int Ap, int Aj) -> int"""
+    return _csr.csr_count_blocks(*args)
 
 def csr_matmat_pass1(*args):
-  """
-    csr_matmat_pass1(int n_row, int n_col, int Ap, int Aj, int Bp, int Bj, 
-        int Cp)
     """
-  return _csr.csr_matmat_pass1(*args)
+      csr_matmat_pass1(int n_row, int n_col, int Ap, int Aj, int Bp, int Bj,
+          int Cp)
+      """
+    return _csr.csr_matmat_pass1(*args)
 
 def csr_has_sorted_indices(*args):
-  """csr_has_sorted_indices(int n_row, int Ap, int Aj) -> bool"""
-  return _csr.csr_has_sorted_indices(*args)
+    """csr_has_sorted_indices(int n_row, int Ap, int Aj) -> bool"""
+    return _csr.csr_has_sorted_indices(*args)
 
 
 def csr_diagonal(*args):
-  """
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        signed char Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        unsigned char Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, short Ax, short Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        unsigned short Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, int Ax, int Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        unsigned int Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        long long Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        unsigned long long Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, float Ax, float Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, double Ax, double Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        long double Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        npy_cfloat_wrapper Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        npy_cdouble_wrapper Yx)
-    csr_diagonal(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        npy_clongdouble_wrapper Yx)
     """
-  return _csr.csr_diagonal(*args)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          signed char Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          unsigned char Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, short Ax, short Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          unsigned short Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, int Ax, int Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          unsigned int Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          long long Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          unsigned long long Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, float Ax, float Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, double Ax, double Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          long double Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          npy_cfloat_wrapper Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          npy_cdouble_wrapper Yx)
+      csr_diagonal(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          npy_clongdouble_wrapper Yx)
+      """
+    return _csr.csr_diagonal(*args)
 
 def csr_scale_rows(*args):
-  """
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        signed char Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        unsigned char Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, short Ax, short Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        unsigned short Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, int Ax, int Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        unsigned int Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        long long Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        unsigned long long Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, float Ax, float Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, double Ax, double Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        long double Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        npy_cfloat_wrapper Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        npy_cdouble_wrapper Xx)
-    csr_scale_rows(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        npy_clongdouble_wrapper Xx)
     """
-  return _csr.csr_scale_rows(*args)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          signed char Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          unsigned char Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, short Ax, short Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          unsigned short Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, int Ax, int Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          unsigned int Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          long long Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          unsigned long long Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, float Ax, float Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, double Ax, double Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          long double Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          npy_cfloat_wrapper Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          npy_cdouble_wrapper Xx)
+      csr_scale_rows(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          npy_clongdouble_wrapper Xx)
+      """
+    return _csr.csr_scale_rows(*args)
 
 def csr_scale_columns(*args):
-  """
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        signed char Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        unsigned char Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, short Ax, short Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        unsigned short Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, int Ax, int Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        unsigned int Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        long long Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        unsigned long long Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, float Ax, float Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, double Ax, double Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        long double Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        npy_cfloat_wrapper Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        npy_cdouble_wrapper Xx)
-    csr_scale_columns(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        npy_clongdouble_wrapper Xx)
     """
-  return _csr.csr_scale_columns(*args)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          signed char Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          unsigned char Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, short Ax, short Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          unsigned short Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, int Ax, int Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          unsigned int Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          long long Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          unsigned long long Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, float Ax, float Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, double Ax, double Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          long double Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          npy_cfloat_wrapper Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          npy_cdouble_wrapper Xx)
+      csr_scale_columns(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          npy_clongdouble_wrapper Xx)
+      """
+    return _csr.csr_scale_columns(*args)
 
 def csr_tocsc(*args):
-  """
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        int Bp, int Bi, signed char Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        int Bp, int Bi, unsigned char Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp, 
-        int Bi, short Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        int Bp, int Bi, unsigned short Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp, 
-        int Bi, int Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        int Bp, int Bi, unsigned int Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        int Bp, int Bi, long long Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        int Bp, int Bi, unsigned long long Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp, 
-        int Bi, float Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp, 
-        int Bi, double Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        int Bp, int Bi, long double Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        int Bp, int Bi, npy_cfloat_wrapper Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        int Bp, int Bi, npy_cdouble_wrapper Bx)
-    csr_tocsc(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bi, npy_clongdouble_wrapper Bx)
     """
-  return _csr.csr_tocsc(*args)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          int Bp, int Bi, signed char Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          int Bp, int Bi, unsigned char Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp,
+          int Bi, short Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          int Bp, int Bi, unsigned short Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp,
+          int Bi, int Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          int Bp, int Bi, unsigned int Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          int Bp, int Bi, long long Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          int Bp, int Bi, unsigned long long Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp,
+          int Bi, float Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp,
+          int Bi, double Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          int Bp, int Bi, long double Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          int Bp, int Bi, npy_cfloat_wrapper Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          int Bp, int Bi, npy_cdouble_wrapper Bx)
+      csr_tocsc(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          int Bp, int Bi, npy_clongdouble_wrapper Bx)
+      """
+    return _csr.csr_tocsc(*args)
 
 def csr_tobsr(*args):
-  """
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        signed char Ax, int Bp, int Bj, signed char Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned char Ax, int Bp, int Bj, unsigned char Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        short Ax, int Bp, int Bj, short Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned short Ax, int Bp, int Bj, unsigned short Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        int Ax, int Bp, int Bj, int Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned int Ax, int Bp, int Bj, unsigned int Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        long long Ax, int Bp, int Bj, long long Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        unsigned long long Ax, int Bp, int Bj, unsigned long long Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        float Ax, int Bp, int Bj, float Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        double Ax, int Bp, int Bj, double Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        long double Ax, int Bp, int Bj, long double Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx)
-    csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj, 
-        npy_clongdouble_wrapper Ax, int Bp, int Bj, 
-        npy_clongdouble_wrapper Bx)
     """
-  return _csr.csr_tobsr(*args)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          signed char Ax, int Bp, int Bj, signed char Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned char Ax, int Bp, int Bj, unsigned char Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          short Ax, int Bp, int Bj, short Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned short Ax, int Bp, int Bj, unsigned short Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          int Ax, int Bp, int Bj, int Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned int Ax, int Bp, int Bj, unsigned int Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          long long Ax, int Bp, int Bj, long long Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          unsigned long long Ax, int Bp, int Bj, unsigned long long Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          float Ax, int Bp, int Bj, float Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          double Ax, int Bp, int Bj, double Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          long double Ax, int Bp, int Bj, long double Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_cfloat_wrapper Ax, int Bp, int Bj, npy_cfloat_wrapper Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_cdouble_wrapper Ax, int Bp, int Bj, npy_cdouble_wrapper Bx)
+      csr_tobsr(int n_row, int n_col, int R, int C, int Ap, int Aj,
+          npy_clongdouble_wrapper Ax, int Bp, int Bj,
+          npy_clongdouble_wrapper Bx)
+      """
+    return _csr.csr_tobsr(*args)
 
 def csr_matmat_pass2(*args):
-  """
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        int Bp, int Bj, signed char Bx, int Cp, int Cj, 
-        signed char Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        int Bp, int Bj, unsigned char Bx, int Cp, 
-        int Cj, unsigned char Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp, 
-        int Bj, short Bx, int Cp, int Cj, short Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        int Bp, int Bj, unsigned short Bx, int Cp, 
-        int Cj, unsigned short Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp, 
-        int Bj, int Bx, int Cp, int Cj, int Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        int Bp, int Bj, unsigned int Bx, int Cp, 
-        int Cj, unsigned int Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        int Bp, int Bj, long long Bx, int Cp, int Cj, 
-        long long Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        int Bp, int Bj, unsigned long long Bx, 
-        int Cp, int Cj, unsigned long long Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp, 
-        int Bj, float Bx, int Cp, int Cj, float Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp, 
-        int Bj, double Bx, int Cp, int Cj, double Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        int Bp, int Bj, long double Bx, int Cp, int Cj, 
-        long double Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        int Bp, int Bj, npy_cfloat_wrapper Bx, 
-        int Cp, int Cj, npy_cfloat_wrapper Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        int Bp, int Bj, npy_cdouble_wrapper Bx, 
-        int Cp, int Cj, npy_cdouble_wrapper Cx)
-    csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bj, npy_clongdouble_wrapper Bx, 
-        int Cp, int Cj, npy_clongdouble_wrapper Cx)
     """
-  return _csr.csr_matmat_pass2(*args)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          int Bp, int Bj, signed char Bx, int Cp, int Cj,
+          signed char Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          int Bp, int Bj, unsigned char Bx, int Cp,
+          int Cj, unsigned char Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp,
+          int Bj, short Bx, int Cp, int Cj, short Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          int Bp, int Bj, unsigned short Bx, int Cp,
+          int Cj, unsigned short Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp,
+          int Bj, int Bx, int Cp, int Cj, int Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          int Bp, int Bj, unsigned int Bx, int Cp,
+          int Cj, unsigned int Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          int Bp, int Bj, long long Bx, int Cp, int Cj,
+          long long Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          int Bp, int Bj, unsigned long long Bx,
+          int Cp, int Cj, unsigned long long Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp,
+          int Bj, float Bx, int Cp, int Cj, float Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp,
+          int Bj, double Bx, int Cp, int Cj, double Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          int Bp, int Bj, long double Bx, int Cp, int Cj,
+          long double Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          int Bp, int Bj, npy_cfloat_wrapper Bx,
+          int Cp, int Cj, npy_cfloat_wrapper Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          int Bp, int Bj, npy_cdouble_wrapper Bx,
+          int Cp, int Cj, npy_cdouble_wrapper Cx)
+      csr_matmat_pass2(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          int Bp, int Bj, npy_clongdouble_wrapper Bx,
+          int Cp, int Cj, npy_clongdouble_wrapper Cx)
+      """
+    return _csr.csr_matmat_pass2(*args)
 
 def csr_matvec(*args):
-  """
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        signed char Xx, signed char Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        unsigned char Xx, unsigned char Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, short Ax, short Xx, 
-        short Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        unsigned short Xx, unsigned short Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, int Ax, int Xx, 
-        int Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        unsigned int Xx, unsigned int Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        long long Xx, long long Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        unsigned long long Xx, unsigned long long Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, float Ax, float Xx, 
-        float Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, double Ax, double Xx, 
-        double Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        long double Xx, long double Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        npy_cfloat_wrapper Xx, npy_cfloat_wrapper Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        npy_cdouble_wrapper Xx, npy_cdouble_wrapper Yx)
-    csr_matvec(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        npy_clongdouble_wrapper Xx, npy_clongdouble_wrapper Yx)
     """
-  return _csr.csr_matvec(*args)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          signed char Xx, signed char Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          unsigned char Xx, unsigned char Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, short Ax, short Xx,
+          short Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          unsigned short Xx, unsigned short Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, int Ax, int Xx,
+          int Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          unsigned int Xx, unsigned int Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          long long Xx, long long Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          unsigned long long Xx, unsigned long long Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, float Ax, float Xx,
+          float Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, double Ax, double Xx,
+          double Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          long double Xx, long double Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          npy_cfloat_wrapper Xx, npy_cfloat_wrapper Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          npy_cdouble_wrapper Xx, npy_cdouble_wrapper Yx)
+      csr_matvec(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          npy_clongdouble_wrapper Xx, npy_clongdouble_wrapper Yx)
+      """
+    return _csr.csr_matvec(*args)
 
 def csr_matvecs(*args):
-  """
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, signed char Ax, 
-        signed char Xx, signed char Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, unsigned char Ax, 
-        unsigned char Xx, unsigned char Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, short Ax, 
-        short Xx, short Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, unsigned short Ax, 
-        unsigned short Xx, unsigned short Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, int Ax, 
-        int Xx, int Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, unsigned int Ax, 
-        unsigned int Xx, unsigned int Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, long long Ax, 
-        long long Xx, long long Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, unsigned long long Ax, 
-        unsigned long long Xx, 
-        unsigned long long Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, float Ax, 
-        float Xx, float Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, double Ax, 
-        double Xx, double Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, long double Ax, 
-        long double Xx, long double Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        npy_cfloat_wrapper Xx, 
-        npy_cfloat_wrapper Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        npy_cdouble_wrapper Xx, 
-        npy_cdouble_wrapper Yx)
-    csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        npy_clongdouble_wrapper Xx, 
-        npy_clongdouble_wrapper Yx)
     """
-  return _csr.csr_matvecs(*args)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, signed char Ax,
+          signed char Xx, signed char Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, unsigned char Ax,
+          unsigned char Xx, unsigned char Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, short Ax,
+          short Xx, short Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, unsigned short Ax,
+          unsigned short Xx, unsigned short Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, int Ax,
+          int Xx, int Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, unsigned int Ax,
+          unsigned int Xx, unsigned int Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, long long Ax,
+          long long Xx, long long Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, unsigned long long Ax,
+          unsigned long long Xx,
+          unsigned long long Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, float Ax,
+          float Xx, float Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, double Ax,
+          double Xx, double Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, long double Ax,
+          long double Xx, long double Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          npy_cfloat_wrapper Xx,
+          npy_cfloat_wrapper Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          npy_cdouble_wrapper Xx,
+          npy_cdouble_wrapper Yx)
+      csr_matvecs(int n_row, int n_col, int n_vecs, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          npy_clongdouble_wrapper Xx,
+          npy_clongdouble_wrapper Yx)
+      """
+    return _csr.csr_matvecs(*args)
 
 def csr_elmul_csr(*args):
-  """
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        int Bp, int Bj, signed char Bx, int Cp, int Cj, 
-        signed char Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        int Bp, int Bj, unsigned char Bx, int Cp, 
-        int Cj, unsigned char Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp, 
-        int Bj, short Bx, int Cp, int Cj, short Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        int Bp, int Bj, unsigned short Bx, int Cp, 
-        int Cj, unsigned short Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp, 
-        int Bj, int Bx, int Cp, int Cj, int Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        int Bp, int Bj, unsigned int Bx, int Cp, 
-        int Cj, unsigned int Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        int Bp, int Bj, long long Bx, int Cp, int Cj, 
-        long long Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        int Bp, int Bj, unsigned long long Bx, 
-        int Cp, int Cj, unsigned long long Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp, 
-        int Bj, float Bx, int Cp, int Cj, float Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp, 
-        int Bj, double Bx, int Cp, int Cj, double Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        int Bp, int Bj, long double Bx, int Cp, int Cj, 
-        long double Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        int Bp, int Bj, npy_cfloat_wrapper Bx, 
-        int Cp, int Cj, npy_cfloat_wrapper Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        int Bp, int Bj, npy_cdouble_wrapper Bx, 
-        int Cp, int Cj, npy_cdouble_wrapper Cx)
-    csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bj, npy_clongdouble_wrapper Bx, 
-        int Cp, int Cj, npy_clongdouble_wrapper Cx)
     """
-  return _csr.csr_elmul_csr(*args)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          int Bp, int Bj, signed char Bx, int Cp, int Cj,
+          signed char Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          int Bp, int Bj, unsigned char Bx, int Cp,
+          int Cj, unsigned char Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp,
+          int Bj, short Bx, int Cp, int Cj, short Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          int Bp, int Bj, unsigned short Bx, int Cp,
+          int Cj, unsigned short Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp,
+          int Bj, int Bx, int Cp, int Cj, int Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          int Bp, int Bj, unsigned int Bx, int Cp,
+          int Cj, unsigned int Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          int Bp, int Bj, long long Bx, int Cp, int Cj,
+          long long Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          int Bp, int Bj, unsigned long long Bx,
+          int Cp, int Cj, unsigned long long Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp,
+          int Bj, float Bx, int Cp, int Cj, float Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp,
+          int Bj, double Bx, int Cp, int Cj, double Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          int Bp, int Bj, long double Bx, int Cp, int Cj,
+          long double Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          int Bp, int Bj, npy_cfloat_wrapper Bx,
+          int Cp, int Cj, npy_cfloat_wrapper Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          int Bp, int Bj, npy_cdouble_wrapper Bx,
+          int Cp, int Cj, npy_cdouble_wrapper Cx)
+      csr_elmul_csr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          int Bp, int Bj, npy_clongdouble_wrapper Bx,
+          int Cp, int Cj, npy_clongdouble_wrapper Cx)
+      """
+    return _csr.csr_elmul_csr(*args)
 
 def csr_eldiv_csr(*args):
-  """
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        int Bp, int Bj, signed char Bx, int Cp, int Cj, 
-        signed char Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        int Bp, int Bj, unsigned char Bx, int Cp, 
-        int Cj, unsigned char Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp, 
-        int Bj, short Bx, int Cp, int Cj, short Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        int Bp, int Bj, unsigned short Bx, int Cp, 
-        int Cj, unsigned short Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp, 
-        int Bj, int Bx, int Cp, int Cj, int Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        int Bp, int Bj, unsigned int Bx, int Cp, 
-        int Cj, unsigned int Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        int Bp, int Bj, long long Bx, int Cp, int Cj, 
-        long long Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        int Bp, int Bj, unsigned long long Bx, 
-        int Cp, int Cj, unsigned long long Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp, 
-        int Bj, float Bx, int Cp, int Cj, float Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp, 
-        int Bj, double Bx, int Cp, int Cj, double Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        int Bp, int Bj, long double Bx, int Cp, int Cj, 
-        long double Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        int Bp, int Bj, npy_cfloat_wrapper Bx, 
-        int Cp, int Cj, npy_cfloat_wrapper Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        int Bp, int Bj, npy_cdouble_wrapper Bx, 
-        int Cp, int Cj, npy_cdouble_wrapper Cx)
-    csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bj, npy_clongdouble_wrapper Bx, 
-        int Cp, int Cj, npy_clongdouble_wrapper Cx)
     """
-  return _csr.csr_eldiv_csr(*args)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          int Bp, int Bj, signed char Bx, int Cp, int Cj,
+          signed char Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          int Bp, int Bj, unsigned char Bx, int Cp,
+          int Cj, unsigned char Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp,
+          int Bj, short Bx, int Cp, int Cj, short Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          int Bp, int Bj, unsigned short Bx, int Cp,
+          int Cj, unsigned short Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp,
+          int Bj, int Bx, int Cp, int Cj, int Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          int Bp, int Bj, unsigned int Bx, int Cp,
+          int Cj, unsigned int Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          int Bp, int Bj, long long Bx, int Cp, int Cj,
+          long long Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          int Bp, int Bj, unsigned long long Bx,
+          int Cp, int Cj, unsigned long long Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp,
+          int Bj, float Bx, int Cp, int Cj, float Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp,
+          int Bj, double Bx, int Cp, int Cj, double Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          int Bp, int Bj, long double Bx, int Cp, int Cj,
+          long double Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          int Bp, int Bj, npy_cfloat_wrapper Bx,
+          int Cp, int Cj, npy_cfloat_wrapper Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          int Bp, int Bj, npy_cdouble_wrapper Bx,
+          int Cp, int Cj, npy_cdouble_wrapper Cx)
+      csr_eldiv_csr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          int Bp, int Bj, npy_clongdouble_wrapper Bx,
+          int Cp, int Cj, npy_clongdouble_wrapper Cx)
+      """
+    return _csr.csr_eldiv_csr(*args)
 
 def csr_plus_csr(*args):
-  """
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        int Bp, int Bj, signed char Bx, int Cp, int Cj, 
-        signed char Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        int Bp, int Bj, unsigned char Bx, int Cp, 
-        int Cj, unsigned char Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp, 
-        int Bj, short Bx, int Cp, int Cj, short Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        int Bp, int Bj, unsigned short Bx, int Cp, 
-        int Cj, unsigned short Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp, 
-        int Bj, int Bx, int Cp, int Cj, int Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        int Bp, int Bj, unsigned int Bx, int Cp, 
-        int Cj, unsigned int Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        int Bp, int Bj, long long Bx, int Cp, int Cj, 
-        long long Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        int Bp, int Bj, unsigned long long Bx, 
-        int Cp, int Cj, unsigned long long Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp, 
-        int Bj, float Bx, int Cp, int Cj, float Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp, 
-        int Bj, double Bx, int Cp, int Cj, double Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        int Bp, int Bj, long double Bx, int Cp, int Cj, 
-        long double Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        int Bp, int Bj, npy_cfloat_wrapper Bx, 
-        int Cp, int Cj, npy_cfloat_wrapper Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        int Bp, int Bj, npy_cdouble_wrapper Bx, 
-        int Cp, int Cj, npy_cdouble_wrapper Cx)
-    csr_plus_csr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bj, npy_clongdouble_wrapper Bx, 
-        int Cp, int Cj, npy_clongdouble_wrapper Cx)
     """
-  return _csr.csr_plus_csr(*args)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          int Bp, int Bj, signed char Bx, int Cp, int Cj,
+          signed char Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          int Bp, int Bj, unsigned char Bx, int Cp,
+          int Cj, unsigned char Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp,
+          int Bj, short Bx, int Cp, int Cj, short Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          int Bp, int Bj, unsigned short Bx, int Cp,
+          int Cj, unsigned short Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp,
+          int Bj, int Bx, int Cp, int Cj, int Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          int Bp, int Bj, unsigned int Bx, int Cp,
+          int Cj, unsigned int Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          int Bp, int Bj, long long Bx, int Cp, int Cj,
+          long long Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          int Bp, int Bj, unsigned long long Bx,
+          int Cp, int Cj, unsigned long long Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp,
+          int Bj, float Bx, int Cp, int Cj, float Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp,
+          int Bj, double Bx, int Cp, int Cj, double Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          int Bp, int Bj, long double Bx, int Cp, int Cj,
+          long double Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          int Bp, int Bj, npy_cfloat_wrapper Bx,
+          int Cp, int Cj, npy_cfloat_wrapper Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          int Bp, int Bj, npy_cdouble_wrapper Bx,
+          int Cp, int Cj, npy_cdouble_wrapper Cx)
+      csr_plus_csr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          int Bp, int Bj, npy_clongdouble_wrapper Bx,
+          int Cp, int Cj, npy_clongdouble_wrapper Cx)
+      """
+    return _csr.csr_plus_csr(*args)
 
 def csr_minus_csr(*args):
-  """
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        int Bp, int Bj, signed char Bx, int Cp, int Cj, 
-        signed char Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        int Bp, int Bj, unsigned char Bx, int Cp, 
-        int Cj, unsigned char Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp, 
-        int Bj, short Bx, int Cp, int Cj, short Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        int Bp, int Bj, unsigned short Bx, int Cp, 
-        int Cj, unsigned short Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp, 
-        int Bj, int Bx, int Cp, int Cj, int Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        int Bp, int Bj, unsigned int Bx, int Cp, 
-        int Cj, unsigned int Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        int Bp, int Bj, long long Bx, int Cp, int Cj, 
-        long long Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        int Bp, int Bj, unsigned long long Bx, 
-        int Cp, int Cj, unsigned long long Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp, 
-        int Bj, float Bx, int Cp, int Cj, float Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp, 
-        int Bj, double Bx, int Cp, int Cj, double Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        int Bp, int Bj, long double Bx, int Cp, int Cj, 
-        long double Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        int Bp, int Bj, npy_cfloat_wrapper Bx, 
-        int Cp, int Cj, npy_cfloat_wrapper Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        int Bp, int Bj, npy_cdouble_wrapper Bx, 
-        int Cp, int Cj, npy_cdouble_wrapper Cx)
-    csr_minus_csr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        int Bp, int Bj, npy_clongdouble_wrapper Bx, 
-        int Cp, int Cj, npy_clongdouble_wrapper Cx)
     """
-  return _csr.csr_minus_csr(*args)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          int Bp, int Bj, signed char Bx, int Cp, int Cj,
+          signed char Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          int Bp, int Bj, unsigned char Bx, int Cp,
+          int Cj, unsigned char Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, short Ax, int Bp,
+          int Bj, short Bx, int Cp, int Cj, short Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          int Bp, int Bj, unsigned short Bx, int Cp,
+          int Cj, unsigned short Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, int Ax, int Bp,
+          int Bj, int Bx, int Cp, int Cj, int Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          int Bp, int Bj, unsigned int Bx, int Cp,
+          int Cj, unsigned int Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          int Bp, int Bj, long long Bx, int Cp, int Cj,
+          long long Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          int Bp, int Bj, unsigned long long Bx,
+          int Cp, int Cj, unsigned long long Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, float Ax, int Bp,
+          int Bj, float Bx, int Cp, int Cj, float Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, double Ax, int Bp,
+          int Bj, double Bx, int Cp, int Cj, double Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          int Bp, int Bj, long double Bx, int Cp, int Cj,
+          long double Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          int Bp, int Bj, npy_cfloat_wrapper Bx,
+          int Cp, int Cj, npy_cfloat_wrapper Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          int Bp, int Bj, npy_cdouble_wrapper Bx,
+          int Cp, int Cj, npy_cdouble_wrapper Cx)
+      csr_minus_csr(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          int Bp, int Bj, npy_clongdouble_wrapper Bx,
+          int Cp, int Cj, npy_clongdouble_wrapper Cx)
+      """
+    return _csr.csr_minus_csr(*args)
 
 def csr_sort_indices(*args):
-  """
-    csr_sort_indices(int n_row, int Ap, int Aj, signed char Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, unsigned char Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, short Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, unsigned short Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, int Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, unsigned int Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, long long Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, unsigned long long Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, float Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, double Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, long double Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, npy_cfloat_wrapper Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, npy_cdouble_wrapper Ax)
-    csr_sort_indices(int n_row, int Ap, int Aj, npy_clongdouble_wrapper Ax)
     """
-  return _csr.csr_sort_indices(*args)
+      csr_sort_indices(int n_row, int Ap, int Aj, signed char Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, unsigned char Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, short Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, unsigned short Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, int Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, unsigned int Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, long long Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, unsigned long long Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, float Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, double Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, long double Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, npy_cfloat_wrapper Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, npy_cdouble_wrapper Ax)
+      csr_sort_indices(int n_row, int Ap, int Aj, npy_clongdouble_wrapper Ax)
+      """
+    return _csr.csr_sort_indices(*args)
 
 def csr_eliminate_zeros(*args):
-  """
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, signed char Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, unsigned char Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, short Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, unsigned short Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, int Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, unsigned int Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, long long Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, float Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, double Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, long double Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax)
-    csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax)
     """
-  return _csr.csr_eliminate_zeros(*args)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, signed char Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, unsigned char Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, short Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, unsigned short Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, int Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, unsigned int Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, long long Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, float Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, double Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, long double Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax)
+      csr_eliminate_zeros(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax)
+      """
+    return _csr.csr_eliminate_zeros(*args)
 
 def csr_sum_duplicates(*args):
-  """
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, signed char Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, unsigned char Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, short Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, unsigned short Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, int Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, unsigned int Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, long long Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, float Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, double Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, long double Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax)
-    csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax)
     """
-  return _csr.csr_sum_duplicates(*args)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, signed char Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, unsigned char Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, short Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, unsigned short Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, int Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, unsigned int Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, long long Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, float Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, double Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, long double Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax)
+      csr_sum_duplicates(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax)
+      """
+    return _csr.csr_sum_duplicates(*args)
 
 def get_csr_submatrix(*args):
-  """
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, signed char Ax, 
-        int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp, 
-        std::vector<(int)> Bj, std::vector<(signed char)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, unsigned char Ax, 
-        int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp, 
-        std::vector<(int)> Bj, std::vector<(unsigned char)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, short Ax, int ir0, 
-        int ir1, int ic0, int ic1, std::vector<(int)> Bp, 
-        std::vector<(int)> Bj, std::vector<(short)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, unsigned short Ax, 
-        int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp, 
-        std::vector<(int)> Bj, std::vector<(unsigned short)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, int Ax, int ir0, 
-        int ir1, int ic0, int ic1, std::vector<(int)> Bp, 
-        std::vector<(int)> Bj, std::vector<(int)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, unsigned int Ax, 
-        int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp, 
-        std::vector<(int)> Bj, std::vector<(unsigned int)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, long long Ax, 
-        int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp, 
-        std::vector<(int)> Bj, std::vector<(long long)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax, 
-        int ir0, int ir1, int ic0, int ic1, 
-        std::vector<(int)> Bp, std::vector<(int)> Bj, 
-        std::vector<(unsigned long long)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, float Ax, int ir0, 
-        int ir1, int ic0, int ic1, std::vector<(int)> Bp, 
-        std::vector<(int)> Bj, std::vector<(float)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, double Ax, int ir0, 
-        int ir1, int ic0, int ic1, std::vector<(int)> Bp, 
-        std::vector<(int)> Bj, std::vector<(double)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, long double Ax, 
-        int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp, 
-        std::vector<(int)> Bj, std::vector<(long double)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax, 
-        int ir0, int ir1, int ic0, int ic1, 
-        std::vector<(int)> Bp, std::vector<(int)> Bj, 
-        std::vector<(npy_cfloat_wrapper)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax, 
-        int ir0, int ir1, int ic0, int ic1, 
-        std::vector<(int)> Bp, std::vector<(int)> Bj, 
-        std::vector<(npy_cdouble_wrapper)> Bx)
-    get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax, 
-        int ir0, int ir1, int ic0, int ic1, 
-        std::vector<(int)> Bp, std::vector<(int)> Bj, 
-        std::vector<(npy_clongdouble_wrapper)> Bx)
     """
-  return _csr.get_csr_submatrix(*args)
-
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, signed char Ax,
+          int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp,
+          std::vector<(int)> Bj, std::vector<(signed char)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, unsigned char Ax,
+          int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp,
+          std::vector<(int)> Bj, std::vector<(unsigned char)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, short Ax, int ir0,
+          int ir1, int ic0, int ic1, std::vector<(int)> Bp,
+          std::vector<(int)> Bj, std::vector<(short)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, unsigned short Ax,
+          int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp,
+          std::vector<(int)> Bj, std::vector<(unsigned short)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, int Ax, int ir0,
+          int ir1, int ic0, int ic1, std::vector<(int)> Bp,
+          std::vector<(int)> Bj, std::vector<(int)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, unsigned int Ax,
+          int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp,
+          std::vector<(int)> Bj, std::vector<(unsigned int)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, long long Ax,
+          int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp,
+          std::vector<(int)> Bj, std::vector<(long long)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, unsigned long long Ax,
+          int ir0, int ir1, int ic0, int ic1,
+          std::vector<(int)> Bp, std::vector<(int)> Bj,
+          std::vector<(unsigned long long)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, float Ax, int ir0,
+          int ir1, int ic0, int ic1, std::vector<(int)> Bp,
+          std::vector<(int)> Bj, std::vector<(float)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, double Ax, int ir0,
+          int ir1, int ic0, int ic1, std::vector<(int)> Bp,
+          std::vector<(int)> Bj, std::vector<(double)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, long double Ax,
+          int ir0, int ir1, int ic0, int ic1, std::vector<(int)> Bp,
+          std::vector<(int)> Bj, std::vector<(long double)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, npy_cfloat_wrapper Ax,
+          int ir0, int ir1, int ic0, int ic1,
+          std::vector<(int)> Bp, std::vector<(int)> Bj,
+          std::vector<(npy_cfloat_wrapper)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, npy_cdouble_wrapper Ax,
+          int ir0, int ir1, int ic0, int ic1,
+          std::vector<(int)> Bp, std::vector<(int)> Bj,
+          std::vector<(npy_cdouble_wrapper)> Bx)
+      get_csr_submatrix(int n_row, int n_col, int Ap, int Aj, npy_clongdouble_wrapper Ax,
+          int ir0, int ir1, int ic0, int ic1,
+          std::vector<(int)> Bp, std::vector<(int)> Bj,
+          std::vector<(npy_clongdouble_wrapper)> Bx)
+      """
+    return _csr.get_csr_submatrix(*args)

Modified: trunk/scipy/sparse/sparsetools/dia.py
===================================================================
--- trunk/scipy/sparse/sparsetools/dia.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/sparsetools/dia.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -51,40 +51,39 @@
 
 
 def dia_matvec(*args):
-  """
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        signed char diags, signed char Xx, signed char Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        unsigned char diags, unsigned char Xx, unsigned char Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        short diags, short Xx, short Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        unsigned short diags, unsigned short Xx, 
-        unsigned short Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        int diags, int Xx, int Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        unsigned int diags, unsigned int Xx, unsigned int Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        long long diags, long long Xx, long long Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        unsigned long long diags, unsigned long long Xx, 
-        unsigned long long Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        float diags, float Xx, float Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        double diags, double Xx, double Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        long double diags, long double Xx, long double Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        npy_cfloat_wrapper diags, npy_cfloat_wrapper Xx, 
-        npy_cfloat_wrapper Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        npy_cdouble_wrapper diags, npy_cdouble_wrapper Xx, 
-        npy_cdouble_wrapper Yx)
-    dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets, 
-        npy_clongdouble_wrapper diags, npy_clongdouble_wrapper Xx, 
-        npy_clongdouble_wrapper Yx)
     """
-  return _dia.dia_matvec(*args)
-
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          signed char diags, signed char Xx, signed char Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          unsigned char diags, unsigned char Xx, unsigned char Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          short diags, short Xx, short Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          unsigned short diags, unsigned short Xx,
+          unsigned short Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          int diags, int Xx, int Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          unsigned int diags, unsigned int Xx, unsigned int Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          long long diags, long long Xx, long long Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          unsigned long long diags, unsigned long long Xx,
+          unsigned long long Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          float diags, float Xx, float Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          double diags, double Xx, double Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          long double diags, long double Xx, long double Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          npy_cfloat_wrapper diags, npy_cfloat_wrapper Xx,
+          npy_cfloat_wrapper Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          npy_cdouble_wrapper diags, npy_cdouble_wrapper Xx,
+          npy_cdouble_wrapper Yx)
+      dia_matvec(int n_row, int n_col, int n_diags, int L, int offsets,
+          npy_clongdouble_wrapper diags, npy_clongdouble_wrapper Xx,
+          npy_clongdouble_wrapper Yx)
+      """
+    return _dia.dia_matvec(*args)

Modified: trunk/scipy/sparse/tests/test_base.py
===================================================================
--- trunk/scipy/sparse/tests/test_base.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/sparse/tests/test_base.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -117,7 +117,7 @@
 
     def test_getrow(self):
         assert_array_equal(self.datsp.getrow(1).todense(), self.dat[1,:])
-    
+
     def test_getcol(self):
         assert_array_equal(self.datsp.getcol(1).todense(), self.dat[:,1])
 
@@ -250,8 +250,8 @@
         # real/complex
         assert_almost_equal( Asp.multiply(Dsp).todense(), A*D) #sparse/sparse
         assert_almost_equal( Asp.multiply(D),             A*D) #sparse/dense
-        
 
+
     def test_elementwise_divide(self):
         expected = [[1,0,0,1],[1,0,1,0],[0,1,0,0]]
         assert_array_equal((self.datsp / self.datsp).todense(),expected)
@@ -713,7 +713,7 @@
         assert_equal(A[3:4,9].todense(), B[3:4,9])
         assert_equal(A[1:4,-5].todense(),B[1:4,-5])
         assert_equal(A[2:-1,3].todense(),B[2:-1,3])
-        
+
         # [1:2,1:2]
         assert_equal(A[1:2,1:2].todense(),B[1:2,1:2])
         assert_equal(A[4:,3:].todense(),  B[4:,3:])
@@ -763,11 +763,11 @@
 
 
         # Check bug reported by Robert Cimrman:
-        # http://thread.gmane.org/gmane.comp.python.scientific.devel/7986 
+        # http://thread.gmane.org/gmane.comp.python.scientific.devel/7986
         s = slice(numpy.int8(2),numpy.int8(4),None)
         assert_equal(A[s,:].todense(), B[2:4,:])
         assert_equal(A[:,s].todense(), B[:,2:4])
-        
+
 class _TestArithmetic:
     """
     Test real/complex arithmetic
@@ -1415,7 +1415,7 @@
         A = bsr_matrix( arange(2*3*4*5).reshape(2*4,3*5), blocksize=(4,5) )
         x = arange(A.shape[1]*6).reshape(-1,6)
         assert_equal(A*x, A.todense()*x)
-        
 
+
 if __name__ == "__main__":
     run_module_suite()

Modified: trunk/scipy/special/tests/test_basic.py
===================================================================
--- trunk/scipy/special/tests/test_basic.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/special/tests/test_basic.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -1179,7 +1179,7 @@
 
         # test contributed by Moritz Deger (2008-05-29)
         # http://projects.scipy.org/scipy/scipy/ticket/659
-        
+
         # reference data obtained from mathematica [ a, b, x, m(a,b,x)]:
         # produced with test_hyp1f1.nb
         ref_data = array([[ -8.38132975e+00,  -1.28436461e+01,  -2.91081397e+01,          1.04178330e+04],

Modified: trunk/scipy/stats/mstats.py
===================================================================
--- trunk/scipy/stats/mstats.py	2008-08-08 06:06:21 UTC (rev 4617)
+++ trunk/scipy/stats/mstats.py	2008-08-08 06:17:26 UTC (rev 4618)
@@ -443,7 +443,7 @@
     use_missing: {False, True} optional
         Whether missing data should be allocated a rank of 0 (False) or the
         average rank (True)
-        
+
     Returns
     -------
         tau : float
@@ -645,7 +645,7 @@
             Independent variable. If None, use arange(len(y)) instead.
         alpha : float
             Confidence degree.
-            
+
     Returns
     -------
         medslope : float



More information about the Scipy-svn mailing list