Starting modularization of the library.

.github/workflows/fpm-deployment.yml

@@ -56,6 +56,11 @@ jobs:
       - run: | # Use fpm gnu ci to check xdp and qp 
           python config/fypp_deployment.py --with_xdp --with_qp
           fpm test --profile release --flag '-DWITH_XDP -DWITH_QP -coverage'
+          fpm run --example example_bench01_zfft --profile release --flag '-DWITH_XDP -DWITH_QP -coverage'
+          fpm run --example example_bench02_zfft --profile release --flag '-DWITH_XDP -DWITH_QP -coverage'
+          fpm run --example example_bench03_dfft --profile release --flag '-DWITH_XDP -DWITH_QP -coverage'
+          fpm run --example example_real_transforms --profile release --flag '-DWITH_XDP -DWITH_QP -coverage'
+          fpm run --example example_complex_transforms --profile release --flag '-DWITH_XDP -DWITH_QP -coverage'
 
       - name: Create coverage report
         run: |

example/example_bench01_zfft.f90

@@ -1,43 +1,43 @@
 program bench1
-use fftpack, only: zffti, zfftf, zfftb
-use fftpack_kind, only: rk
-implicit none
-complex(rk), allocatable :: z(:)
-real(rk), allocatable :: w(:), x(:)
-real(rk) :: err, time_init, time_forward, time_backward, t1, t2
-integer :: N
+   use fftpack, only: zffti, zfftf, zfftb
+   use fftpack_kinds, only: dp
+   implicit none
+   complex(dp), allocatable :: z(:)
+   real(dp), allocatable :: w(:), x(:)
+   real(dp) :: err, time_init, time_forward, time_backward, t1, t2
+   integer :: N
 
-N = 1024*1014*16
+   N = 1024*1014*16
 
-allocate(x(N), z(N), w(4*N+15))
-call random_number(x)
-z = x
+   allocate (x(N), z(N), w(4*N + 15))
+   call random_number(x)
+   z = x
 
-print *, "01: Benchmarking zfft"
-print *, "Initializing"
-call cpu_time(t1)
-call zffti(N, w)
-call cpu_time(t2)
-time_init = t2-t1
+   print *, "01: Benchmarking zfft"
+   print *, "Initializing"
+   call cpu_time(t1)
+   call zffti(N, w)
+   call cpu_time(t2)
+   time_init = t2 - t1
 
-print *, "Forward"
-call cpu_time(t1)
-call zfftf(N, z, w)
-call cpu_time(t2)
-time_forward = t2-t1
+   print *, "Forward"
+   call cpu_time(t1)
+   call zfftf(N, z, w)
+   call cpu_time(t2)
+   time_forward = t2 - t1
 
-print *, "Backward"
-call cpu_time(t1)
-call zfftb(N, z, w)
-call cpu_time(t2)
-time_backward = t2-t1
-print *, "Done"
+   print *, "Backward"
+   call cpu_time(t1)
+   call zfftb(N, z, w)
+   call cpu_time(t2)
+   time_backward = t2 - t1
+   print *, "Done"
 
-err = maxval(abs(x-real(z/N,rk)))
-print *
-print *, "Error: ", err
-print *, "Init time: ", time_init
-print *, "Forward time: ", time_forward
-print *, "Backward time: ", time_backward
-print *, ""
+   err = maxval(abs(x - real(z/N, dp)))
+   print *
+   print *, "Error: ", err
+   print *, "Init time: ", time_init
+   print *, "Forward time: ", time_forward
+   print *, "Backward time: ", time_backward
+   print *, ""
 end program

example/example_bench02_zfft.f90

@@ -1,64 +1,64 @@
 program bench2
-use fftpack, only: zffti, zfftf, zfftb, fft, ifft
-use fftpack_kind, only: rk
+   use fftpack, only: zffti, zfftf, zfftb, fft, ifft
+   use fftpack_kinds, only: dp
 
-implicit none
-integer, parameter :: N = 1024*135*77  ! (2**10)*(3**3)*5*7*11
+   implicit none
+   integer, parameter :: N = 1024*135*77  ! (2**10)*(3**3)*5*7*11
 
-complex(rk), dimension(N) :: x, z
-real(rk), dimension(4*N+15) :: w
-real(rk) :: err, time_i, time_f, time_b, t1, t2
+   complex(dp), dimension(N) :: x, z
+   real(dp), dimension(4*N + 15) :: w
+   real(dp) :: err, time_i, time_f, time_b, t1, t2
 
-call random_number(x%re)
-z = x
+   call random_number(x%re)
+   z = x
 
-print *, "02: Benchmarking zfft & fft"
+   print *, "02: Benchmarking zfft & fft"
 
-call cpu_time(t1)
-call zffti(N, w)
-call cpu_time(t2)
-time_i = t2-t1
-print *, "Initializing: done"
+   call cpu_time(t1)
+   call zffti(N, w)
+   call cpu_time(t2)
+   time_i = t2 - t1
+   print *, "Initializing: done"
 
-call cpu_time(t1)
-call zfftf(N, z, w)
-call cpu_time(t2)
-time_f = t2-t1
-print *, "Forward: done"
+   call cpu_time(t1)
+   call zfftf(N, z, w)
+   call cpu_time(t2)
+   time_f = t2 - t1
+   print *, "Forward: done"
 
-call cpu_time(t1)
-call zfftb(N, z, w)
-call cpu_time(t2)
-time_b = t2-t1
-print *, "Backward: done"
-print *, ""
+   call cpu_time(t1)
+   call zfftb(N, z, w)
+   call cpu_time(t2)
+   time_b = t2 - t1
+   print *, "Backward: done"
+   print *, ""
 
