Merge branch 'new_interface' into 'master'

New interface

See merge request !12

bench.py

+import numpy as np
+import pypocketfft
+import pyfftw
+from time import time
+import matplotlib.pyplot as plt
+import math
+
+nthr = 1
+
+
+def _l2error(a, b):
+    return np.sqrt(np.sum(np.abs(a-b)**2)/np.sum(np.abs(a)**2))
+
+
+def prime_factorize(n):
+    factors = []
+    number = math.fabs(n)
+
+    while number > 1:
+        factor = get_next_prime_factor(number)
+        factors.append(factor)
+        number /= factor
+
+    if n < -1:  # If we'd check for < 0, -1 would give us trouble
+        factors[0] = -factors[0]
+
+    return tuple(factors)
+
+
+def get_next_prime_factor(n):
+    if n % 2 == 0:
+        return 2
+
+    # Not 'good' [also] checking non-prime numbers I guess?
+    # But the alternative, creating a list of prime numbers,
+    # wouldn't it be more demanding? Process of creating it.
+    for x in range(3, int(math.ceil(math.sqrt(n)) + 1), 2):
+        if n % x == 0:
+            return x
+    return int(n)
+
+
+def measure_fftw(a, nrepeat):
+    import pyfftw
+    f1 = pyfftw.empty_aligned(a.shape, dtype=a.dtype)
+    f1[()] = a
+    f2 = pyfftw.empty_aligned(a.shape, dtype=a.dtype)
+    fftw = pyfftw.FFTW(f1, f2, flags=('FFTW_MEASURE',), threads=nthr)
+    tmin = 1e38
+    for i in range(nrepeat):
+        t0 = time()
+        fftw()
+        t1 = time()
+        tmin = min(tmin, t1-t0)
+    return tmin
+
+
+def measure_fftw_np_interface(a, nrepeat):
+    import pyfftw
+    pyfftw.interfaces.cache.enable()
+    tmin = 1e38
+    for i in range(nrepeat):
+        t0 = time()
+        b = pyfftw.interfaces.numpy_fft.fftn(a)
+        t1 = time()
+        tmin = min(tmin, t1-t0)
+    return tmin
+
+
+def measure_pypocketfft(a, nrepeat):
+    import pypocketfft as ppf
+    tmin = 1e38
+    for i in range(nrepeat):
+        t0 = time()
+        b = ppf.c2c(a, forward=True, nthreads=nthr)
+        t1 = time()
+        tmin = min(tmin, t1-t0)
+    return tmin
+
+
+def measure_scipy_fftpack(a, nrepeat):
+    import scipy.fftpack
+    tmin = 1e38
+    for i in range(nrepeat):
+        t0 = time()
+        b = scipy.fftpack.fftn(a)
+        t1 = time()
+        tmin = min(tmin, t1-t0)
+    return tmin
+
+
+def bench_nd(ndim, nmax, ntry, tp, funcs, nrepeat, ttl="", filename=""):
+    results = [[] for i in range(len(funcs))]
+    for n in range(ntry):
+        print(n, ntry)
+        shp = np.random.randint(nmax//3, nmax+1, ndim)
+        a = (np.random.rand(*shp) + 1j*np.random.rand(*shp)).astype(tp)
+        for func, res in zip(funcs, results):
+            res.append(func(a, nrepeat))
+    results = np.array(results)
+    plt.title("{}: {}D, {}, max_extent={}".format(
+        ttl, ndim, str(tp), nmax))
+    plt.xlabel("time ratio")
+    plt.ylabel("counts")
+    plt.hist(results[0, :]/results[1, :], bins="auto")
+    if filename != "":
+        plt.savefig(filename)
+    plt.show()
+
+
+funcs = (measure_pypocketfft, measure_fftw)
+ttl = "pypocketfft/FFTW()"
+bench_nd(1, 8192, 100, "c16", funcs, 10, ttl, "1d.png")
+bench_nd(2, 2048, 100, "c16", funcs, 2, ttl, "2d.png")
+bench_nd(3, 256, 100, "c16", funcs, 2, ttl, "3d.png")
+bench_nd(1, 8192, 100, "c8", funcs, 10, ttl, "1d_single.png")
+bench_nd(2, 2048, 100, "c8", funcs, 2, ttl, "2d_single.png")
+bench_nd(3, 256, 100, "c8", funcs, 2, ttl, "3d_single.png")

bench_nd.py

@@ -5,7 +5,7 @@ import pypocketfft
 from time import time
 import matplotlib.pyplot as plt
 
-nthreads=0
+nthreads=1
 def _l2error(a,b):
     return np.sqrt(np.sum(np.abs(a-b)**2)/np.sum(np.abs(a)**2))
 
@@ -23,10 +23,10 @@ def bench_nd_fftn(ndim, nmax, ntry, tp, nrepeat, filename=""):
         tmin_pp=1e38
         for i in range(nrepeat):
             t0=time()
-            b=pypocketfft.fftn(a,nthreads=nthreads)
+            b=pypocketfft.c2c(a,nthreads=nthreads, forward=True)
             t1=time()
             tmin_pp = min(tmin_pp,t1-t0)
-        a2=pypocketfft.ifftn(b,fct=1./a.size)
+        a2=pypocketfft.c2c(b,inorm=2, forward=False)
         assert(_l2error(a,a2)<(2.5e-15 if tp=='c16' else 6e-7))
         res.append(tmin_pp/tmin_np)
     plt.title("t(pypocketfft / numpy 1.17), {}D, {}, max_extent={}".format(ndim, str(tp), nmax))

setup.py

@@ -21,9 +21,9 @@ if sys.platform == 'darwin':
     extra_compile_args += ['--stdlib=libc++', '-mmacosx-version-min=10.9']
     vars = distutils.sysconfig.get_config_vars()
     vars['LDSHARED'] = vars['LDSHARED'].replace('-bundle', '')
-    python_module_link_args+=['-bundle']
+    python_module_link_args += ['-bundle']
 else:
-    extra_compile_args += ['-DPOCKETFFT_OPENMP', '-fopenmp', '-Wfatal-errors', '-Wfloat-conversion' ,'-Wsign-conversion', '-Wconversion' ,'-W', '-Wall', '-Wstrict-aliasing=2', '-Wwrite-strings', '-Wredundant-decls', '-Woverloaded-virtual', '-Wcast-qual', '-Wcast-align', '-Wpointer-arith']
+    extra_compile_args += ['-DPOCKETFFT_OPENMP', '-fopenmp', '-Wfatal-errors', '-Wfloat-conversion', '-Wsign-conversion', '-Wconversion' ,'-W', '-Wall', '-Wstrict-aliasing=2', '-Wwrite-strings', '-Wredundant-decls', '-Woverloaded-virtual', '-Wcast-qual', '-Wcast-align', '-Wpointer-arith']
     python_module_link_args += ['-march=native', '-Wl,-rpath,$ORIGIN', '-fopenmp']
 
 # if you don't want debugging info, add "-s" to python_module_link_args

stress.py

 import numpy as np
 import pypocketfft
 
-def _l2error(a,b):
+
+def _l2error(a, b):
     return np.sqrt(np.sum(np.abs(a-b)**2)/np.sum(np.abs(a)**2))
 
-nthreads=0
-cmaxerr=0.
-fmaxerr=0.
-cmaxerrf=0.
-fmaxerrf=0.
-hmaxerr=0.
-hmaxerrf=0.
-def test():
-    global cmaxerr, fmaxerr, hmaxerr, cmaxerrf, fmaxerrf, hmaxerrf
-    ndim=np.random.randint(1,5)
-    axlen=int((2**20)**(1./ndim))
-    shape = np.random.randint(1,axlen,ndim)
+
+def fftn(a, axes=None, inorm=0, out=None, nthreads=1):
+    return pypocketfft.c2c(a, axes=axes, forward=True, inorm=inorm,
+                           out=out, nthreads=nthreads)
+
+
+def ifftn(a, axes=None, inorm=0, out=None, nthreads=1):
+    return pypocketfft.c2c(a, axes=axes, forward=False, inorm=inorm,
+                           out=out, nthreads=nthreads)
+
+
+def rfftn(a, axes=None, inorm=0, nthreads=1):
+    return pypocketfft.r2c(a, axes=axes, forward=True, inorm=inorm,
+                           nthreads=nthreads)
+
+
+def irfftn(a, axes=None, lastsize=0, inorm=0, nthreads=1):
+    return pypocketfft.c2r(a, axes=axes, lastsize=lastsize, forward=False,
+                           inorm=inorm, nthreads=nthreads)
+
+
+nthreads = 0
+
+
+def update_err(err, name, value):
+    if name not in err:
+        err[name] = value
+        print("{}: {}".format(name, value))
+    else:
+        if value > err[name]:
+            err[name] = value
+            print("{}: {}".format(name, value))
+    return err
+
+
+def test(err):
+    ndim = np.random.randint(1, 5)
+    axlen = int((2**20)**(1./ndim))
+    shape = np.random.randint(1, axlen, ndim)
     axes = np.arange(ndim)
     np.random.shuffle(axes)
-    nax = np.random.randint(1,ndim+1)
+    nax = np.random.randint(1, ndim+1)
     axes = axes[:nax]
     lastsize = shape[axes[-1]]
-    fct = 1./np.prod(np.take(shape, axes))
-    a=np.random.rand(*shape)-0.5 + 1j*np.random.rand(*shape)-0.5j
-    b=pypocketfft.ifftn(pypocketfft.fftn(a,axes=axes,nthreads=nthreads),axes=axes,fct=fct,nthreads=nthreads)
-    err = _l2error(a,b)
-    if err > cmaxerr:
-        cmaxerr = err
-        print("cmaxerr:", cmaxerr, shape, axes)
-    b=pypocketfft.irfftn(pypocketfft.rfftn(a.real,axes=axes,nthreads=nthreads),axes=axes,fct=fct,lastsize=lastsize,nthreads=nthreads)
-    err = _l2error(a.real,b)
-    if err > fmaxerr:
-        fmaxerr = err
-        print("fmaxerr:", fmaxerr, shape, axes)
-    b=pypocketfft.ifftn(pypocketfft.fftn(a.astype(np.complex64),axes=axes,nthreads=nthreads),axes=axes,fct=fct,nthreads=nthreads)
-    err = _l2error(a.astype(np.complex64),b)
-    if err > cmaxerrf:
-        cmaxerrf = err
-        print("cmaxerrf:", cmaxerrf, shape, axes)
-    b=pypocketfft.irfftn(pypocketfft.rfftn(a.real.astype(np.float32),axes=axes,nthreads=nthreads),axes=axes,fct=fct,lastsize=lastsize,nthreads=nthreads)
-    err = _l2error(a.real.astype(np.float32),b)
-    if err > fmaxerrf:
-        fmaxerrf = err
-        print("fmaxerrf:", fmaxerrf, shape, axes)
-    b=pypocketfft.hartley(pypocketfft.hartley(a.real,axes=axes,nthreads=nthreads),axes=axes,fct=fct,nthreads=nthreads)
-    err = _l2error(a.real,b)
-    if err > hmaxerr:
-        hmaxerr = err
-        print("hmaxerr:", hmaxerr, shape, axes)
-    b=pypocketfft.hartley(pypocketfft.hartley(a.real.astype(np.float32),axes=axes,nthreads=nthreads),axes=axes,fct=fct,nthreads=nthreads)
-    err = _l2error(a.real.astype(np.float32),b)
-    if err > hmaxerrf:
-        hmaxerrf = err
-        print("hmaxerrf:", hmaxerrf, shape, axes)
+    a = np.random.rand(*shape)-0.5 + 1j*np.random.rand(*shape)-0.5j
+    b = ifftn(fftn(a, axes=axes, nthreads=nthreads), axes=axes, inorm=2,
+              nthreads=nthreads)
+    err = update_err(err, "cmax", _l2error(a, b))
+    b = ifftn(fftn(a.real, axes=axes, nthreads=nthreads), axes=axes, inorm=2,
+              nthreads=nthreads)
+    err = update_err(err, "cmax", _l2error(a.real, b))
+    b = fftn(ifftn(a.real, axes=axes, nthreads=nthreads), axes=axes, inorm=2,
+             nthreads=nthreads)
+    err = update_err(err, "cmax", _l2error(a.real, b))
+    b = irfftn(rfftn(a.real, axes=axes, nthreads=nthreads), axes=axes, inorm=2,
+               lastsize=lastsize, nthreads=nthreads)
+    err = update_err(err, "rmax", _l2error(a.real, b))
+    b = ifftn(fftn(a.astype(np.complex64), axes=axes, nthreads=nthreads),
+              axes=axes, inorm=2, nthreads=nthreads)
+    err = update_err(err, "cmaxf", _l2error(a.astype(np.complex64), b))
+    b = irfftn(rfftn(a.real.astype(np.float32), axes=axes, nthreads=nthreads),
+               axes=axes, inorm=2, lastsize=lastsize, nthreads=nthreads)
+    err = update_err(err, "rmaxf", _l2error(a.real.astype(np.float32), b))
+    b = pypocketfft.separable_hartley(
+        pypocketfft.separable_hartley(a.real, axes=axes, nthreads=nthreads),
+        axes=axes, inorm=2, nthreads=nthreads)
+    err = update_err(err, "hmax", _l2error(a.real, b))
+    b = pypocketfft.genuine_hartley(
+        pypocketfft.genuine_hartley(a.real, axes=axes, nthreads=nthreads),
+        axes=axes, inorm=2, nthreads=nthreads)
+    err = update_err(err, "hmax", _l2error(a.real, b))
+    b = pypocketfft.separable_hartley(
+            pypocketfft.separable_hartley(
+                a.real.astype(np.float32), axes=axes, nthreads=nthreads),
+            axes=axes, inorm=2, nthreads=nthreads)
+    err = update_err(err, "hmaxf", _l2error(a.real.astype(np.float32), b))
+    b = pypocketfft.genuine_hartley(
+            pypocketfft.genuine_hartley(a.real.astype(np.float32), axes=axes,
+                                        nthreads=nthreads),
+            axes=axes, inorm=2, nthreads=nthreads)
+    err = update_err(err, "hmaxf", _l2error(a.real.astype(np.float32), b))
+
 
+err = dict()
 while True:
-    test()
+    test(err)

test.py

@@ -2,125 +2,197 @@ import pypocketfft
 import pyfftw
 import numpy as np
 import pytest
+from numpy.testing import assert_
 
 pmp = pytest.mark.parametrize
 
 shapes1D = ((10,), (127,))
-shapes2D = ((128, 128), (128, 129), (1, 129), (129,1))
-shapes3D = ((32,17,39),)
+shapes2D = ((128, 128), (128, 129), (1, 129), (129, 1))
+shapes3D = ((32, 17, 39),)
 shapes = shapes1D+shapes2D+shapes3D
-len1D=range(1,2048)
+len1D = range(1, 2048)
 
-def _l2error(a,b):
+
+def _l2error(a, b):
     return np.sqrt(np.sum(np.abs(a-b)**2)/np.sum(np.abs(a)**2))
 
+
+def fftn(a, axes=None, inorm=0, out=None, nthreads=1):
+    return pypocketfft.c2c(a, axes=axes, forward=True, inorm=inorm,
+                           out=out, nthreads=nthreads)
+
+
+def ifftn(a, axes=None, inorm=0, out=None, nthreads=1):
+    return pypocketfft.c2c(a, axes=axes, forward=False, inorm=inorm,
+                           out=out, nthreads=nthreads)
+
+
+def rfftn(a, axes=None, inorm=0, nthreads=1):
+    return pypocketfft.r2c(a, axes=axes, forward=True, inorm=inorm,
+                           nthreads=nthreads)
+
+
+def irfftn(a, axes=None, lastsize=0, inorm=0, nthreads=1):
+    return pypocketfft.c2r(a, axes=axes, lastsize=lastsize, forward=False,
+                           inorm=inorm, nthreads=nthreads)
+
+
+def rfft_scipy(a, axis, inorm=0, out=None, nthreads=1):
+    return pypocketfft.r2r_fftpack(a, axes=(axis,), real2hermitian=True,
+                                   forward=True, inorm=inorm, out=out,
+                                   nthreads=nthreads)
+
+
+def irfft_scipy(a, axis, inorm=0, out=None, nthreads=1):
+    return pypocketfft.r2r_fftpack(a, axes=(axis,), real2hermitian=False,
+                                   forward=False, inorm=inorm, out=out,
+                                   nthreads=nthreads)
+
+
 @pmp("len", len1D)
-def test1D(len):
-    a=np.random.rand(len)-0.5 + 1j*np.random.rand(len)-0.5j
-    b=a.astype(np.complex64)
-    c=a.astype(np.complex256)
-    assert(_l2error(a, pypocketfft.ifftn(pypocketfft.fftn(c))*np.float128(1.)/len)<1e-18)
-    assert(_l2error(a, pypocketfft.ifftn(pypocketfft.fftn(a),fct=1./len))<1.5e-15)
-    assert(_l2error(a.real, pypocketfft.irfftn(pypocketfft.rfftn(a.real),fct=1./len,lastsize=len))<1.5e-15)
-    tmp=a.copy()
-    assert (pypocketfft.ifftn(pypocketfft.fftn(tmp, inplace=True), fct=1./len, inplace=True) is tmp)
-    assert(_l2error(tmp, a)<1.5e-15)
-    assert(_l2error(b, pypocketfft.ifftn(pypocketfft.fftn(b),fct=1./len))<6e-7)
-    assert(_l2error(b.real, pypocketfft.irfftn(pypocketfft.rfftn(b.real),fct=1./len,lastsize=len))<6e-7)
-    tmp=b.copy()
-    assert (pypocketfft.ifftn(pypocketfft.fftn(tmp, inplace=True), fct=1./len, inplace=True) is tmp)
-    assert(_l2error(tmp, b)<6e-7)
+@pmp("inorm", [0, 1, 2])
+def test1D(len, inorm):
+    a = np.random.rand(len)-0.5 + 1j*np.random.rand(len)-0.5j
+    b = a.astype(np.complex64)
+    c = a.astype(np.complex256)
+    assert_(_l2error(a, ifftn(fftn(c, inorm=inorm), inorm=2-inorm)) < 1e-18)
+    assert_(_l2error(a, ifftn(fftn(a, inorm=inorm), inorm=2-inorm)) < 1.5e-15)
+    assert_(_l2error(a.real, ifftn(fftn(a.real, inorm=inorm), inorm=2-inorm))
+            < 1.5e-15)
+    assert_(_l2error(a.real, fftn(ifftn(a.real, inorm=inorm), inorm=2-inorm))
+            < 1.5e-15)
+    assert_(_l2error(a.real, irfftn(rfftn(a.real, inorm=inorm),
+                                    inorm=2-inorm, lastsize=len)) < 1.5e-15)
+    tmp = a.copy()
+    assert_(ifftn(fftn(tmp, out=tmp, inorm=inorm), out=tmp, inorm=2-inorm)
+            is tmp)
+    assert_(_l2error(tmp, a) < 1.5e-15)
+    assert_(_l2error(b, ifftn(fftn(b, inorm=inorm), inorm=2-inorm)) < 6e-7)
+    assert_(_l2error(b.real, ifftn(fftn(b.real, inorm=inorm), inorm=2-inorm))
+            < 6e-7)
+    assert_(_l2error(b.real, fftn(ifftn(b.real, inorm=inorm), inorm=2-inorm))
+            < 6e-7)
+    assert_(_l2error(b.real, irfftn(rfftn(b.real, inorm=inorm), lastsize=len,
+                                    inorm=2-inorm)) < 6e-7)
+    tmp = b.copy()
+    assert_(ifftn(fftn(tmp, out=tmp, inorm=inorm), out=tmp, inorm=2-inorm)
+            is tmp)
+    assert_(_l2error(tmp, b) < 6e-7)
+
 
 @pmp("shp", shapes)
-@pmp("nthreads", (0,1,2))
+@pmp("nthreads", (0, 1, 2))
 def test_fftn(shp, nthreads):
-    a=np.random.rand(*shp)-0.5 + 1j*np.random.rand(*shp)-0.5j
-    assert(_l2error(pyfftw.interfaces.numpy_fft.fftn(a), pypocketfft.fftn(a, nthreads=nthreads))<1e-15)
-    a=a.astype(np.complex64)
-    assert(_l2error(pyfftw.interfaces.numpy_fft.fftn(a), pypocketfft.fftn(a, nthreads=nthreads))<5e-7)
+    a = np.random.rand(*shp)-0.5 + 1j*np.random.rand(*shp)-0.5j
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.fftn(a),
+                     fftn(a, nthreads=nthreads)) < 1e-15)
+    a = a.astype(np.complex64)
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.fftn(a),
+                     fftn(a, nthreads=nthreads)) < 5e-7)
+
 
 @pmp("shp", shapes2D)
