Beispiel #1
0
def test():
    '''
    author: twg
    
    '''
    from joblib import Parallel, delayed, dump, load
    from tqdm import tqdm
    
    nmodes = 30
    eigenval = []
    eigenfn = gen_modes(nmodes, 1)
    
    beta = 0.04258226873188785
    for itr in range(nmodes):
        eigenval.append(calc_eigenval(1, beta, itr))
    eigenval = np.asarray(eigenval)
    eigenfn  = np.asarray(eigenfn)
    np.savetxt(outdir + "eigenfn.csv", eigenfn, delimiter = ",")
    np.savetxt(outdir + "eigenval.csv", eigenval, delimiter = ",")
    
    outdir = r"/nfs/data/users/twg/gsmModes/"
    
    beamline = sxri_bl()
    beamline.setup_OE()
    #beamline.setup_beamline()
    #beamline.setup_metrology_beamline(beamline.bl)
    Parallel(n_jobs = 5,backend= "threading")(delayed(beamline.generate_mode)(mode_no, eigenfn, outdir) for mode_no in tqdm(range(nmodes)))
    def solid_syms_Fourier(self, solid, apply_translation = True):
        # x = 0.5 + x, 0.5 - y, -z
        u1 = afnumpy.arrayfire.data.flip(solid.d_array, dim=1)
        u1 = afnumpy.arrayfire.data.flip(u1, dim=0)
        u1 = afnumpy.arrayfire.data.shift(u1, 1, d1=1)

        # x = -x, 0.5 + y, 0.5 - z
        u2 = afnumpy.arrayfire.data.flip(solid.d_array, dim=2)
        u2 = afnumpy.arrayfire.data.flip(u2, dim=0)
        u2 = afnumpy.arrayfire.data.shift(u2, 1, d2=1)

        # x = 0.5 - x, -y, 0.5 + z
        u3 = afnumpy.arrayfire.data.flip(solid.d_array, dim=2)
        u3 = afnumpy.arrayfire.data.flip(u3, dim=1)
        u3 = afnumpy.arrayfire.data.shift(u3, 0, d1=1, d2=1)

        U = afnumpy.arrayfire.data.join(3, solid.d_array, u1, u2, u3)
        U = afnumpy.arrayfire.data.moddims(U, self.syms.shape[3],self.syms.shape[2],self.syms.shape[1],self.syms.shape[0])
        self.syms = afnumpy.asarray(U)
        
        if apply_translation :
            if self.translations is None :
                self.make_Ts()
            
            self.syms *= self.translations
        return self.syms
    def unflip_modes_Fourier(self, U, apply_translation = True):
        # x = 0.5 + x, 0.5 - y, -z
        u1 = afnumpy.arrayfire.data.flip(U[1].d_array, dim=1)
        u1 = afnumpy.arrayfire.data.flip(u1, dim=0)
        u1 = afnumpy.arrayfire.data.shift(u1, 1, d1=1)

        # x = -x, 0.5 + y, 0.5 - z
        u2 = afnumpy.arrayfire.data.flip(U[2].d_array, dim=2)
        u2 = afnumpy.arrayfire.data.flip(u2, dim=0)
        u2 = afnumpy.arrayfire.data.shift(u2, 1, d2=1)

        # x = 0.5 - x, -y, 0.5 + z
        u3 = afnumpy.arrayfire.data.flip(U[3].d_array, dim=2)
        u3 = afnumpy.arrayfire.data.flip(u3, dim=1)
        u3 = afnumpy.arrayfire.data.shift(u3, 0, d1=1, d2=1)

        U_inv = afnumpy.arrayfire.data.join(3, U[0].d_array, u1, u2, u3)
        U_inv = afnumpy.arrayfire.data.moddims(U_inv, self.syms.shape[3],self.syms.shape[2],self.syms.shape[1],self.syms.shape[0])
        U_inv = afnumpy.asarray(U_inv)
        

        if apply_translation :
            if self.translations is None :
                self.make_Ts()
            
            U_inv *= self.translations.conj()
        return U_inv