-err = maxval(abs(x-real(z/N,rk)))
-print *, "--zfft"
-print *, "Error: ", err
-print *, "Init. time: ", time_i
-print *, "Forward time: ", time_f
-print *, "Backward time: ", time_b
-print *, ""
+   err = maxval(abs(x - real(z/N, dp)))
+   print *, "--zfft"
+   print *, "Error: ", err
+   print *, "Init. time: ", time_i
+   print *, "Forward time: ", time_f
+   print *, "Backward time: ", time_b
+   print *, ""
 
-print *, "Comparing to calls through fft"
-call cpu_time(t1)
-z = fft(x)
-call cpu_time(t2)
-time_f = t2-t1
-print *, "Init. & forward: done"
+   print *, "Comparing to calls through fft"
+   call cpu_time(t1)
+   z = fft(x)
+   call cpu_time(t2)
+   time_f = t2 - t1
+   print *, "Init. & forward: done"
 
-call cpu_time(t1)
-z = ifft(z)
-call cpu_time(t2)
-time_b = t2-t1
-print *, "Backward: done"
-print *, ""
+   call cpu_time(t1)
+   z = ifft(z)
+   call cpu_time(t2)
+   time_b = t2 - t1
+   print *, "Backward: done"
+   print *, ""
 
-err = maxval(abs(x-real(z/N,rk)))
-print *, "--fft"
-print *, "Error: ", err
-print *, "Init. & forward time: ", time_f
-print *, "Backward time: ", time_b
-print *, ""
+   err = maxval(abs(x - real(z/N, dp)))
+   print *, "--fft"
+   print *, "Error: ", err
+   print *, "Init. & forward time: ", time_f
+   print *, "Backward time: ", time_b
+   print *, ""
 end program

example/example_bench03_dfft.f90

@@ -1,64 +1,64 @@
 program bench3
-use fftpack, only: dffti, dfftf, dfftb, rfft, irfft
-use fftpack_kind, only: rk
+   use fftpack, only: dffti, dfftf, dfftb, rfft, irfft
+   use fftpack_kinds, only: dp
 
-implicit none
-integer, parameter :: N = 1024*135*77  ! (2**10)*(3**3)*5*7*11
+   implicit none
+   integer, parameter :: N = 1024*135*77  ! (2**10)*(3**3)*5*7*11
 
-real(rk), dimension(N) :: x, y
-real(rk), dimension(2*N+15) :: w
-real(rk) :: err, time_i, time_f, time_b, t1, t2
+   real(dp), dimension(N) :: x, y
+   real(dp), dimension(2*N + 15) :: w
+   real(dp) :: err, time_i, time_f, time_b, t1, t2
 
-call random_number(x)
-y = x
+   call random_number(x)
+   y = x
 
-print *, "03: Benchmarking dfft & rfft"
+   print *, "03: Benchmarking dfft & rfft"
 
-call cpu_time(t1)
-call dffti(N, w)
-call cpu_time(t2)
-time_i = t2-t1
-print *, "Initializing: done"
+   call cpu_time(t1)
+   call dffti(N, w)
+   call cpu_time(t2)
+   time_i = t2 - t1
+   print *, "Initializing: done"
 
-call cpu_time(t1)
-call dfftf(N, y, w)
-call cpu_time(t2)
-time_f = t2-t1
-print *, "Forward: done"
+   call cpu_time(t1)
+   call dfftf(N, y, w)
+   call cpu_time(t2)
+   time_f = t2 - t1
+   print *, "Forward: done"
 
-call cpu_time(t1)
-call dfftb(N, y, w)
-call cpu_time(t2)
-time_b = t2-t1
-print *, "Backward: done"
-print *, ""
+   call cpu_time(t1)
+   call dfftb(N, y, w)
+   call cpu_time(t2)
+   time_b = t2 - t1
+   print *, "Backward: done"
+   print *, ""
 
-err = maxval(abs(x-y/N))
-print *, "--dfft"
-print *, "Error: ", err
-print *, "Init. time: ", time_i
-print *, "Forward time: ", time_f
-print *, "Backward time: ", time_b
-print *, ""
+   err = maxval(abs(x - y/N))
+   print *, "--dfft"
+   print *, "Error: ", err
+   print *, "Init. time: ", time_i
+   print *, "Forward time: ", time_f
+   print *, "Backward time: ", time_b
+   print *, ""
 
-print *, "Comparing to calls through rfft"
-call cpu_time(t1)
-y = rfft(x)
-call cpu_time(t2)
-time_f = t2-t1
-print *, "Init. & forward: done"
+   print *, "Comparing to calls through rfft"
+   call cpu_time(t1)
+   y = rfft(x)
+   call cpu_time(t2)
+   time_f = t2 - t1
+   print *, "Init. & forward: done"
 
-call cpu_time(t1)
-y = irfft(y)
-call cpu_time(t2)
-time_b = t2-t1
-print *, "Backward: done"
-print *, ""
+   call cpu_time(t1)
+   y = irfft(y)
+   call cpu_time(t2)
+   time_b = t2 - t1
+   print *, "Backward: done"
+   print *, ""
 
-err = maxval(abs(x-y/N))
-print *, "--rfft"
-print *, "Error: ", err
-print *, "Init. & forward time: ", time_f
-print *, "Backward time: ", time_b
-print *, ""
+   err = maxval(abs(x - y/N))
+   print *, "--rfft"
+   print *, "Error: ", err
+   print *, "Init. & forward time: ", time_f
+   print *, "Backward time: ", time_b
+   print *, ""
 end program