change normalization parameters

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))
 
@@ -26,7 +26,7 @@ def bench_nd_fftn(ndim, nmax, ntry, tp, nrepeat, filename=""):
             b=pypocketfft.fftn(a,nthreads=nthreads)
             t1=time()
             tmin_pp = min(tmin_pp,t1-t0)
-        a2=pypocketfft.ifftn(b,fct=1./a.size)
+        a2=pypocketfft.ifftn(b,inorm=2)
         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))

pocketfft_hdronly.h

@@ -34,11 +34,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define POCKETFFT_HDRONLY_H
 
 #ifndef __cplusplus
-#error This file is C++ and requires a C++ compiler
+#error This file is C++ and requires a C++ compiler.
 #endif
 
 #if !(__cplusplus >= 201103L || _MSVC_LANG+0L >= 201103L)
-#error This file requires at least C++11 support
+#error This file requires at least C++11 support.
 #endif
 
 #include <cmath>
@@ -48,9 +48,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <memory>
 #include <vector>
 #include <complex>
-#if defined(_WIN32)
-#include <malloc.h>
-#endif
 #ifdef POCKETFFT_OPENMP
 #include <omp.h>
 #endif
@@ -83,7 +80,7 @@ constexpr bool FORWARD  = true,
 #ifndef POCKETFFT_NO_VECTORS
 #define POCKETFFT_NO_VECTORS
 #if defined(__INTEL_COMPILER)
-// do nothing. This is necessary because this compiler also sets __GNUC__
+// do nothing. This is necessary because this compiler also sets __GNUC__.
 #elif defined(__clang__)
 #if __clang__>=5
 #undef POCKETFFT_NO_VECTORS
@@ -141,27 +138,19 @@ template<typename T> class arr
       }
     static void dealloc(T *ptr)
       { free(ptr); }
-#elif defined(_WIN32)
+#else // portable emulation
     static T *ralloc(size_t num)
       {
       if (num==0) return nullptr;
-      void *res = _aligned_malloc(num*sizeof(T), 64);
-      if (!res) throw bad_alloc();
-      return reinterpret_cast<T *>(res);
+      void *ptr = malloc(num*sizeof(T)+64);
+      if (!ptr) throw bad_alloc();
+      T *res = reinterpret_cast<T *>
+        ((reinterpret_cast<size_t>(ptr) & ~(size_t(63))) + 64);
+      (reinterpret_cast<void**>(res))[-1] = ptr;
+      return res;
       }
     static void dealloc(T *ptr)
-      { _aligned_free(ptr); }
-#else
-    static T *ralloc(size_t num)
-      {
-      if (num==0) return nullptr;
-      void *res(nullptr);
-      if (posix_memalign(&res, 64, num*sizeof(T))!=0)
-        throw bad_alloc();
-      return reinterpret_cast<T *>(res);
-      }
-    static void dealloc(T *ptr)
-      { free(ptr); }
+      { if (ptr) free((reinterpret_cast<void**>(ptr))[-1]); }
 #endif
 
   public:

stress.py

@@ -21,34 +21,33 @@ def test():
     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)
+    b=pypocketfft.ifftn(pypocketfft.fftn(a,axes=axes,nthreads=nthreads),axes=axes,inorm=2,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)
+    b=pypocketfft.irfftn(pypocketfft.rfftn(a.real,axes=axes,nthreads=nthreads),axes=axes,inorm=2,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)
+    b=pypocketfft.ifftn(pypocketfft.fftn(a.astype(np.complex64),axes=axes,nthreads=nthreads),axes=axes,inorm=2,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)
+    b=pypocketfft.irfftn(pypocketfft.rfftn(a.real.astype(np.float32),axes=axes,nthreads=nthreads),axes=axes,inorm=2,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)
+    b=pypocketfft.hartley(pypocketfft.hartley(a.real,axes=axes,nthreads=nthreads),axes=axes,inorm=2,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)
+    b=pypocketfft.hartley(pypocketfft.hartley(a.real.astype(np.float32),axes=axes,nthreads=nthreads),axes=axes,inorm=2,nthreads=nthreads)
     err = _l2error(a.real.astype(np.float32),b)
     if err > hmaxerrf:
         hmaxerrf = err