Beispiel #4
0
def arrayfire_4Dflip(a):
    c1 = afnumpy.arrayfire.data.flip(a.d_array, dim=1)
    c1 = afnumpy.arrayfire.data.shift(c1, 0, d1=1)
    
    b = afnumpy.arrayfire.data.join(3, a.d_array, c1)
    b = afnumpy.arrayfire.data.moddims(b, a.shape[2], a.shape[1], a.shape[0], 2)
    b = afnumpy.asarray(b)
    return b
Beispiel #5
0
    def __init__(self, arg1, shape=None, dtype=None, copy=False):
        spmatrix.__init__(self)

        if isspmatrix(arg1):
            raise ValueError("Copying another sparse matrix not yet implemented")

        elif isinstance(arg1, tuple):
            if isshape(arg1):
                raise ValueError("Empty sparse matrices not implemented")
                # It's a tuple of matrix dimensions (M, N)
                # create empty matrix
                # self._shape = check_shape(arg1)
            else:
                if len(arg1) == 2:                    
                    try:
                        obj, (row, col) = arg1
                    except (TypeError, ValueError):
                        raise TypeError('invalid input format')
                    if shape is None:
                        raise ValueError("shape parameter must not be None") 
                    obj = afnp.asarray(obj)
                    # Arrayfire only supports floating point values
                    if obj.dtype.kind != 'c' and obj.dtype.kind != 'f':
                        obj = obj.astype(afnp.float32)
                    self.dtype = obj.dtype
                    self.d_array = arrayfire.sparse.create_sparse(afnp.asarray(obj).d_array,
                                                             afnp.asarray(row).astype(afnp.int32).d_array, 
                                                             afnp.asarray(col).astype(afnp.int32).d_array,
                                                             shape[0], shape[1],  storage = arrayfire.STORAGE.COO)
                    self.d_array = arrayfire.convert_sparse(self.d_array, arrayfire.STORAGE.CSR)
                    self._shape = shape
                elif len(arg1) == 3:
                    raise ValueError("(data, indices, indptr) format not implemented")
                else:
                    raise ValueError("unrecognized %s_matrix constructor usage" %
                            self.format)

        else:
            # must be dense
            try:
                arg1 = afnp.asarray(arg1)
            except:
                raise ValueError("unrecognized %s_matrix constructor usage" %
                        self.format)
            d_array = arrayfire.sparse.create_sparse_from_dense(arg1)
Beispiel #6
0
def ifftshift(x, axes=None):
    tmp = afnumpy.asarray(x)
    ndim = len(tmp.shape)
    if axes is None:
        axes = list(range(ndim))
    elif isinstance(axes, numbers.Integral):
        axes = [axes]
    shift = [0]*ndim
    for k in axes:
        n = tmp.shape[k]
        shift[k] = (n+1)//2
    s = arrayfire.data.shift(tmp.d_array, *pu.c2f(shift))
    return ndarray(pu.af_shape(s), dtype=pu.typemap(s.dtype()), af_array=s)
Beispiel #7
0
def ifftshift(x, axes=None):
    tmp = afnumpy.asarray(x)
    ndim = len(tmp.shape)
    if axes is None:
        axes = list(range(ndim))
    elif isinstance(axes, numbers.Integral):
        axes = (axes,)
    y = tmp
    for k in axes:
        n = tmp.shape[k]
        p2 = n-(n+1)//2
        mylist = afnumpy.concatenate((afnumpy.arange(p2, n), afnumpy.arange(p2)))
        y = afnumpy.take(y, mylist, k)
    return y