-@pmp("axes", ((0,),(1,),(0,1),(1,0)))
+@pmp("axes", ((0,), (1,), (0, 1), (1, 0)))
 def test_fftn2D(shp, axes):
-    a=np.random.rand(*shp)-0.5 + 1j*np.random.rand(*shp)-0.5j
-    assert(_l2error(pyfftw.interfaces.numpy_fft.fftn(a, axes=axes), pypocketfft.fftn(a, axes=axes))<1e-15)
-    a=a.astype(np.complex64)
-    assert(_l2error(pyfftw.interfaces.numpy_fft.fftn(a, axes=axes), pypocketfft.fftn(a, axes=axes))<5e-7)
+    a = np.random.rand(*shp)-0.5 + 1j*np.random.rand(*shp)-0.5j
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.fftn(a, axes=axes),
+                     fftn(a, axes=axes)) < 1e-15)
+    a = a.astype(np.complex64)
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.fftn(a, axes=axes),
+                     fftn(a, axes=axes)) < 5e-7)
+
 
 @pmp("shp", shapes)
 def test_rfftn(shp):
-    a=np.random.rand(*shp)-0.5
-    assert(_l2error(pyfftw.interfaces.numpy_fft.rfftn(a), pypocketfft.rfftn(a))<1e-15)
-    a=a.astype(np.float32)
-    assert(_l2error(pyfftw.interfaces.numpy_fft.rfftn(a), pypocketfft.rfftn(a))<5e-7)
+    a = np.random.rand(*shp)-0.5
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.rfftn(a), rfftn(a)) < 1e-15)
+    a = a.astype(np.float32)
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.rfftn(a), rfftn(a)) < 5e-7)
+
 
 @pmp("shp", shapes)
 def test_rfft_scipy(shp):
     for i in range(len(shp)):
