pep 8

pywafo/src/wafo/magic.py

@@ -1,15 +1,16 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Tue Apr 17 13:59:12 2012
-
-@author: pab
-"""
-import numpy as np
-
-def magic(n):
-    ix = np.arange(n)+1
-    J, I = np.meshgrid(ix,ix)
-    A = np.mod(I+J-(n+3)/2,n)
-    B = np.mod(I+2*J-2,n)
-    M = n*A + B + 1
-    return M
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Apr 17 13:59:12 2012
+
+@author: pab
+"""
+import numpy as np
+
+
+def magic(n):
+    ix = np.arange(n) + 1
+    J, I = np.meshgrid(ix, ix)
+    A = np.mod(I + J - (n + 3) / 2, n)
+    B = np.mod(I + 2 * J - 2, n)
+    M = n * A + B + 1
+    return M

pywafo/src/wafo/meshgrid.py

@@ -1,133 +1,136 @@
-import numpy as np
-def meshgrid(*xi, **kwargs):
-    """
-    Return coordinate matrices from one or more coordinate vectors.
-
-    Make N-D coordinate arrays for vectorized evaluations of
-    N-D scalar/vector fields over N-D grids, given
-    one-dimensional coordinate arrays x1, x2,..., xn.
-
-    Parameters
-    ----------
-    x1, x2,..., xn : array_like
-        1-D arrays representing the coordinates of a grid.
-    indexing : 'xy' or 'ij' (optional)
-        cartesian ('xy', default) or matrix ('ij') indexing of output
-    sparse : True or False (default) (optional)
-         If True a sparse grid is returned in order to conserve memory.
-    copy : True (default) or False (optional)
-        If False a view into the original arrays are returned in order to
-        conserve memory. Please note that sparse=False, copy=False will likely 
-        return non-contiguous arrays. Furthermore, more than one element of a
-        broadcasted array may refer to a single memory location.  If you
-        need to write to the arrays, make copies first.
-
-    Returns
-    -------
-    X1, X2,..., XN : ndarray
-        For vectors `x1`, `x2`,..., 'xn' with lengths ``Ni=len(xi)`` ,
-        return ``(N1, N2, N3,...Nn)`` shaped arrays if indexing='ij'
-        or ``(N2, N1, N3,...Nn)`` shaped arrays if indexing='xy'
-        with the elements of `xi` repeated to fill the matrix along
-        the first dimension for `x1`, the second for `x2` and so on.
-    
-    Notes
-    -----
-    This function supports both indexing conventions through the indexing keyword 
-    argument. Giving the string 'ij' returns a meshgrid with matrix indexing, 
-    while 'xy' returns a meshgrid with Cartesian indexing. The difference is 
-    illustrated by the following code snippet:
-    
-    xv, yv = meshgrid(x, y, sparse=False, indexing='ij')
-    for i in range(nx):
-        for j in range(ny):
-            # treat xv[i,j], yv[i,j]
-    
-    xv, yv = meshgrid(x, y, sparse=False, indexing='xy')
-    for i in range(nx):
-        for j in range(ny):
-            # treat xv[j,i], yv[j,i]
-
-    See Also
-    --------
-    index_tricks.mgrid : Construct a multi-dimensional "meshgrid"
-                     using indexing notation.
-    index_tricks.ogrid : Construct an open multi-dimensional "meshgrid"
-                     using indexing notation.
-
-    Examples
-    --------
-    >>> nx, ny = (3, 2)
-    >>> x = np.linspace(0, 1, nx)   
-    >>> y = np.linspace(0, 1, ny)   
-    >>> xv, yv = meshgrid(x, y)     
-    >>> xv
-    array([[ 0. ,  0.5,  1. ],
-           [ 0. ,  0.5,  1. ]])
-    >>> yv
-    array([[ 0.,  0.,  0.],
-           [ 1.,  1.,  1.]])
-    >>> xv, yv = meshgrid(x, y, sparse=True)  # make sparse output arrays
-    >>> xv
-    array([[ 0. ,  0.5,  1. ]])
-    >>> yv
-    array([[ 0.],
-           [ 1.]])
-
-    `meshgrid` is very useful to evaluate functions on a grid.
-
-    >>> x = np.arange(-5, 5, 0.1)
-    >>> y = np.arange(-5, 5, 0.1)
-    >>> xx, yy = meshgrid(x, y, sparse=True)
-    >>> z = np.sin(xx**2+yy**2)/(xx**2+yy**2)
-    
-    >>> import matplotlib.pyplot as plt
-    >>> h = plt.contourf(x,y,z)
-    """
-    copy_ = kwargs.get('copy', True)
-    args = np.atleast_1d(*xi)
-    ndim = len(args)
-    
-    if not isinstance(args, list) or ndim<2:
-        raise TypeError('meshgrid() takes 2 or more arguments (%d given)' % int(ndim>0))
-
-    sparse = kwargs.get('sparse', False)
-    indexing = kwargs.get('indexing', 'xy')
-
-    s0 = (1,)*ndim
-    output = [x.reshape(s0[:i] + (-1,) + s0[i + 1::]) for i, x in enumerate(args)]
-
-    shape = [x.size for x in output]
-
-    if indexing == 'xy':
-        # switch first and second axis
-        output[0].shape = (1, -1) + (1,)*(ndim - 2)
-        output[1].shape = (-1, 1) + (1,)*(ndim - 2)
-        shape[0], shape[1] = shape[1], shape[0]
-
-    if sparse:
-        if copy_:
-            return [x.copy() for x in output]
-        else:
-            return output
-    else:
-        # Return the full N-D matrix (not only the 1-D vector)
-        if copy_:
-            mult_fact = np.ones(shape, dtype=int)
-            return [x * mult_fact for x in output]
-        else:
-            return np.broadcast_arrays(*output)
-
-
-def ndgrid(*args, **kwargs):
-    """
-    Same as calling meshgrid with indexing='ij' (see meshgrid for
-    documentation).
-    """
-    kwargs['indexing'] = 'ij'
-    return meshgrid(*args, **kwargs)
-
-if __name__ == '__main__':
-    import doctest
-    doctest.testmod()
-
+import numpy as np
+
+
+def meshgrid(*xi, **kwargs):
+    """
+    Return coordinate matrices from one or more coordinate vectors.
+
+    Make N-D coordinate arrays for vectorized evaluations of
+    N-D scalar/vector fields over N-D grids, given
+    one-dimensional coordinate arrays x1, x2,..., xn.
+
+    Parameters
+    ----------
+    x1, x2,..., xn : array_like
+        1-D arrays representing the coordinates of a grid.
+    indexing : 'xy' or 'ij' (optional)
+        cartesian ('xy', default) or matrix ('ij') indexing of output
+    sparse : True or False (default) (optional)
+         If True a sparse grid is returned in order to conserve memory.
+    copy : True (default) or False (optional)
+        If False a view into the original arrays are returned in order to
+        conserve memory. Please note that sparse=False, copy=False will likely
+        return non-contiguous arrays. Furthermore, more than one element of a
+        broadcasted array may refer to a single memory location.  If you
+        need to write to the arrays, make copies first.
+
+    Returns
+    -------
+    X1, X2,..., XN : ndarray
+        For vectors `x1`, `x2`,..., 'xn' with lengths ``Ni=len(xi)`` ,
+        return ``(N1, N2, N3,...Nn)`` shaped arrays if indexing='ij'
+        or ``(N2, N1, N3,...Nn)`` shaped arrays if indexing='xy'
+        with the elements of `xi` repeated to fill the matrix along
+        the first dimension for `x1`, the second for `x2` and so on.
+
+    Notes
+    -----
+    This function supports both indexing conventions through the indexing
+    keyword argument. Giving the string 'ij' returns a meshgrid with matrix
+    indexing, while 'xy' returns a meshgrid with Cartesian indexing. The
+    difference is illustrated by the following code snippet:
+
+    xv, yv = meshgrid(x, y, sparse=False, indexing='ij')
+    for i in range(nx):
+        for j in range(ny):
+            # treat xv[i,j], yv[i,j]
+
+    xv, yv = meshgrid(x, y, sparse=False, indexing='xy')
+    for i in range(nx):
+        for j in range(ny):
+            # treat xv[j,i], yv[j,i]
+
+    See Also
+    --------
+    index_tricks.mgrid : Construct a multi-dimensional "meshgrid"
+                     using indexing notation.
+    index_tricks.ogrid : Construct an open multi-dimensional "meshgrid"
+                     using indexing notation.
+
+    Examples
+    --------
+    >>> nx, ny = (3, 2)
+    >>> x = np.linspace(0, 1, nx)
+    >>> y = np.linspace(0, 1, ny)
+    >>> xv, yv = meshgrid(x, y)
+    >>> xv
+    array([[ 0. ,  0.5,  1. ],
+           [ 0. ,  0.5,  1. ]])
+    >>> yv
+    array([[ 0.,  0.,  0.],
+           [ 1.,  1.,  1.]])
+    >>> xv, yv = meshgrid(x, y, sparse=True)  # make sparse output arrays
+    >>> xv
+    array([[ 0. ,  0.5,  1. ]])
+    >>> yv
+    array([[ 0.],
+           [ 1.]])
+
+    `meshgrid` is very useful to evaluate functions on a grid.
+
+    >>> x = np.arange(-5, 5, 0.1)
+    >>> y = np.arange(-5, 5, 0.1)
+    >>> xx, yy = meshgrid(x, y, sparse=True)
+    >>> z = np.sin(xx**2+yy**2)/(xx**2+yy**2)
+
+    >>> import matplotlib.pyplot as plt
+    >>> h = plt.contourf(x,y,z)
+    """
+    copy_ = kwargs.get('copy', True)
+    args = np.atleast_1d(*xi)
+    ndim = len(args)
+
+    if not isinstance(args, list) or ndim < 2:
+        raise TypeError(
+            'meshgrid() takes 2 or more arguments (%d given)' % int(ndim > 0))
+
+    sparse = kwargs.get('sparse', False)
+    indexing = kwargs.get('indexing', 'xy')
+
+    s0 = (1,) * ndim
+    output = [x.reshape(s0[:i] + (-1,) + s0[i + 1::])
+              for i, x in enumerate(args)]
+
+    shape = [x.size for x in output]
+
+    if indexing == 'xy':
+        # switch first and second axis
+        output[0].shape = (1, -1) + (1,) * (ndim - 2)
+        output[1].shape = (-1, 1) + (1,) * (ndim - 2)
+        shape[0], shape[1] = shape[1], shape[0]
+
+    if sparse:
+        if copy_:
+            return [x.copy() for x in output]
+        else:
+            return output
+    else:
+        # Return the full N-D matrix (not only the 1-D vector)
+        if copy_:
+            mult_fact = np.ones(shape, dtype=int)
+            return [x * mult_fact for x in output]
+        else:
+            return np.broadcast_arrays(*output)
+
+
+def ndgrid(*args, **kwargs):
+    """
+    Same as calling meshgrid with indexing='ij' (see meshgrid for
+    documentation).
+    """
+    kwargs['indexing'] = 'ij'
+    return meshgrid(*args, **kwargs)
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()