Beispiel #8
0
def angle(z, deg=0):
    """
    Return the angle of the complex argument.

    Parameters
    ----------
    z : array_like
        A complex number or sequence of complex numbers.
    deg : bool, optional
        Return angle in degrees if True, radians if False (default).

    Returns
    -------
    angle : {ndarray, scalar}
        The counterclockwise angle from the positive real axis on
        the complex plane, with dtype as numpy.float64.

    See Also
    --------
    arctan2
    absolute



    Examples
    --------
    >>> np.angle([1.0, 1.0j, 1+1j])               # in radians
    array([ 0.        ,  1.57079633,  0.78539816])
    >>> np.angle(1+1j, deg=True)                  # in degrees
    45.0

    """
    if deg:
        fact = 180 / pi
    else:
        fact = 1.0
    z = afnumpy.asarray(z)
    if numpy.issubdtype(z.dtype, numpy.complexfloating):
        zimag = z.imag
        zreal = z.real
    else:
        zimag = 0
        zreal = z
    return afnumpy.arctan2(zimag, zreal) * fact
Beispiel #9
0
def angle(z, deg=0):
    """
    Return the angle of the complex argument.

    Parameters
    ----------
    z : array_like
        A complex number or sequence of complex numbers.
    deg : bool, optional
        Return angle in degrees if True, radians if False (default).

    Returns
    -------
    angle : {ndarray, scalar}
        The counterclockwise angle from the positive real axis on
        the complex plane, with dtype as numpy.float64.

    See Also
    --------
    arctan2
    absolute



    Examples
    --------
    >>> np.angle([1.0, 1.0j, 1+1j])               # in radians
    array([ 0.        ,  1.57079633,  0.78539816])
    >>> np.angle(1+1j, deg=True)                  # in degrees
    45.0

    """
    if deg:
        fact = 180/pi
    else:
        fact = 1.0
    z = afnumpy.asarray(z)
    if numpy.issubdtype(z.dtype, numpy.complexfloating):
        zimag = z.imag
        zreal = z.real
    else:
        zimag = 0
        zreal = z
    return afnumpy.arctan2(zimag, zreal) * fact
Beispiel #10
0
def repeat(a, repeats, axis=None):
    """
    Repeat elements of an array.

    Parameters
    ----------
    a : array_like
        Input array.
    repeats : int or array of ints
        The number of repetitions for each element.  `repeats` is broadcasted
        to fit the shape of the given axis.
    axis : int, optional
        The axis along which to repeat values.  By default, use the
        flattened input array, and return a flat output array.

    Returns
    -------
    repeated_array : ndarray
        Output array which has the same shape as `a`, except along
        the given axis.

    See Also
    --------
    tile : Tile an array.

    Examples
    --------
    >>> np.repeat(3, 4)
    array([3, 3, 3, 3])
    >>> x = np.array([[1,2],[3,4]])
    >>> np.repeat(x, 2)
    array([1, 1, 2, 2, 3, 3, 4, 4])
    >>> np.repeat(x, 3, axis=1)
    array([[1, 1, 1, 2, 2, 2],
           [3, 3, 3, 4, 4, 4]])
    >>> np.repeat(x, [1, 2], axis=0)
    array([[1, 2],
           [3, 4],
           [3, 4]])

    """
    return afnumpy.asarray(a).repeat(repeats, axis=axis)
    def solid_syms_real(self, solid):
        """
        This uses pixel shifts (not phase ramps) for translation.
        Therefore sub-pixel shifts are ignored.
        """
        translations = []
        translations.append([self.unitcell_size[0]/2, self.unitcell_size[1]/2, 0])
        translations.append([0, self.unitcell_size[1]/2, self.unitcell_size[2]/2])
        translations.append([self.unitcell_size[0]/2, 0, self.unitcell_size[2]/2])
        
        # x = 0.5 + x, 0.5 - y, -z
        u1 = afnumpy.arrayfire.data.flip(solid.d_array, dim=1)
        u1 = afnumpy.arrayfire.data.flip(u1, dim=0)
        u1 = afnumpy.arrayfire.data.shift(u1, 1, d1=1)
        
        t  = translations[0]
        u1 = afnumpy.arrayfire.data.shift(u1, t[-1], d1=t[-2], d2=t[-3])

        # x = -x, 0.5 + y, 0.5 - z
        u2 = afnumpy.arrayfire.data.flip(solid.d_array, dim=2)
        u2 = afnumpy.arrayfire.data.flip(u2, dim=0)
        u2 = afnumpy.arrayfire.data.shift(u2, 1, d2=1)

        t  = translations[1]
        u2 = afnumpy.arrayfire.data.shift(u2, t[-1], d1=t[-2], d2=t[-3])

        # x = 0.5 - x, -y, 0.5 + z
        u3 = afnumpy.arrayfire.data.flip(solid.d_array, dim=2)
        u3 = afnumpy.arrayfire.data.flip(u3, dim=1)
        u3 = afnumpy.arrayfire.data.shift(u3, 0, d1=1, d2=1)
        
        t  = translations[2]
        u3 = afnumpy.arrayfire.data.shift(u3, t[-1], d1=t[-2], d2=t[-3])

        U = afnumpy.arrayfire.data.join(3, solid.d_array, u1, u2, u3)
        U = afnumpy.arrayfire.data.moddims(U, self.syms.shape[3],self.syms.shape[2],self.syms.shape[1],self.syms.shape[0])
        U = afnumpy.asarray(U)
        
        return U