test.py

@@ -2,6 +2,7 @@ import pypocketfft
 import pyfftw
 import numpy as np
 import pytest
+from numpy.testing import assert_
 
 pmp = pytest.mark.parametrize
 
@@ -15,69 +16,70 @@ def _l2error(a,b):
     return np.sqrt(np.sum(np.abs(a-b)**2)/np.sum(np.abs(a)**2))
 
 @pmp("len", len1D)
-def test1D(len):
+@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, 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)
+    assert_(_l2error(a, pypocketfft.ifftn(pypocketfft.fftn(c,inorm=inorm), inorm=2-inorm))<1e-18)
+    assert_(_l2error(a, pypocketfft.ifftn(pypocketfft.fftn(a,inorm=inorm), inorm=2-inorm))<1.5e-15)
+    assert_(_l2error(a.real, pypocketfft.irfftn(pypocketfft.rfftn(a.real,inorm=inorm), inorm=2-inorm,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)
+    assert_ (pypocketfft.ifftn(pypocketfft.fftn(tmp, inplace=True, inorm=inorm), inplace=True, inorm=2-inorm) is tmp)
+    assert_(_l2error(tmp, a)<1.5e-15)
+    assert_(_l2error(b, pypocketfft.ifftn(pypocketfft.fftn(b, inorm=inorm), inorm=2-inorm))<6e-7)
+    assert_(_l2error(b.real, pypocketfft.irfftn(pypocketfft.rfftn(b.real, inorm=inorm), lastsize=len, inorm=2-inorm))<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)
+    assert_ (pypocketfft.ifftn(pypocketfft.fftn(tmp, inplace=True, inorm=inorm), inplace=True, inorm=2-inorm) is tmp)
+    assert_(_l2error(tmp, b)<6e-7)
 
 @pmp("shp", shapes)
 @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)
+    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)
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.fftn(a), pypocketfft.fftn(a, nthreads=nthreads))<5e-7)
 
 @pmp("shp", shapes2D)
 @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)
+    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)
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.fftn(a, axes=axes), pypocketfft.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)
+    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)
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.rfftn(a), pypocketfft.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)
+        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,inorm=2))<1e-15)
 
 @pmp("shp", shapes2D)
 @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)
+    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)
+    assert_(_l2error(pyfftw.interfaces.numpy_fft.rfftn(a, axes=axes), pypocketfft.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)
+    assert_(_l2error(pypocketfft.ifftn(pypocketfft.fftn(a),inorm=2), 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)
+    assert_ (pypocketfft.ifftn(pypocketfft.fftn(tmp, inplace=True), inorm=2, 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)
+    assert_(_l2error(pypocketfft.ifftn(pypocketfft.fftn(a),inorm=2), a)<6e-7)
 
 @pmp("shp", shapes)
 def test_identity_r(shp):
@@ -85,15 +87,14 @@ def test_identity_r(shp):
     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(pypocketfft.irfftn(pypocketfft.rfftn(a,(ax,)),(ax,),lastsize=n,inorm=2), a)<1e-15)
+        assert_(_l2error(pypocketfft.irfftn(pypocketfft.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)
+    assert_(_l2error(pypocketfft.rfftn(pypocketfft.irfftn(a),inorm=2), a)<1e-15)
 
 @pmp("shp", shapes2D+shapes3D)
 def test_hartley2(shp):
@@ -101,26 +102,25 @@ def test_hartley2(shp):
     v1 = pypocketfft.hartley2(a)
     v2 = pypocketfft.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)
+    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)
+    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.hartley2(pypocketfft.hartley2(v1, inplace=True), inorm=2, inplace=True) 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)
+    assert_(_l2error(pypocketfft.hartley2(pypocketfft.hartley2(a, axes=axes), axes=axes, inorm=2),a)<1e-15)