Beispiel #1
0
def fft2d(A):
    """
    Compute the 2-dimensional discrete Fourier Transform

    This function computes the *n*-dimensional discrete Fourier Transform
    over any axes in an *M*-dimensional array by means of the
    Fast Fourier Transform (FFT).

    Parameters
    ----------
    a : array_like
        Input array, can be complex

    Returns
    -------
    out : complex ndarray
    """

    if not A.dist():
        raise Exception("The array must be distributed")

    for d in A.shape:
        if (d % np.BLOCKSIZE != 0):
            raise Exception("The array dimensions must be divisible "\
                            "with np.BLOCKSIZE(%d)"%np.BLOCKSIZE)

    #Find an axis that is not distributed.
    localaxis = -1
    for i, p in enumerate(A.pgrid()):
        if p == 1:
            localaxis = i
            break
    if localaxis == -1:
        raise Exception("One dimension in the process grid must not "
                        "be distributed.")

    #Convert to a complex array
    B = np.empty(A.shape, dtype=np.complex, dist=True)
    B[:] = A

    ## 1-D FFT on the X dimension
    l_A = A.local()
    if len(l_A) > 0:
        l_A[:] = np.fft.fft(l_A, axis=localaxis)  ## local FFTs

    ## Transpose
    A = pyHPC.transpose(A)

    ## 1-D FFt on the Y dimension
    l_A = A.local()
    if len(l_A) > 0:
        l_A[:] = np.fft.fft(l_A, axis=localaxis)  ## local FFTs

    ## Transpose
    A = pyHPC.transpose(A)

    return A
Beispiel #2
0
def fft2d(A):
    """
    Compute the 2-dimensional discrete Fourier Transform

    This function computes the *n*-dimensional discrete Fourier Transform
    over any axes in an *M*-dimensional array by means of the
    Fast Fourier Transform (FFT).

    Parameters
    ----------
    a : array_like
        Input array, can be complex

    Returns
    -------
    out : complex ndarray
    """

    if not A.dist():
        raise Exception("The array must be distributed")

    for d in A.shape:
        if(d % np.BLOCKSIZE != 0):
            raise Exception("The array dimensions must be divisible "\
                            "with np.BLOCKSIZE(%d)"%np.BLOCKSIZE)

    #Find an axis that is not distributed.
    localaxis = -1
    for i,p in enumerate(A.pgrid()):
        if p == 1:
            localaxis = i
            break
    if localaxis == -1:
        raise Exception("One dimension in the process grid must not "
                        "be distributed.")

    #Convert to a complex array
    B = np.empty(A.shape, dtype=np.complex, dist=True)
    B[:] = A

    ## 1-D FFT on the X dimension
    l_A = A.local()
    if len(l_A) > 0:
        l_A[:] = np.fft.fft(l_A,axis=localaxis) ## local FFTs

    ## Transpose
    A = pyHPC.transpose(A)

    ## 1-D FFt on the Y dimension
    l_A = A.local()
    if len(l_A) > 0:
        l_A[:] = np.fft.fft(l_A,axis=localaxis) ## local FFTs

    ## Transpose
    A = pyHPC.transpose(A)

    return A
def run():
    if not np.SPMD_MODE:
        print "[rank %d] Warning - ignored in non-SPMD mode\n" % (np.RANK),
        return
    try:  #This test requires the pyHPC module
        import pyHPC
    except:
        print "[rank %d] Warning - ignored pyHPC not found\n" % (np.RANK),
        return
    if np.BLOCKSIZE > 10:
        print "[rank %d] Warning - ignored np.BLOCKSIZE too high\n" % (
            np.RANK),
        return

    niter = 5
    for m in range(np.BLOCKSIZE, niter * np.BLOCKSIZE, np.BLOCKSIZE):
        for n in range(np.BLOCKSIZE, niter * np.BLOCKSIZE, np.BLOCKSIZE):
            for k in range(np.BLOCKSIZE, niter * np.BLOCKSIZE, np.BLOCKSIZE):
                for axis in permutations(xrange(3)):
                    Asrc = dnumpytest.random_list([m, n, k])
                    Ad = np.array(Asrc, dtype=float, dist=True)
                    Af = np.array(Asrc, dtype=float, dist=False)
                    Bd = pyHPC.transpose(Ad, axis)
                    Bf = np.transpose(Af, axis)
                    if not dnumpytest.array_equal(Bd, Bf):
                        raise Exception("Uncorrect result matrix\n")
def run():
    if not np.SPMD_MODE:
        print "[rank %d] Warning - ignored in non-SPMD mode\n"%(np.RANK),
        return
    try:#This test requires the pyHPC module
        import pyHPC
    except:
        print "[rank %d] Warning - ignored pyHPC not found\n"%(np.RANK),
        return
    if np.BLOCKSIZE > 10:
        print "[rank %d] Warning - ignored np.BLOCKSIZE too high\n"%(np.RANK),
        return

    niter = 5
    for m in range(np.BLOCKSIZE,niter*np.BLOCKSIZE, np.BLOCKSIZE):
        for n in range(np.BLOCKSIZE,niter*np.BLOCKSIZE, np.BLOCKSIZE):
            for k in range(np.BLOCKSIZE,niter*np.BLOCKSIZE, np.BLOCKSIZE):
                for axis in permutations(xrange(3)):
                    Asrc = dnumpytest.random_list([m,n,k])
                    Ad = np.array(Asrc, dtype=float, dist=True)
                    Af = np.array(Asrc, dtype=float, dist=False)
                    Bd = pyHPC.transpose(Ad, axis)
                    Bf = np.transpose(Af, axis)
                    if not dnumpytest.array_equal(Bd,Bf):
                        raise Exception("Uncorrect result matrix\n")