-        a=np.random.rand(*shp)-0.5
-        assert(_l2error(pyfftw.interfaces.scipy_fftpack.rfft(a,axis=i), pypocketfft.rfft_scipy(a,axis=i))<1e-15)
-        assert(_l2error(pyfftw.interfaces.scipy_fftpack.irfft(a,axis=i), pypocketfft.irfft_scipy(a,axis=i,fct=1./a.shape[i]))<1e-15)
+        a = np.random.rand(*shp)-0.5
+        assert_(_l2error(pyfftw.interfaces.scipy_fftpack.rfft(a, axis=i),
+                         rfft_scipy(a, axis=i)) < 1e-15)
+        assert_(_l2error(pyfftw.interfaces.scipy_fftpack.irfft(a, axis=i),
+                         irfft_scipy(a, axis=i, inorm=2)) < 1e-15)
+
 
 @pmp("shp", shapes2D)
-@pmp("axes", ((0,),(1,),(0,1),(1,0)))
+@pmp("axes", ((0,), (1,), (0, 1), (1, 0)))
 def test_rfftn2D(shp, axes):
-    a=np.random.rand(*shp)-0.5
-    assert(_l2error(pyfftw.interfaces.numpy_fft.rfftn(a, axes=axes), pypocketfft.rfftn(a, axes=axes))<1e-15)
-    a=a.astype(np.float32)
-    assert(_l2error(pyfftw.interfaces.numpy_fft.rfftn(a, axes=axes), pypocketfft.rfftn(a, axes=axes))<5e-7)
+    a = np.random.rand(*shp)-0.5
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.rfftn(a, axes=axes),
+                     rfftn(a, axes=axes)) < 1e-15)
+    a = a.astype(np.float32)
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.rfftn(a, axes=axes),
+                     rfftn(a, axes=axes)) < 5e-7)
+
 
 @pmp("shp", shapes)
 def test_identity(shp):