Beispiel #12
0
def asfarray(a, dtype=_nx.float_):
    dtype = _nx.obj2sctype(dtype)
    if not issubclass(dtype, _nx.inexact):
        dtype = _nx.float_
    return afnumpy.asarray(a, dtype=dtype)
Beispiel #13
0
def asfarray(a, dtype=_nx.float_):
    dtype = _nx.obj2sctype(dtype)
    if not issubclass(dtype, _nx.inexact):
        dtype = _nx.float_
    return afnumpy.asarray(a, dtype=dtype)
Beispiel #14
0
def ravel(a, order='C'):
    """
    Return a flattened array.

    A 1-D array, containing the elements of the input, is returned.  A copy is
    made only if needed.

    Parameters
    ----------
    a : array_like
        Input array.  The elements in `a` are read in the order specified by
        `order`, and packed as a 1-D array.
    order : {'C','F', 'A', 'K'}, optional
        The elements of `a` are read using this index order. 'C' means to
        index the elements in C-like order, with the last axis index changing
        fastest, back to the first axis index changing slowest.   'F' means to
        index the elements in Fortran-like index order, with the first index
        changing fastest, and the last index changing slowest. Note that the 'C'
        and 'F' options take no account of the memory layout of the underlying
        array, and only refer to the order of axis indexing.  'A' means to read
        the elements in Fortran-like index order if `a` is Fortran *contiguous*
        in memory, C-like order otherwise.  'K' means to read the elements in
        the order they occur in memory, except for reversing the data when
        strides are negative.  By default, 'C' index order is used.

    Returns
    -------
    1d_array : ndarray
        Output of the same dtype as `a`, and of shape ``(a.size,)``.

    See Also
    --------
    ndarray.flat : 1-D iterator over an array.
    ndarray.flatten : 1-D array copy of the elements of an array
                      in row-major order.

    Notes
    -----
    In C-like (row-major) order, in two dimensions, the row index varies the
    slowest, and the column index the quickest.  This can be generalized to
    multiple dimensions, where row-major order implies that the index along the
    first axis varies slowest, and the index along the last quickest.  The
    opposite holds for Fortran-like, or column-major, index ordering.

    Examples
    --------
    It is equivalent to ``reshape(-1, order=order)``.

    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
    >>> print np.ravel(x)
    [1 2 3 4 5 6]

    >>> print x.reshape(-1)
    [1 2 3 4 5 6]

    >>> print np.ravel(x, order='F')
    [1 4 2 5 3 6]

    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:

    >>> print np.ravel(x.T)
    [1 4 2 5 3 6]
    >>> print np.ravel(x.T, order='A')
    [1 2 3 4 5 6]

    When ``order`` is 'K', it will preserve orderings that are neither 'C'
    nor 'F', but won't reverse axes:

    >>> a = np.arange(3)[::-1]; a
    array([2, 1, 0])
    >>> a.ravel(order='C')
    array([2, 1, 0])
    >>> a.ravel(order='K')
    array([2, 1, 0])

    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    array([[[ 0,  2,  4],
            [ 1,  3,  5]],
           [[ 6,  8, 10],
            [ 7,  9, 11]]])
    >>> a.ravel(order='C')
    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
    >>> a.ravel(order='K')
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

    """
    return afnumpy.asarray(a).ravel(order)