Beispiel #5
0
def fft3d(A):
    """
    Compute the 3-dimensional discrete Fourier Transform

    This function computes the *n*-dimensional discrete Fourier Transform
    over any axes in an *M*-dimensional array by means of the
    Fast Fourier Transform (FFT).

    Parameters
    ----------
    a : array_like
        Input array, can be complex

    Returns
    -------
    out : complex ndarray
    """

    if not A.dist():
        raise Exception("The array must be distributed")

    for d in A.shape:
        if (d % np.BLOCKSIZE != 0):
            raise Exception("The array dimensions must be divisible "\
                            "with np.BLOCKSIZE(%d)"%np.BLOCKSIZE)

    #Find an axis that is not distributed.
    localaxis = 0
    if A.pgrid()[0] != 1:
        raise Exception("The first dimension in the process grid must not "
                        "be distributed.")

    #Convert to a complex array
    B = np.empty(A.shape, dtype=np.complex, dist=True)
    B[:] = A

    ## 1-D FFT on data along the X dimension, for which the data
    ## should be local and contiguous
    l_A = A.local()
    if len(l_A) > 0:
        l_A[:] = np.fft.fft(l_A, axis=localaxis)  ## local FFTs

    ## Transpose the X,Y planes: X'=Y, Y'=X, Z'=Z, (Y,X,Z)
    A = pyHPC.transpose(A, (1, 0, 2))

    ## 1-D FFT on data along the Y dimension (now is X', for which the
    ## data should be local and contiguous)
    l_A = A.local()
    if len(l_A) > 0:
        l_A[:] = np.fft.fft(l_A, axis=localaxis)  ## local FFTs

    ## Transpose the X',Z' planes: X''=Z'=Z, Y''=Y'=X, Z''=X'=Y, (Z,X,Y)
    A = pyHPC.transpose(A, (2, 1, 0))

    ## 1-D FFt on data along the Z dimension (now is X'', for which
    ## data should be local and contiguous)
    l_A = A.local()
    if len(l_A) > 0:
        l_A[:] = np.fft.fft(l_A, axis=localaxis)  ## local FFTs

    ## Transpose the X',Z' planes: X''=Z'=Z, Y''=Y'=X, Z''=X'=Y, (Z,X,Y)
    A = pyHPC.transpose(A, (1, 2, 0))

    return A
Beispiel #6
0
def fft3d(A):
    """
    Compute the 3-dimensional discrete Fourier Transform

    This function computes the *n*-dimensional discrete Fourier Transform
    over any axes in an *M*-dimensional array by means of the
    Fast Fourier Transform (FFT).

    Parameters
    ----------
    a : array_like
        Input array, can be complex

    Returns
    -------
    out : complex ndarray
    """

    if not A.dist():
        raise Exception("The array must be distributed")

    for d in A.shape:
        if(d % np.BLOCKSIZE != 0):
            raise Exception("The array dimensions must be divisible "\
                            "with np.BLOCKSIZE(%d)"%np.BLOCKSIZE)

    #Find an axis that is not distributed.
    localaxis=0
    if A.pgrid()[0] != 1:
        raise Exception("The first dimension in the process grid must not "
                        "be distributed.")

    #Convert to a complex array
    B = np.empty(A.shape, dtype=np.complex, dist=True)
    B[:] = A

    ## 1-D FFT on data along the X dimension, for which the data
    ## should be local and contiguous
    l_A = A.local()
    if len(l_A) > 0:
        l_A[:] = np.fft.fft(l_A,axis=localaxis) ## local FFTs

    ## Transpose the X,Y planes: X'=Y, Y'=X, Z'=Z, (Y,X,Z)
    A = pyHPC.transpose(A,(1,0,2))

    ## 1-D FFT on data along the Y dimension (now is X', for which the
    ## data should be local and contiguous)
    l_A = A.local()
    if len(l_A) > 0:
        l_A[:] = np.fft.fft(l_A,axis=localaxis) ## local FFTs

    ## Transpose the X',Z' planes: X''=Z'=Z, Y''=Y'=X, Z''=X'=Y, (Z,X,Y)
    A = pyHPC.transpose(A,(2,1,0))

    ## 1-D FFt on data along the Z dimension (now is X'', for which
    ## data should be local and contiguous)
    l_A = A.local()
    if len(l_A) > 0:
        l_A[:] = np.fft.fft(l_A,axis=localaxis) ## local FFTs

    ## Transpose the X',Z' planes: X''=Z'=Z, Y''=Y'=X, Z''=X'=Y, (Z,X,Y)
    A = pyHPC.transpose(A,(1,2,0))

    return A