-    a=np.random.rand(*shp)-0.5 + 1j*np.random.rand(*shp)-0.5j
-    assert(_l2error(pypocketfft.ifftn(pypocketfft.fftn(a),fct=1./a.size), a)<1.5e-15)
-    tmp=a.copy()
-    assert (pypocketfft.ifftn(pypocketfft.fftn(tmp, inplace=True), fct=1./a.size, inplace=True) is tmp)
-    assert(_l2error(tmp, a)<1.5e-15)
-    a=a.astype(np.complex64)
-    assert(_l2error(pypocketfft.ifftn(pypocketfft.fftn(a),fct=1./a.size), a)<6e-7)
+    a = np.random.rand(*shp)-0.5 + 1j*np.random.rand(*shp)-0.5j
+    assert_(_l2error(ifftn(fftn(a), inorm=2), a) < 1.5e-15)
+    assert_(_l2error(ifftn(fftn(a.real), inorm=2), a.real) < 1.5e-15)
+    assert_(_l2error(fftn(ifftn(a.real), inorm=2), a.real) < 1.5e-15)
+    tmp = a.copy()
+    assert_(ifftn(fftn(tmp, out=tmp), inorm=2, out=tmp) is tmp)
+    assert_(_l2error(tmp, a) < 1.5e-15)
+    a = a.astype(np.complex64)
+    assert_(_l2error(ifftn(fftn(a), inorm=2), a) < 6e-7)
+
 
 @pmp("shp", shapes)
 def test_identity_r(shp):