Beispiel #15
0
def ravel(a, order='C'):
    """
    Return a flattened array.

    A 1-D array, containing the elements of the input, is returned.  A copy is
    made only if needed.

    Parameters
    ----------
    a : array_like
        Input array.  The elements in `a` are read in the order specified by
        `order`, and packed as a 1-D array.
    order : {'C','F', 'A', 'K'}, optional
        The elements of `a` are read using this index order. 'C' means to
        index the elements in C-like order, with the last axis index changing
        fastest, back to the first axis index changing slowest.   'F' means to
        index the elements in Fortran-like index order, with the first index
        changing fastest, and the last index changing slowest. Note that the 'C'
        and 'F' options take no account of the memory layout of the underlying
        array, and only refer to the order of axis indexing.  'A' means to read
        the elements in Fortran-like index order if `a` is Fortran *contiguous*
        in memory, C-like order otherwise.  'K' means to read the elements in
        the order they occur in memory, except for reversing the data when
        strides are negative.  By default, 'C' index order is used.

    Returns
    -------
    1d_array : ndarray
        Output of the same dtype as `a`, and of shape ``(a.size,)``.

    See Also
    --------
    ndarray.flat : 1-D iterator over an array.
    ndarray.flatten : 1-D array copy of the elements of an array
                      in row-major order.

    Notes
    -----
    In C-like (row-major) order, in two dimensions, the row index varies the
    slowest, and the column index the quickest.  This can be generalized to
    multiple dimensions, where row-major order implies that the index along the
    first axis varies slowest, and the index along the last quickest.  The
    opposite holds for Fortran-like, or column-major, index ordering.

    Examples
    --------
    It is equivalent to ``reshape(-1, order=order)``.

    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
    >>> print np.ravel(x)
    [1 2 3 4 5 6]

    >>> print x.reshape(-1)
    [1 2 3 4 5 6]

    >>> print np.ravel(x, order='F')
    [1 4 2 5 3 6]

    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:

    >>> print np.ravel(x.T)
    [1 4 2 5 3 6]
    >>> print np.ravel(x.T, order='A')
    [1 2 3 4 5 6]

    When ``order`` is 'K', it will preserve orderings that are neither 'C'
    nor 'F', but won't reverse axes:

    >>> a = np.arange(3)[::-1]; a
    array([2, 1, 0])
    >>> a.ravel(order='C')
    array([2, 1, 0])
    >>> a.ravel(order='K')
    array([2, 1, 0])

    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    array([[[ 0,  2,  4],
            [ 1,  3,  5]],
           [[ 6,  8, 10],
            [ 7,  9, 11]]])
    >>> a.ravel(order='C')
    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
    >>> a.ravel(order='K')
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

    """
    return afnumpy.asarray(a).ravel(order)
Beispiel #16
0
 def __mul__(self, other):
     other = afnp.asarray(other).astype(self.dtype)
     s = arrayfire.matmul(self.d_array, other.d_array)
     a = afnp.ndarray(pu.af_shape(s), dtype=pu.typemap(s.dtype()), af_array=s)
     a._eval()
     return a
Beispiel #17
0
def norm(x, ord=None, axis=None, keepdims=False):
    x = asarray(x)

    # Check the default case first and handle it immediately.
    if ord is None and axis is None:
        ndim = x.ndim
        x = x.ravel(order='K')
        if isComplexType(x.dtype.type):
            sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag)
        else:
            sqnorm = dot(x, x)
        ret = sqrt(sqnorm)
        if keepdims:
            ret = ret.reshape(ndim * [1])
        return ret

    # Normalize the `axis` argument to a tuple.
    nd = x.ndim
    if axis is None:
        axis = tuple(range(nd))
    elif not isinstance(axis, tuple):
        try:
            axis = int(axis)
        except:
            raise TypeError(
                "'axis' must be None, an integer or a tuple of integers")
        axis = (axis, )

    if len(axis) == 1:
        if ord == Inf:
            return abs(x).max(axis=axis, keepdims=keepdims)
        elif ord == -Inf:
            return abs(x).min(axis=axis, keepdims=keepdims)
        elif ord == 0:
            # Zero norm
            return (x != 0).sum(axis=axis, keepdims=keepdims)
        elif ord == 1:
            # special case for speedup
            return afnumpy.sum(abs(x), axis=axis, keepdims=keepdims)
        elif ord is None or ord == 2:
            # special case for speedup
            s = (x.conj() * x).real
            return sqrt(afnumpy.sum(s, axis=axis, keepdims=keepdims))
        else:
            try:
                ord + 1
            except TypeError:
                raise ValueError("Invalid norm order for vectors.")
            if x.dtype.type is longdouble:
                # Convert to a float type, so integer arrays give
                # float results.  Don't apply asfarray to longdouble arrays,
                # because it will downcast to float64.
                absx = abs(x)
            else:
                absx = x if isComplexType(x.dtype.type) else asfarray(x)
                if absx.dtype is x.dtype:
                    absx = abs(absx)
                else:
                    # if the type changed, we can safely overwrite absx
                    abs(absx, out=absx)
            absx **= ord
            return afnumpy.sum(absx, axis=axis, keepdims=keepdims)**(1.0 / ord)
    elif len(axis) == 2:
        row_axis, col_axis = axis
        if not (-nd <= row_axis < nd and -nd <= col_axis < nd):
            raise ValueError('Invalid axis %r for an array with shape %r' %
                             (axis, x.shape))
        if row_axis % nd == col_axis % nd:
            raise ValueError('Duplicate axes given.')
        if ord == 2:
            ret = _multi_svd_norm(x, row_axis, col_axis, amax)
        elif ord == -2:
            ret = _multi_svd_norm(x, row_axis, col_axis, amin)
        elif ord == 1:
            if col_axis > row_axis:
                col_axis -= 1
            ret = afnumpy.sum(abs(x), axis=row_axis).max(axis=col_axis)
        elif ord == Inf:
            if row_axis > col_axis:
                row_axis -= 1
            ret = afnumpy.sum(abs(x), axis=col_axis).max(axis=row_axis)
        elif ord == -1:
            if col_axis > row_axis:
                col_axis -= 1
            ret = afnumpy.sum(abs(x), axis=row_axis).min(axis=col_axis)
        elif ord == -Inf:
            if row_axis > col_axis:
                row_axis -= 1
            ret = afnumpy.sum(abs(x), axis=col_axis).min(axis=row_axis)
        elif ord in [None, 'fro', 'f']:
            ret = sqrt(afnumpy.sum((x.conj() * x).real, axis=axis))
        else:
            raise ValueError("Invalid norm order for matrices.")
        if keepdims:
            ret_shape = list(x.shape)
            ret_shape[axis[0]] = 1
            ret_shape[axis[1]] = 1
            ret = ret.reshape(ret_shape)
        return ret
    else:
        raise ValueError("Improper number of dimensions to norm.")