-    a=np.random.rand(*shp)-0.5
-    b=a.astype(np.float32)
+    a = np.random.rand(*shp)-0.5
+    b = a.astype(np.float32)
     for ax in range(a.ndim):
         n = a.shape[ax]
-        assert(_l2error(pypocketfft.irfftn(pypocketfft.rfftn(a,(ax,)),(ax,),lastsize=n,fct=1./n), a)<1e-15)
-        assert(_l2error(pypocketfft.irfftn(pypocketfft.rfftn(b,(ax,)),(ax,),lastsize=n,fct=1./n), b)<5e-7)
+        assert_(_l2error(irfftn(rfftn(a, (ax,)), (ax,), lastsize=n, inorm=2),
+                         a) < 1e-15)
+        assert_(_l2error(irfftn(rfftn(b, (ax,)), (ax,), lastsize=n, inorm=2),
+                         b) < 5e-7)
+
 
 @pmp("shp", shapes)
 def test_identity_r2(shp):
-    a=np.random.rand(*shp)-0.5 + 1j*np.random.rand(*shp)-0.5j
-    a=pypocketfft.rfftn(pypocketfft.irfftn(a))
-    fct = 1./pypocketfft.irfftn(a).size
-    assert(_l2error(pypocketfft.rfftn(pypocketfft.irfftn(a),fct=fct), a)<1e-15)
+    a = np.random.rand(*shp)-0.5 + 1j*np.random.rand(*shp)-0.5j
+    a = rfftn(irfftn(a))
+    assert_(_l2error(rfftn(irfftn(a), inorm=2), a) < 1e-15)
+
 
 @pmp("shp", shapes2D+shapes3D)