Beispiel #18
0
def norm(x, ord=None, axis=None, keepdims=False):
    x = asarray(x)

    # Check the default case first and handle it immediately.
    if ord is None and axis is None:
        ndim = x.ndim
        x = x.ravel(order='K')
        if isComplexType(x.dtype.type):
            sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag)
        else:
            sqnorm = dot(x, x)
        ret = sqrt(sqnorm)
        if keepdims:
            ret = ret.reshape(ndim*[1])
        return ret

    # Normalize the `axis` argument to a tuple.
    nd = x.ndim
    if axis is None:
        axis = tuple(range(nd))
    elif not isinstance(axis, tuple):
        try:
            axis = int(axis)
        except:
            raise TypeError("'axis' must be None, an integer or a tuple of integers")
        axis = (axis,)

    if len(axis) == 1:
        if ord == Inf:
            return abs(x).max(axis=axis, keepdims=keepdims)
        elif ord == -Inf:
            return abs(x).min(axis=axis, keepdims=keepdims)
        elif ord == 0:
            # Zero norm
            return (x != 0).sum(axis=axis, keepdims=keepdims)
        elif ord == 1:
            # special case for speedup
            return afnumpy.sum(abs(x), axis=axis, keepdims=keepdims)
        elif ord is None or ord == 2:
            # special case for speedup
            s = (x.conj() * x).real
            return sqrt(afnumpy.sum(s, axis=axis, keepdims=keepdims))
        else:
            try:
                ord + 1
            except TypeError:
                raise ValueError("Invalid norm order for vectors.")
            if x.dtype.type is longdouble:
                # Convert to a float type, so integer arrays give
                # float results.  Don't apply asfarray to longdouble arrays,
                # because it will downcast to float64.
                absx = abs(x)
            else:
                absx = x if isComplexType(x.dtype.type) else asfarray(x)
                if absx.dtype is x.dtype:
                    absx = abs(absx)
                else:
                    # if the type changed, we can safely overwrite absx
                    abs(absx, out=absx)
            absx **= ord
            return afnumpy.sum(absx, axis=axis, keepdims=keepdims) ** (1.0 / ord)
    elif len(axis) == 2:
        row_axis, col_axis = axis
        if not (-nd <= row_axis < nd and -nd <= col_axis < nd):
            raise ValueError('Invalid axis %r for an array with shape %r' %
                             (axis, x.shape))
        if row_axis % nd == col_axis % nd:
            raise ValueError('Duplicate axes given.')
        if ord == 2:
            ret =  _multi_svd_norm(x, row_axis, col_axis, amax)
        elif ord == -2:
            ret = _multi_svd_norm(x, row_axis, col_axis, amin)
        elif ord == 1:
            if col_axis > row_axis:
                col_axis -= 1
            ret = afnumpy.sum(abs(x), axis=row_axis).max(axis=col_axis)
        elif ord == Inf:
            if row_axis > col_axis:
                row_axis -= 1
            ret = afnumpy.sum(abs(x), axis=col_axis).max(axis=row_axis)
        elif ord == -1:
            if col_axis > row_axis:
                col_axis -= 1
            ret = afnumpy.sum(abs(x), axis=row_axis).min(axis=col_axis)
        elif ord == -Inf:
            if row_axis > col_axis:
                row_axis -= 1
            ret = afnumpy.sum(abs(x), axis=col_axis).min(axis=row_axis)
        elif ord in [None, 'fro', 'f']:
            ret = sqrt(afnumpy.sum((x.conj() * x).real, axis=axis))
        else:
            raise ValueError("Invalid norm order for matrices.")
        if keepdims:
            ret_shape = list(x.shape)
            ret_shape[axis[0]] = 1
            ret_shape[axis[1]] = 1
            ret = ret.reshape(ret_shape)
        return ret
    else:
        raise ValueError("Improper number of dimensions to norm.")