-def test_hartley2(shp):
-    a=np.random.rand(*shp)-0.5
-    v1 = pypocketfft.hartley2(a)
-    v2 = pypocketfft.fftn(a.astype(np.complex128))
+def test_genuine_hartley(shp):
+    a = np.random.rand(*shp)-0.5
+    v1 = pypocketfft.genuine_hartley(a)
+    v2 = fftn(a.astype(np.complex128))
     v2 = v2.real+v2.imag
-    assert(_l2error(v1, v2)<1e-15)
+    assert_(_l2error(v1, v2) < 1e-15)
+
 
 @pmp("shp", shapes)
 def test_hartley_identity(shp):
-    a=np.random.rand(*shp)-0.5
-    v1 = pypocketfft.hartley(pypocketfft.hartley(a))/a.size
-    assert(_l2error(a, v1)<1e-15)
+    a = np.random.rand(*shp)-0.5
+    v1 = pypocketfft.separable_hartley(pypocketfft.separable_hartley(a))/a.size
+    assert_(_l2error(a, v1) < 1e-15)
+
 
 @pmp("shp", shapes)
-def test_hartley2_identity(shp):
-    a=np.random.rand(*shp)-0.5
-    v1 = pypocketfft.hartley2(pypocketfft.hartley2(a))/a.size
-    assert(_l2error(a, v1)<1e-15)
+def test_genuine_hartley_identity(shp):
+    a = np.random.rand(*shp)-0.5
+    v1 = pypocketfft.genuine_hartley(pypocketfft.genuine_hartley(a))/a.size
+    assert_(_l2error(a, v1) < 1e-15)
     v1 = a.copy()
-    assert (pypocketfft.hartley2(pypocketfft.hartley2(v1, inplace=True), fct=1./a.size, inplace=True) is v1)
-    assert(_l2error(a, v1)<1e-15)
+    assert_(pypocketfft.genuine_hartley(
+        pypocketfft.genuine_hartley(v1, out=v1), inorm=2, out=v1) is v1)
+    assert_(_l2error(a, v1) < 1e-15)
+
 
 @pmp("shp", shapes2D)
-@pmp("axes", ((0,),(1,),(0,1),(1,0)))
-def test_hartley2_2D(shp, axes):
-    a=np.random.rand(*shp)-0.5
-    fct = 1./np.prod(np.take(shp,axes))
-    assert(_l2error(pypocketfft.hartley2(pypocketfft.hartley2(a, axes=axes), axes=axes, fct=fct),a)<1e-15)
+@pmp("axes", ((0,), (1,), (0, 1), (1, 0)))
+def test_genuine_hartley_2D(shp, axes):
+    a = np.random.rand(*shp)-0.5
+    assert_(_l2error(pypocketfft.genuine_hartley(pypocketfft.genuine_hartley(
+        a, axes=axes), axes=axes, inorm=2), a)