[pyfftw] 01/11: Imported Upstream version 0.10.3+dfsg1
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Tue Jun 7 05:13:02 UTC 2016
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch master
in repository pyfftw.
commit d0ae80c4e0f9598c6bde1a996df8e223bca1e339
Author: Ghislain Antony Vaillant <ghisvail at gmail.com>
Date: Sun Jun 5 22:25:20 2016 +0100
Imported Upstream version 0.10.3+dfsg1
---
CHANGELOG.md | 257 ++-
LICENSE.txt | 1 -
MANIFEST.in | 9 +-
PKG-INFO | 10 +-
README.rst | 57 +-
conf.py | 230 ++
include/cpu.h | 12 +-
include/msvc_2008/stdint.h | 18 +-
include/msvc_2010/stdint.h | 18 +-
include/pyfftw_complex.h | 2 +-
include/win/fftw3.h | 8 +-
index.rst | 56 +
pyFFTW.egg-info/PKG-INFO | 10 +-
pyFFTW.egg-info/SOURCES.txt | 12 +
pyfftw/__init__.py | 2 +-
pyfftw/builders/_utils.py | 48 +-
pyfftw/builders/_utils.rst | 10 +
pyfftw/builders/builders.py | 161 +-
pyfftw/builders/builders.rst | 9 +
pyfftw/cpu.pxd | 2 +-
pyfftw/interfaces/__init__.py | 33 +-
pyfftw/interfaces/_utils.py | 79 +-
pyfftw/interfaces/cache.py | 35 +-
pyfftw/interfaces/interfaces.rst | 16 +
pyfftw/interfaces/numpy_fft.py | 190 +-
pyfftw/interfaces/numpy_fft.rst | 5 +
pyfftw/interfaces/scipy_fftpack.py | 87 +-
pyfftw/interfaces/scipy_fftpack.rst | 5 +
pyfftw/pyfftw.c | 3266 ++++++++++++++-------------
pyfftw/pyfftw.pxd | 42 +-
pyfftw/pyfftw.pyx | 364 +--
pyfftw/pyfftw.rst | 94 +
pyfftw/utils.pxi | 8 +-
pyfftw/version.py | 10 +-
requirements.txt | 1 +
setup.py | 111 +-
sphinx/api.rst | 9 +
sphinx/tutorial.rst | 474 ++++
test/_cook_nd_args.py | 60 +
pyfftw/cpu.pxd => test/_get_default_args.py | 31 +-
test/test_pyfftw_base.py | 26 +-
test/test_pyfftw_builders.py | 102 +-
test/test_pyfftw_call.py | 108 +-
test/test_pyfftw_class_misc.py | 18 +-
test/test_pyfftw_complex.py | 193 +-
test/test_pyfftw_interfaces_cache.py | 43 +-
test/test_pyfftw_multithreaded.py | 20 +-
test/test_pyfftw_numpy_interface.py | 192 +-
test/test_pyfftw_real_backward.py | 64 +-
test/test_pyfftw_real_forward.py | 28 +-
test/test_pyfftw_scipy_interface.py | 58 +-
test/test_pyfftw_utils.py | 11 +-
test/test_pyfftw_wisdom.py | 9 +-
53 files changed, 4101 insertions(+), 2623 deletions(-)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5cebc79..8bc8c17 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,146 +1,203 @@
# Change Log
-## [v0.10.1](https://github.com/hgomersall/pyFFTW/tree/v0.10.1) (2016-01-29)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.10.0...v0.10.1)
+## [v0.10.3](https://github.com/pyFFTW/pyFFTW/tree/v0.10.3) (2016-06-05)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v10.2...v0.10.3)
-## [v0.10.0](https://github.com/hgomersall/pyFFTW/tree/v0.10.0) (2016-01-29)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.9.2...v0.10.0)
+**Merged pull requests:**
+
+- Another attempt to set the PyPI password with travis. [\#121](https://github.com/pyFFTW/pyFFTW/pull/121) ([hgomersall](https://github.com/hgomersall))
+- Fix to allow TRAVIS\_TAG be empty. [\#120](https://github.com/pyFFTW/pyFFTW/pull/120) ([hgomersall](https://github.com/hgomersall))
+- Allow travis to automatically handle releases and push to PyPI [\#119](https://github.com/pyFFTW/pyFFTW/pull/119) ([hgomersall](https://github.com/hgomersall))
+
+## [v10.2](https://github.com/pyFFTW/pyFFTW/tree/v10.2) (2016-06-04)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.10.1_docs...v10.2)
+
+**Fixed bugs:**
+
+- Numpy interface can fail with non-writeable arrays. [\#92](https://github.com/pyFFTW/pyFFTW/issues/92)
+- undefined symbol: simd\_alignment with gcc 5.3.0 [\#89](https://github.com/pyFFTW/pyFFTW/issues/89)
+- FTBFS: TypeError: can't pickle Cython.Compiler.FlowControl.NameAssignment objects [\#82](https://github.com/pyFFTW/pyFFTW/issues/82)
+
+**Closed issues:**
+
+- pyfftw fails with ImportError/undefined symbol fftwl\_plan\_with\_nthreads [\#112](https://github.com/pyFFTW/pyFFTW/issues/112)
+- pyfftw does not appear to be using available wisdom files [\#110](https://github.com/pyFFTW/pyFFTW/issues/110)
+- Accuracy of non-power 2 data [\#105](https://github.com/pyFFTW/pyFFTW/issues/105)
+- Cannot find fftw3l when installing from pip [\#100](https://github.com/pyFFTW/pyFFTW/issues/100)
+- Incorrect links to docs [\#96](https://github.com/pyFFTW/pyFFTW/issues/96)
+- PyFFTW returning all zero array after transform... [\#94](https://github.com/pyFFTW/pyFFTW/issues/94)
+- Move to separate pyFFTW project page [\#83](https://github.com/pyFFTW/pyFFTW/issues/83)
+- Release GIL during planning? [\#75](https://github.com/pyFFTW/pyFFTW/issues/75)
+- Merging/sharing wisdom [\#72](https://github.com/pyFFTW/pyFFTW/issues/72)
+- scipy interface patching. [\#68](https://github.com/pyFFTW/pyFFTW/issues/68)
+- very slow test suite [\#47](https://github.com/pyFFTW/pyFFTW/issues/47)
+- setup: some targets should not require numpy to be installed [\#46](https://github.com/pyFFTW/pyFFTW/issues/46)
+- 2x margin on the planning timelimit test is inadequate in windows on Complex64 [\#24](https://github.com/pyFFTW/pyFFTW/issues/24)
+
+**Merged pull requests:**
+
+- 10.2 Release [\#117](https://github.com/pyFFTW/pyFFTW/pull/117) ([hgomersall](https://github.com/hgomersall))
+- BLD: use optional STATIC\_FFTW\_DIR environment variable to link static… [\#116](https://github.com/pyFFTW/pyFFTW/pull/116) ([grlee77](https://github.com/grlee77))
+- Fix for missing test files in MANIFEST.in [\#115](https://github.com/pyFFTW/pyFFTW/pull/115) ([hgomersall](https://github.com/hgomersall))
+- Updated the bintray upload from appveyor to use the new abi naming scheme. [\#113](https://github.com/pyFFTW/pyFFTW/pull/113) ([hgomersall](https://github.com/hgomersall))
+- fix two minor test bugs [\#109](https://github.com/pyFFTW/pyFFTW/pull/109) ([grlee77](https://github.com/grlee77))
+- add option to select orthonormal \(unitary\) DFT scaling [\#108](https://github.com/pyFFTW/pyFFTW/pull/108) ([grlee77](https://github.com/grlee77))
+- Fix LDFLAGS in OS X install instructions [\#104](https://github.com/pyFFTW/pyFFTW/pull/104) ([stephentu](https://github.com/stephentu))
+- DOC: use sub-sub-section headings [\#102](https://github.com/pyFFTW/pyFFTW/pull/102) ([endolith](https://github.com/endolith))
+- Doc fixes to address scipy changes \(\#68\) [\#101](https://github.com/pyFFTW/pyFFTW/pull/101) ([hgomersall](https://github.com/hgomersall))
+- Get rid of trailing whitespace. [\#98](https://github.com/pyFFTW/pyFFTW/pull/98) ([drwells](https://github.com/drwells))
+- Updating README to reflect github moving the pages server. [\#97](https://github.com/pyFFTW/pyFFTW/pull/97) ([hgomersall](https://github.com/hgomersall))
+- Resolves issue \#92. [\#93](https://github.com/pyFFTW/pyFFTW/pull/93) ([mforbes](https://github.com/mforbes))
+- Fix to tests to handle the new style of importing fftpack inside scipy [\#91](https://github.com/pyFFTW/pyFFTW/pull/91) ([hgomersall](https://github.com/hgomersall))
+- Fix for \#89, getting simd\_alignment exposed properly. [\#90](https://github.com/pyFFTW/pyFFTW/pull/90) ([hgomersall](https://github.com/hgomersall))
+- Fixes to aid downstream building. [\#88](https://github.com/pyFFTW/pyFFTW/pull/88) ([hgomersall](https://github.com/hgomersall))
+- Updated the readme to reflect the movement to a new project page. [\#85](https://github.com/pyFFTW/pyFFTW/pull/85) ([hgomersall](https://github.com/hgomersall))
+- Added a travis.yml to gh-pages that excludes that gh-pages branch. [\#84](https://github.com/pyFFTW/pyFFTW/pull/84) ([hgomersall](https://github.com/hgomersall))
+
+## [v0.10.1_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.10.1_docs) (2016-01-29)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.10.1...v0.10.1_docs)
+
+## [v0.10.1](https://github.com/pyFFTW/pyFFTW/tree/v0.10.1) (2016-01-29)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.10.0...v0.10.1)
+
+## [v0.10.0](https://github.com/pyFFTW/pyFFTW/tree/v0.10.0) (2016-01-29)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.9.2...v0.10.0)
**Closed issues:**
-- Conda downloads are failing [\#76](https://github.com/hgomersall/pyFFTW/issues/76)
-- Python 3.4 and WinPython [\#74](https://github.com/hgomersall/pyFFTW/issues/74)
-- Installing pyfftw on Anaconda3 on Windows 7 [\#73](https://github.com/hgomersall/pyFFTW/issues/73)
-- is python 3.5 supported? [\#71](https://github.com/hgomersall/pyFFTW/issues/71)
-- deadlock of cache handler at interpreter shutdown [\#69](https://github.com/hgomersall/pyFFTW/issues/69)
-- pyFFTW breaks when forked [\#65](https://github.com/hgomersall/pyFFTW/issues/65)
-- build with mingw [\#62](https://github.com/hgomersall/pyFFTW/issues/62)
-- Striding in n\_byte\_align not on a uniform standard [\#61](https://github.com/hgomersall/pyFFTW/issues/61)
-- No exception on wrong arguments of function call of pyfftw.FFTW\(...\) [\#60](https://github.com/hgomersall/pyFFTW/issues/60)
-- pyfftw vs numpy.fft: faster and slower [\#58](https://github.com/hgomersall/pyFFTW/issues/58)
-- simple transposes? [\#57](https://github.com/hgomersall/pyFFTW/issues/57)
-- `Datatype not supported` with scipy [\#56](https://github.com/hgomersall/pyFFTW/issues/56)
-- Update tutorial with new byte align functions [\#53](https://github.com/hgomersall/pyFFTW/issues/53)
-- OS X Installation errors: [\#52](https://github.com/hgomersall/pyFFTW/issues/52)
-- Wrong results for pyfftw's ifft? [\#51](https://github.com/hgomersall/pyFFTW/issues/51)
-- Installing on OS X Mavericks [\#49](https://github.com/hgomersall/pyFFTW/issues/49)
-- Install error. Ld cannot find -lfftw3f [\#48](https://github.com/hgomersall/pyFFTW/issues/48)
-- new source release with updated licensing [\#43](https://github.com/hgomersall/pyFFTW/issues/43)
-- Crash during initialization of FFTW plan for r2c and c2r with Intel compiler [\#37](https://github.com/hgomersall/pyFFTW/issues/37)
-- Move FFTW class definition to pyfftw.pxd [\#36](https://github.com/hgomersall/pyFFTW/issues/36)
-- Provide transform metadata such as axes and direction [\#34](https://github.com/hgomersall/pyFFTW/issues/34)
-- Provide shape and dtype properties [\#33](https://github.com/hgomersall/pyFFTW/issues/33)
-- problem with very large arrays: OverflowError: value too large to convert to int [\#30](https://github.com/hgomersall/pyFFTW/issues/30)
-- add support for in-place multidimensional r2c transform [\#29](https://github.com/hgomersall/pyFFTW/issues/29)
-- Add numpy interface for hfft [\#28](https://github.com/hgomersall/pyFFTW/issues/28)
-- add cython as a build dependency [\#25](https://github.com/hgomersall/pyFFTW/issues/25)
-- Potential memory leak in caching [\#22](https://github.com/hgomersall/pyFFTW/issues/22)
-- Allow GIL to be released with threads=1 [\#13](https://github.com/hgomersall/pyFFTW/issues/13)
-- Building for 64bit windows [\#12](https://github.com/hgomersall/pyFFTW/issues/12)
-- Test failure using numpy 1.6.2 [\#9](https://github.com/hgomersall/pyFFTW/issues/9)
-- Remove the requirement for users to specify alignment [\#8](https://github.com/hgomersall/pyFFTW/issues/8)
-- pyfftw.interfaces can only handle numpy arrays [\#7](https://github.com/hgomersall/pyFFTW/issues/7)
+- Conda downloads are failing [\#76](https://github.com/pyFFTW/pyFFTW/issues/76)
+- Python 3.4 and WinPython [\#74](https://github.com/pyFFTW/pyFFTW/issues/74)
+- Installing pyfftw on Anaconda3 on Windows 7 [\#73](https://github.com/pyFFTW/pyFFTW/issues/73)
+- is python 3.5 supported? [\#71](https://github.com/pyFFTW/pyFFTW/issues/71)
+- deadlock of cache handler at interpreter shutdown [\#69](https://github.com/pyFFTW/pyFFTW/issues/69)
+- pyFFTW breaks when forked [\#65](https://github.com/pyFFTW/pyFFTW/issues/65)
+- build with mingw [\#62](https://github.com/pyFFTW/pyFFTW/issues/62)
+- Striding in n\_byte\_align not on a uniform standard [\#61](https://github.com/pyFFTW/pyFFTW/issues/61)
+- No exception on wrong arguments of function call of pyfftw.FFTW\(...\) [\#60](https://github.com/pyFFTW/pyFFTW/issues/60)
+- pyfftw vs numpy.fft: faster and slower [\#58](https://github.com/pyFFTW/pyFFTW/issues/58)
+- simple transposes? [\#57](https://github.com/pyFFTW/pyFFTW/issues/57)
+- `Datatype not supported` with scipy [\#56](https://github.com/pyFFTW/pyFFTW/issues/56)
+- Update tutorial with new byte align functions [\#53](https://github.com/pyFFTW/pyFFTW/issues/53)
+- OS X Installation errors: [\#52](https://github.com/pyFFTW/pyFFTW/issues/52)
+- Wrong results for pyfftw's ifft? [\#51](https://github.com/pyFFTW/pyFFTW/issues/51)
+- Installing on OS X Mavericks [\#49](https://github.com/pyFFTW/pyFFTW/issues/49)
+- Install error. Ld cannot find -lfftw3f [\#48](https://github.com/pyFFTW/pyFFTW/issues/48)
+- new source release with updated licensing [\#43](https://github.com/pyFFTW/pyFFTW/issues/43)
+- Crash during initialization of FFTW plan for r2c and c2r with Intel compiler [\#37](https://github.com/pyFFTW/pyFFTW/issues/37)
+- Move FFTW class definition to pyfftw.pxd [\#36](https://github.com/pyFFTW/pyFFTW/issues/36)
+- Provide transform metadata such as axes and direction [\#34](https://github.com/pyFFTW/pyFFTW/issues/34)
+- Provide shape and dtype properties [\#33](https://github.com/pyFFTW/pyFFTW/issues/33)
+- problem with very large arrays: OverflowError: value too large to convert to int [\#30](https://github.com/pyFFTW/pyFFTW/issues/30)
+- add support for in-place multidimensional r2c transform [\#29](https://github.com/pyFFTW/pyFFTW/issues/29)
+- Add numpy interface for hfft [\#28](https://github.com/pyFFTW/pyFFTW/issues/28)
+- add cython as a build dependency [\#25](https://github.com/pyFFTW/pyFFTW/issues/25)
+- Potential memory leak in caching [\#22](https://github.com/pyFFTW/pyFFTW/issues/22)
+- Allow GIL to be released with threads=1 [\#13](https://github.com/pyFFTW/pyFFTW/issues/13)
+- Building for 64bit windows [\#12](https://github.com/pyFFTW/pyFFTW/issues/12)
+- Test failure using numpy 1.6.2 [\#9](https://github.com/pyFFTW/pyFFTW/issues/9)
+- Remove the requirement for users to specify alignment [\#8](https://github.com/pyFFTW/pyFFTW/issues/8)
+- pyfftw.interfaces can only handle numpy arrays [\#7](https://github.com/pyFFTW/pyFFTW/issues/7)
**Merged pull requests:**
-- Release GIL during both single- and multi-thread execution \(cleaned up patch\) [\#81](https://github.com/hgomersall/pyFFTW/pull/81) ([zpincus](https://github.com/zpincus))
-- Support FFTW\_WISDOM\_ONLY \(cleaned up patch\) [\#80](https://github.com/hgomersall/pyFFTW/pull/80) ([zpincus](https://github.com/zpincus))
-- Release GIL around FFTW planning [\#78](https://github.com/hgomersall/pyFFTW/pull/78) ([zpincus](https://github.com/zpincus))
-- Updated the tutorial to reflect changes with new aligned array creation functions. [\#54](https://github.com/hgomersall/pyFFTW/pull/54) ([drwells](https://github.com/drwells))
-- Add description for installing on OS X [\#50](https://github.com/hgomersall/pyFFTW/pull/50) ([arve0](https://github.com/arve0))
-- close issue \#8 \(More numpy like aligned array creation functions\) [\#44](https://github.com/hgomersall/pyFFTW/pull/44) ([drwells](https://github.com/drwells))
-- Discrete sine transform imports [\#42](https://github.com/hgomersall/pyFFTW/pull/42) ([insertinterestingnamehere](https://github.com/insertinterestingnamehere))
+- Release GIL during both single- and multi-thread execution \(cleaned up patch\) [\#81](https://github.com/pyFFTW/pyFFTW/pull/81) ([zpincus](https://github.com/zpincus))
+- Support FFTW\_WISDOM\_ONLY \(cleaned up patch\) [\#80](https://github.com/pyFFTW/pyFFTW/pull/80) ([zpincus](https://github.com/zpincus))
+- Release GIL around FFTW planning [\#78](https://github.com/pyFFTW/pyFFTW/pull/78) ([zpincus](https://github.com/zpincus))
+- Updated the tutorial to reflect changes with new aligned array creation functions. [\#54](https://github.com/pyFFTW/pyFFTW/pull/54) ([drwells](https://github.com/drwells))
+- Add description for installing on OS X [\#50](https://github.com/pyFFTW/pyFFTW/pull/50) ([arve0](https://github.com/arve0))
+- close issue \#8 \(More numpy like aligned array creation functions\) [\#44](https://github.com/pyFFTW/pyFFTW/pull/44) ([drwells](https://github.com/drwells))
+- Discrete sine transform imports [\#42](https://github.com/pyFFTW/pyFFTW/pull/42) ([insertinterestingnamehere](https://github.com/insertinterestingnamehere))
-## [v0.9.2](https://github.com/hgomersall/pyFFTW/tree/v0.9.2) (2013-09-20)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.9.2_docs...v0.9.2)
+## [v0.9.2](https://github.com/pyFFTW/pyFFTW/tree/v0.9.2) (2013-09-20)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.9.2_docs...v0.9.2)
-## [v0.9.2_docs](https://github.com/hgomersall/pyFFTW/tree/v0.9.2_docs) (2013-09-11)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.9.1_docs...v0.9.2_docs)
+## [v0.9.2_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.9.2_docs) (2013-09-11)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.9.1_docs...v0.9.2_docs)
-## [v0.9.1_docs](https://github.com/hgomersall/pyFFTW/tree/v0.9.1_docs) (2013-09-11)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.9.1...v0.9.1_docs)
+## [v0.9.1_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.9.1_docs) (2013-09-11)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.9.1...v0.9.1_docs)
-## [v0.9.1](https://github.com/hgomersall/pyFFTW/tree/v0.9.1) (2013-09-11)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.9_docs...v0.9.1)
+## [v0.9.1](https://github.com/pyFFTW/pyFFTW/tree/v0.9.1) (2013-09-11)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.9_docs...v0.9.1)
**Closed issues:**
-- Overwriting previous input when cache is enabled. [\#23](https://github.com/hgomersall/pyFFTW/issues/23)
-- Race condition in cache culling [\#21](https://github.com/hgomersall/pyFFTW/issues/21)
-- Memory corruption at exit [\#19](https://github.com/hgomersall/pyFFTW/issues/19)
-- In-place transform? [\#18](https://github.com/hgomersall/pyFFTW/issues/18)
-- Support for 2.6? [\#17](https://github.com/hgomersall/pyFFTW/issues/17)
-- Install fails; can't find library? [\#16](https://github.com/hgomersall/pyFFTW/issues/16)
-- Please include cython source code [\#11](https://github.com/hgomersall/pyFFTW/issues/11)
-- Make repeated axes act like numpy.fft's repeated axes [\#2](https://github.com/hgomersall/pyFFTW/issues/2)
-- Implement numpy.fft API to pyfftw [\#1](https://github.com/hgomersall/pyFFTW/issues/1)
+- Overwriting previous input when cache is enabled. [\#23](https://github.com/pyFFTW/pyFFTW/issues/23)
+- Race condition in cache culling [\#21](https://github.com/pyFFTW/pyFFTW/issues/21)
+- Memory corruption at exit [\#19](https://github.com/pyFFTW/pyFFTW/issues/19)
+- In-place transform? [\#18](https://github.com/pyFFTW/pyFFTW/issues/18)
+- Support for 2.6? [\#17](https://github.com/pyFFTW/pyFFTW/issues/17)
+- Install fails; can't find library? [\#16](https://github.com/pyFFTW/pyFFTW/issues/16)
+- Please include cython source code [\#11](https://github.com/pyFFTW/pyFFTW/issues/11)
+- Make repeated axes act like numpy.fft's repeated axes [\#2](https://github.com/pyFFTW/pyFFTW/issues/2)
+- Implement numpy.fft API to pyfftw [\#1](https://github.com/pyFFTW/pyFFTW/issues/1)
**Merged pull requests:**
-- register fftw cleanup with Py\_AtExit [\#20](https://github.com/hgomersall/pyFFTW/pull/20) ([rainwoodman](https://github.com/rainwoodman))
+- register fftw cleanup with Py\_AtExit [\#20](https://github.com/pyFFTW/pyFFTW/pull/20) ([rainwoodman](https://github.com/rainwoodman))
-## [v0.9_docs](https://github.com/hgomersall/pyFFTW/tree/v0.9_docs) (2013-02-15)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.9...v0.9_docs)
+## [v0.9_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.9_docs) (2013-02-15)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.9...v0.9_docs)
-## [v0.9](https://github.com/hgomersall/pyFFTW/tree/v0.9) (2013-02-15)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.8.2_docs...v0.9)
+## [v0.9](https://github.com/pyFFTW/pyFFTW/tree/v0.9) (2013-02-15)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.8.2_docs...v0.9)
**Closed issues:**
-- Issue getting PyFFTW to import in Python 3 [\#6](https://github.com/hgomersall/pyFFTW/issues/6)
-- Some tests fail [\#5](https://github.com/hgomersall/pyFFTW/issues/5)
-- n\_byte\_array\(\) and n\_byte\_align\_empty\(\) break for large arrays [\#4](https://github.com/hgomersall/pyFFTW/issues/4)
+- Issue getting PyFFTW to import in Python 3 [\#6](https://github.com/pyFFTW/pyFFTW/issues/6)
+- Some tests fail [\#5](https://github.com/pyFFTW/pyFFTW/issues/5)
+- n\_byte\_array\(\) and n\_byte\_align\_empty\(\) break for large arrays [\#4](https://github.com/pyFFTW/pyFFTW/issues/4)
-## [v0.8.2_docs](https://github.com/hgomersall/pyFFTW/tree/v0.8.2_docs) (2012-05-29)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.8.2...v0.8.2_docs)
+## [v0.8.2_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.8.2_docs) (2012-05-29)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.8.2...v0.8.2_docs)
-## [v0.8.2](https://github.com/hgomersall/pyFFTW/tree/v0.8.2) (2012-05-29)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.8.1_docs...v0.8.2)
+## [v0.8.2](https://github.com/pyFFTW/pyFFTW/tree/v0.8.2) (2012-05-29)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.8.1_docs...v0.8.2)
**Closed issues:**
-- export\_wisdom\(\) fails on windows 7 and vista [\#3](https://github.com/hgomersall/pyFFTW/issues/3)
+- export\_wisdom\(\) fails on windows 7 and vista [\#3](https://github.com/pyFFTW/pyFFTW/issues/3)
-## [v0.8.1_docs](https://github.com/hgomersall/pyFFTW/tree/v0.8.1_docs) (2012-05-20)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.8.1...v0.8.1_docs)
+## [v0.8.1_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.8.1_docs) (2012-05-20)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.8.1...v0.8.1_docs)
-## [v0.8.1](https://github.com/hgomersall/pyFFTW/tree/v0.8.1) (2012-05-20)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.8.0_docs...v0.8.1)
+## [v0.8.1](https://github.com/pyFFTW/pyFFTW/tree/v0.8.1) (2012-05-20)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.8.0_docs...v0.8.1)
-## [v0.8.0_docs](https://github.com/hgomersall/pyFFTW/tree/v0.8.0_docs) (2012-04-08)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.8.0...v0.8.0_docs)
+## [v0.8.0_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.8.0_docs) (2012-04-08)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.8.0...v0.8.0_docs)
-## [v0.8.0](https://github.com/hgomersall/pyFFTW/tree/v0.8.0) (2012-04-08)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.7.0_docs...v0.8.0)
+## [v0.8.0](https://github.com/pyFFTW/pyFFTW/tree/v0.8.0) (2012-04-08)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.7.0_docs...v0.8.0)
-## [v0.7.0_docs](https://github.com/hgomersall/pyFFTW/tree/v0.7.0_docs) (2012-03-04)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.7.0...v0.7.0_docs)
+## [v0.7.0_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.7.0_docs) (2012-03-04)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.7.0...v0.7.0_docs)
-## [v0.7.0](https://github.com/hgomersall/pyFFTW/tree/v0.7.0) (2012-02-29)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.6.1_docs...v0.7.0)
+## [v0.7.0](https://github.com/pyFFTW/pyFFTW/tree/v0.7.0) (2012-02-29)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.6.1_docs...v0.7.0)
-## [v0.6.1_docs](https://github.com/hgomersall/pyFFTW/tree/v0.6.1_docs) (2012-02-26)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.6.1...v0.6.1_docs)
+## [v0.6.1_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.6.1_docs) (2012-02-26)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.6.1...v0.6.1_docs)
-## [v0.6.1](https://github.com/hgomersall/pyFFTW/tree/v0.6.1) (2012-02-26)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.6.0_docs...v0.6.1)
+## [v0.6.1](https://github.com/pyFFTW/pyFFTW/tree/v0.6.1) (2012-02-26)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.6.0_docs...v0.6.1)
-## [v0.6.0_docs](https://github.com/hgomersall/pyFFTW/tree/v0.6.0_docs) (2012-02-06)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.6.0...v0.6.0_docs)
+## [v0.6.0_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.6.0_docs) (2012-02-06)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.6.0...v0.6.0_docs)
-## [v0.6.0](https://github.com/hgomersall/pyFFTW/tree/v0.6.0) (2012-02-06)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.5.1_docs...v0.6.0)
+## [v0.6.0](https://github.com/pyFFTW/pyFFTW/tree/v0.6.0) (2012-02-06)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.5.1_docs...v0.6.0)
-## [v0.5.1_docs](https://github.com/hgomersall/pyFFTW/tree/v0.5.1_docs) (2012-02-05)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.5.1...v0.5.1_docs)
+## [v0.5.1_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.5.1_docs) (2012-02-05)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.5.1...v0.5.1_docs)
-## [v0.5.1](https://github.com/hgomersall/pyFFTW/tree/v0.5.1) (2012-02-04)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.5.0...v0.5.1)
+## [v0.5.1](https://github.com/pyFFTW/pyFFTW/tree/v0.5.1) (2012-02-04)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.5.0...v0.5.1)
-## [v0.5.0](https://github.com/hgomersall/pyFFTW/tree/v0.5.0) (2012-02-01)
-[Full Changelog](https://github.com/hgomersall/pyFFTW/compare/v0.5.0_docs...v0.5.0)
+## [v0.5.0](https://github.com/pyFFTW/pyFFTW/tree/v0.5.0) (2012-02-01)
+[Full Changelog](https://github.com/pyFFTW/pyFFTW/compare/v0.5.0_docs...v0.5.0)
-## [v0.5.0_docs](https://github.com/hgomersall/pyFFTW/tree/v0.5.0_docs) (2012-02-01)
+## [v0.5.0_docs](https://github.com/pyFFTW/pyFFTW/tree/v0.5.0_docs) (2012-02-01)
\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*
\ No newline at end of file
diff --git a/LICENSE.txt b/LICENSE.txt
index 0bf19ab..b9b9526 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -31,4 +31,3 @@ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-
diff --git a/MANIFEST.in b/MANIFEST.in
index b2c2cba..f1b38cd 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -2,12 +2,13 @@ include CHANGELOG.md
include LICENSE.txt
include requirements.txt
include README.rst
-include pyfftw/pyfftw.c
include pyfftw/pyfftw.pyx
include pyfftw/pyfftw.pxd
include pyfftw/cpu.pxd
include pyfftw/utils.pxi
-include test/test_*.py
-include test/__init__.py
+include test/*.py
+include conf.py
+include index.rst
+recursive-include pyfftw *.rst
+recursive-include sphinx *.rst
recursive-include include *.h
-recursive-include docs *.html *.css *.png *.js *.rst
diff --git a/PKG-INFO b/PKG-INFO
index 8913dcb..1ebfec0 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,6 +1,6 @@
Metadata-Version: 1.1
Name: pyFFTW
-Version: 0.10.1
+Version: 0.10.3
Summary: A pythonic wrapper around FFTW, the FFT library, presenting a unified interface for all the supported transforms.
Home-page: http://hgomersall.github.com/pyFFTW/
Author: Henry Gomersall
@@ -13,18 +13,18 @@ Description:
Both the complex DFT and the real DFT are supported, as well as arbitrary
axes of abitrary shaped and strided arrays, which makes it almost
- feature equivalent to standard and real FFT functions of ``numpy.fft``
+ feature equivalent to standard and real FFT functions of ``numpy.fft``
(indeed, it supports the ``clongdouble`` dtype which ``numpy.fft`` does not).
Operating FFTW in multithreaded mode is supported.
- A comprehensive unittest suite can be found with the source on the github
+ A comprehensive unittest suite can be found with the source on the github
repository.
To build for windows from source, download the fftw dlls for your system
and the header file from here (they're in a zip file):
http://www.fftw.org/install/windows.html and place them in the pyfftw
- directory. The files are libfftw3-3.dll, libfftw3l-3.dll, libfftw3f-3.dll
+ directory. The files are libfftw3-3.dll, libfftw3l-3.dll, libfftw3f-3.dll
and libfftw3.h.
Under linux, to build from source, the FFTW library must be installed already.
@@ -32,7 +32,7 @@ Description:
Numpy is a dependency for both.
- The documentation can be found
+ The documentation can be found
`here <http://hgomersall.github.com/pyFFTW/>`_, and the source
is on `github <https://github.com/hgomersall/pyFFTW>`_.
diff --git a/README.rst b/README.rst
index e0d01c8..bc8ba07 100644
--- a/README.rst
+++ b/README.rst
@@ -6,7 +6,7 @@
| Appveyor | |appveyor_ci| |
+----------+---------------+
-.. |travis_ci| image:: https://travis-ci.org/hgomersall/pyFFTW.png?branch=master
+.. |travis_ci| image:: https://travis-ci.org/pyFFTW/pyFFTW.svg?branch=master
:align: middle
:target: https://travis-ci.org/hgomersall/pyFFTW
@@ -22,7 +22,7 @@ speedy FFT library. The ultimate aim is to present a unified interface for all
Both the complex DFT and the real DFT are supported, as well as on arbitrary
axes of abitrary shaped and strided arrays, which makes it almost
-feature equivalent to standard and real FFT functions of ``numpy.fft``
+feature equivalent to standard and real FFT functions of ``numpy.fft``
(indeed, it supports the ``clongdouble`` dtype which ``numpy.fft`` does not).
Wisdom import and export now works fairly reliably.
@@ -32,12 +32,12 @@ Operating FFTW in multithreaded mode is supported.
pyFFTW implements the numpy and scipy fft interfaces in order for users to
take advantage of the speed of FFTW with minimal code modifications.
-A comprehensive unittest suite can be found with the source on the github
+A comprehensive unittest suite can be found with the source on the github
repository or with the source distribution on PyPI.
-The documentation can be found on
-`github pages <http://hgomersall.github.com/pyFFTW>`_, the source is
-on `github <https://github.com/hgomersall/pyFFTW>`_ and the python package
+The documentation can be found on
+`github pages <http://pyfftw.github.io/pyFFTW>`_, the source is
+on `github <https://github.com/pyFFTW/pyFFTW>`_ and the python package
index page is `here <http://pypi.python.org/pypi/pyFFTW>`_.
Requirements (i.e. what it was designed for)
@@ -45,7 +45,7 @@ Requirements (i.e. what it was designed for)
- Python 2.7 or greater (Python 3 is supported)
- Numpy 1.6
- FFTW 3.3 or higher (lower versions *may* work)
-- Cython 0.15 or higher (though the source release on PyPI loses this
+- Cython 0.15 or higher (though the source release on PyPI loses this
dependency)
(install these as much as possible with your preferred package manager).
@@ -53,7 +53,7 @@ Requirements (i.e. what it was designed for)
Installation
------------
-We recommend *not* building from github, but using the release on
+We recommend *not* building from github, but using the release on
the python package index with tools such as easy_install or pip::
pip install pyfftw
@@ -67,9 +67,9 @@ all the necessary DLLs.
With FFTW installed, the PyPI release should install fine on Linux and Mac OSX. It doesn't mean it won't work anywhere else, just we don't have any information on it.
-Windows development builds are also automatically uploaded to
-`bintray <https://bintray.com/hgomersall/generic/PyFFTW-development-builds/view>`_
-as wheels (which are built against numpy 1.9), from where they can be
+Windows development builds are also automatically uploaded to
+`bintray <https://bintray.com/hgomersall/generic/PyFFTW-development-builds/view>`_
+as wheels (which are built against numpy 1.9), from where they can be
downloaded and installed with something like::
pip install pyFFTW-0.10.0.dev0+79ec589-cp35-none-win_amd64.whl
@@ -89,12 +89,12 @@ That cythons the python extension and builds it into a shared library
which is placed in ``pyfftw/``. The directory can then be treated as a python
package.
-After you've run ``setup.py`` with cython available, you then have a
-normal C extension in the ``pyfftw`` directory.
+After you've run ``setup.py`` with cython available, you then have a
+normal C extension in the ``pyfftw`` directory.
Further building does not depend on cython (as long as the .c file remains).
-For more ways of building and installing, see the
-`distutils documentation <http://docs.python.org/distutils/builtdist.html>`_
+For more ways of building and installing, see the
+`distutils documentation <http://docs.python.org/distutils/builtdist.html>`_
and `setuptools documentation <https://pythonhosted.org/setuptools/>`_.
Platform specific build info
@@ -104,22 +104,22 @@ Windows
~~~~~~~
To build for windows from source, download the fftw dlls for your system
-and the header file from `here <http://www.fftw.org/install/windows.html>`_
+and the header file from `here <http://www.fftw.org/install/windows.html>`_
(they're in a zip file) and place them in the pyfftw
-directory. The files are ``libfftw3-3.dll``, ``libfftw3l-3.dll``,
+directory. The files are ``libfftw3-3.dll``, ``libfftw3l-3.dll``,
``libfftw3f-3.dll``. If you're using a version of FFTW other than 3.3, it may
be necessary to copy ``fftw3.h`` into ``include\win``.
-The builds on PyPI use mingw for the 32-bit release and the Windows SDK
-C++ compiler for the 64-bit release. The scripts should handle this
+The builds on PyPI use mingw for the 32-bit release and the Windows SDK
+C++ compiler for the 64-bit release. The scripts should handle this
automatically. If you want to compile for 64-bit Windows, you have to use
-the MS Visual C++ compiler. Set up your environment as described
+the MS Visual C++ compiler. Set up your environment as described
`here <https://github.com/cython/cython/wiki/CythonExtensionsOnWindows>`_ and then
run `setup.py` with the version of python you wish to target and a suitable
build command.
-For using the MS Visual C++ compiler, you'll need to create a set of
-suitable `.lib` files as described on the
+For using the MS Visual C++ compiler, you'll need to create a set of
+suitable `.lib` files as described on the
`FFTW page <http://www.fftw.org/install/windows.html>`_.
Mac OSX
@@ -131,18 +131,18 @@ Install FFTW from `homebrew <http://brew.sh>`_::
Set temporary environmental variables, such that pyfftw finds fftw::
export DYLD_LIBRARY_PATH=/usr/local/lib
- export LDFLAGS="-L/usr/local/include"
+ export LDFLAGS="-L/usr/local/lib"
export CFLAGS="-I/usr/local/include"
Now install pyfftw from pip::
pip install pyfftw
-Notes: `pkgin <http://saveosx.org>`_ fftw package does not contain the long
+Notes: `pkgin <http://saveosx.org>`_ fftw package does not contain the long
or float implementations of fftw and so installation will fail.
-It has been suggested that `macports <http://www.macports.org/>`_ might also
-work fine. You should then replace the LD environmental variables above with the
+It has been suggested that `macports <http://www.macports.org/>`_ might also
+work fine. You should then replace the LD environmental variables above with the
right ones.
- DYLD - path for libfftw3.dylib etc - ``find /usr -name libfftw3.dylib``
@@ -153,7 +153,7 @@ Contributions
Contributions are always welcome and valued. The primary restriction on
accepting contributions is that they are exhaustively tested. The bulk of
-pyFFTW has been developed in a test-driven way (i.e. the test to be
+pyFFTW has been developed in a test-driven way (i.e. the test to be
satisfied is written before the code). I strongly encourage potential
contributors to adopt such an approach.
@@ -162,7 +162,7 @@ See some of my philosophy on testing in development `here
If you want to argue with the philosophy, there is probably a good place to
do it.
-New contributions should adhere to pep-8, but this is only weakly enforced
+New contributions should adhere to pep-8, but this is only weakly enforced
(there is loads of legacy stuff that breaks it, and things like a single
trailing whitespace is not a big deal).
@@ -173,4 +173,3 @@ where I can with any conceptual issues.
I suggest reading the issues already open in order that you know where things
might be heading, or what others are working on.
-
diff --git a/conf.py b/conf.py
new file mode 100644
index 0000000..88b360c
--- /dev/null
+++ b/conf.py
@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+#
+# pyFFTW documentation build configuration file, created by
+# sphinx-quickstart on Mon Jan 30 14:37:35 2012.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys, os
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+sys.path.insert(0, os.path.abspath('.'))
+
+# -- General configuration -----------------------------------------------------
+
+autoclass_content = "both"
+autodoc_docstring_signature = True
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.coverage',
+ 'sphinx.ext.intersphinx']
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'pyFFTW'
+copyright = u'2016, Henry Gomersall'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+from setup import VERSION as pyfftw_version
+# The short X.Y version.
+version = pyfftw_version
+# The full version, including alpha/beta/rc tags.
+release = pyfftw_version
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = ['docs', 'README.rst']
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+
+# -- Options for HTML output ---------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages. See the documentation for
+# a list of builtin themes.
+html_theme = 'default'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further. For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+# The name for this set of Sphinx documents. If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar. Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = [os.path.join('sphinx','_static')]
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it. The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = None
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'pyFFTWdoc'
+
+
+# -- Options for LaTeX output --------------------------------------------------
+
+# The paper size ('letter' or 'a4').
+#latex_paper_size = 'letter'
+
+# The font size ('10pt', '11pt' or '12pt').
+#latex_font_size = '10pt'
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, documentclass [howto/manual]).
+latex_documents = [
+ ('index', 'pyFFTW.tex', u'pyFFTW Documentation',
+ u'Henry Gomersall', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# If true, show page references after internal links.
+#latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#latex_show_urls = False
+
+# Additional stuff for the LaTeX preamble.
+#latex_preamble = ''
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_domain_indices = True
+
+
+# -- Options for manual page output --------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+ ('index', 'pyfftw', u'pyFFTW Documentation',
+ [u'Henry Gomersall'], 1)
+]
+
+# Intersphinx mappings
+intersphinx_mapping = {'http://docs.python.org/': None,
+ 'http://docs.scipy.org/doc/numpy': None,
+ 'http://docs.scipy.org/doc/scipy/reference': None}
+
+dependencies = {'pyfftw/pyfftw': ['pyfftw/pyfftw.so'],
+ 'pyfftw/builders/builders': ['pyfftw/builders/builders.py'],
+ 'pyfftw/builders/_utils': ['pyfftw/builders/utils.py']}
diff --git a/include/cpu.h b/include/cpu.h
index e8b166e..38cfc7f 100644
--- a/include/cpu.h
+++ b/include/cpu.h
@@ -1,6 +1,6 @@
/*
- * Copyright 2014 Knowledge Economy Developments Ltd
- *
+ * Copyright 2016 Knowledge Economy Developments Ltd
+ *
* Henry Gomersall
* heng at kedevelopments.co.uk
*
@@ -41,7 +41,7 @@
#if __STDC_VERSION__ >= 199901L
/* "inline" is a keyword */
#else
-# define inline static
+# define inline
#endif
#if defined(__amd64__) || defined (_M_X64) || defined(__i386__) || defined(_M_IX86) || defined(_X86_)
@@ -72,11 +72,11 @@
:"+a" (cpuinfo[0]), "=S" (cpuinfo[1]), /* eax rw, esi read */ \
"=c" (cpuinfo[2]), "=d" (cpuinfo[3]) /* ecx read, edx read */\
: :"edi")
-
+
#endif
/* Returns the byte alignment for optimum simd operations */
-inline int simd_alignment(void){
+static inline int simd_alignment(void){
int cpuinfo[4];
/* This gets the cpuinfo (set by 1)*/
@@ -92,7 +92,7 @@ inline int simd_alignment(void){
#else
-inline int simd_alignment(void){
+static inline int simd_alignment(void){
return 4;
}
#endif
diff --git a/include/msvc_2008/stdint.h b/include/msvc_2008/stdint.h
index 4fe0ef9..cb2acd9 100644
--- a/include/msvc_2008/stdint.h
+++ b/include/msvc_2008/stdint.h
@@ -1,33 +1,33 @@
// ISO C9x compliant stdint.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
-//
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
// Copyright (c) 2006-2013 Alexander Chemeris
-//
+//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
-//
+//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
-//
+//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
-//
+//
// 3. Neither the name of the product nor the names of its contributors may
// be used to endorse or promote products derived from this software
// without specific prior written permission.
-//
+//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+//
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSC_VER // [
diff --git a/include/msvc_2010/stdint.h b/include/msvc_2010/stdint.h
index ecf96e7..5802442 100644
--- a/include/msvc_2010/stdint.h
+++ b/include/msvc_2010/stdint.h
@@ -1,33 +1,33 @@
// ISO C9x compliant stdint.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
-//
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
// Copyright (c) 2006-2013 Alexander Chemeris
-//
+//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
-//
+//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
-//
+//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
-//
+//
// 3. Neither the name of the product nor the names of its contributors may
// be used to endorse or promote products derived from this software
// without specific prior written permission.
-//
+//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+//
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSC_VER // [
diff --git a/include/pyfftw_complex.h b/include/pyfftw_complex.h
index 63a627a..970ece0 100644
--- a/include/pyfftw_complex.h
+++ b/include/pyfftw_complex.h
@@ -1,6 +1,6 @@
/*
* Copyright 2014 Knowledge Economy Developments Ltd
- *
+ *
* Henry Gomersall
* heng at kedevelopments.co.uk
*
diff --git a/include/win/fftw3.h b/include/win/fftw3.h
index 6fabb7e..a66ed8d 100644
--- a/include/win/fftw3.h
+++ b/include/win/fftw3.h
@@ -4,7 +4,7 @@
*
* The following statement of license applies *only* to this header file,
* and *not* to the other files distributed with FFTW or derived therefrom:
- *
+ *
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
@@ -80,9 +80,9 @@ extern "C"
#if defined(FFTW_DLL) && (defined(_WIN32) || defined(__WIN32__))
/* annoying Windows syntax for shared-library declarations */
# if defined(COMPILING_FFTW) /* defined in api.h when compiling FFTW */
-# define FFTW_EXTERN extern __declspec(dllexport)
+# define FFTW_EXTERN extern __declspec(dllexport)
# else /* user is calling FFTW; import symbol */
-# define FFTW_EXTERN extern __declspec(dllimport)
+# define FFTW_EXTERN extern __declspec(dllimport)
# endif
#else
# define FFTW_EXTERN extern
@@ -113,7 +113,7 @@ typedef int (*fftw_read_char_func_do_not_use_me)(void *);
/*
huge second-order macro that defines prototypes for all API
functions. We expand this macro for each supported precision
-
+
X: name-mangling macro
R: real data type
C: complex data type
diff --git a/index.rst b/index.rst
new file mode 100644
index 0000000..528eb75
--- /dev/null
+++ b/index.rst
@@ -0,0 +1,56 @@
+.. pyFFTW documentation master file, created by
+ sphinx-quickstart on Mon Jan 30 14:37:35 2012.
+ You can adapt this file completely to your liking, but it should at least
+ contain the root `toctree` directive.
+
+Welcome to pyFFTW's documentation!
+==================================
+
+Introduction
+------------
+
+pyFFTW is a pythonic wrapper around `FFTW <http://www.fftw.org/>`_, the
+speedy FFT library. The ultimate aim is to present a unified interface for all
+the possible transforms that FFTW can perform.
+
+Both the complex DFT and the real DFT are supported, as well as on arbitrary
+axes of abitrary shaped and strided arrays, which makes it almost
+feature equivalent to standard and real FFT functions of :mod:`numpy.fft`
+(indeed, it supports the :attr:`~numpy.clongdouble` dtype which
+:mod:`!numpy.fft` does not).
+
+Operating FFTW in multithreaded mode is supported.
+
+The core interface is provided by a unified class, :class:`pyfftw.FFTW`.
+This core interface can be accessed directly, or through a series of helper
+functions, provided by the :mod:`pyfftw.builders` module. These helper
+functions provide an interface similar to :mod:`numpy.fft` for ease of use.
+
+In addition to using :class:`pyfftw.FFTW`, a convenient series of functions
+are included through :mod:`pyfftw.interfaces` that make using :mod:`pyfftw`
+almost equivalent to :mod:`numpy.fft` or :mod:`scipy.fftpack`.
+
+
+The source can be found in `github <https://github.com/hgomersall/pyFFTW>`_ and
+its page in the python package index is `here
+<http://pypi.python.org/pypi/pyFFTW>`_.
+
+A comprehensive unittest suite is included with the source on the repository.
+If any aspect of this library is not covered by the test suite, that is a bug
+(please report it!).
+
+Contents
+--------
+
+.. toctree::
+ :maxdepth: 2
+
+ /sphinx/tutorial
+ /sphinx/api
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
diff --git a/pyFFTW.egg-info/PKG-INFO b/pyFFTW.egg-info/PKG-INFO
index 8913dcb..1ebfec0 100644
--- a/pyFFTW.egg-info/PKG-INFO
+++ b/pyFFTW.egg-info/PKG-INFO
@@ -1,6 +1,6 @@
Metadata-Version: 1.1
Name: pyFFTW
-Version: 0.10.1
+Version: 0.10.3
Summary: A pythonic wrapper around FFTW, the FFT library, presenting a unified interface for all the supported transforms.
Home-page: http://hgomersall.github.com/pyFFTW/
Author: Henry Gomersall
@@ -13,18 +13,18 @@ Description:
Both the complex DFT and the real DFT are supported, as well as arbitrary
axes of abitrary shaped and strided arrays, which makes it almost
- feature equivalent to standard and real FFT functions of ``numpy.fft``
+ feature equivalent to standard and real FFT functions of ``numpy.fft``
(indeed, it supports the ``clongdouble`` dtype which ``numpy.fft`` does not).
Operating FFTW in multithreaded mode is supported.
- A comprehensive unittest suite can be found with the source on the github
+ A comprehensive unittest suite can be found with the source on the github
repository.
To build for windows from source, download the fftw dlls for your system
and the header file from here (they're in a zip file):
http://www.fftw.org/install/windows.html and place them in the pyfftw
- directory. The files are libfftw3-3.dll, libfftw3l-3.dll, libfftw3f-3.dll
+ directory. The files are libfftw3-3.dll, libfftw3l-3.dll, libfftw3f-3.dll
and libfftw3.h.
Under linux, to build from source, the FFTW library must be installed already.
@@ -32,7 +32,7 @@ Description:
Numpy is a dependency for both.
- The documentation can be found
+ The documentation can be found
`here <http://hgomersall.github.com/pyFFTW/>`_, and the source
is on `github <https://github.com/hgomersall/pyFFTW>`_.
diff --git a/pyFFTW.egg-info/SOURCES.txt b/pyFFTW.egg-info/SOURCES.txt
index 57278b4..6a6dc7a 100644
--- a/pyFFTW.egg-info/SOURCES.txt
+++ b/pyFFTW.egg-info/SOURCES.txt
@@ -2,6 +2,8 @@ CHANGELOG.md
LICENSE.txt
MANIFEST.in
README.rst
+conf.py
+index.rst
requirements.txt
setup.py
/home/whg/Projects/github/pyFFTW/pyfftw/pyfftw.c
@@ -54,17 +56,27 @@ pyfftw/cpu.pxd
pyfftw/pyfftw.c
pyfftw/pyfftw.pxd
pyfftw/pyfftw.pyx
+pyfftw/pyfftw.rst
pyfftw/utils.pxi
pyfftw/version.py
pyfftw/builders/__init__.py
pyfftw/builders/_utils.py
+pyfftw/builders/_utils.rst
pyfftw/builders/builders.py
+pyfftw/builders/builders.rst
pyfftw/interfaces/__init__.py
pyfftw/interfaces/_utils.py
pyfftw/interfaces/cache.py
+pyfftw/interfaces/interfaces.rst
pyfftw/interfaces/numpy_fft.py
+pyfftw/interfaces/numpy_fft.rst
pyfftw/interfaces/scipy_fftpack.py
+pyfftw/interfaces/scipy_fftpack.rst
+sphinx/api.rst
+sphinx/tutorial.rst
test/__init__.py
+test/_cook_nd_args.py
+test/_get_default_args.py
test/test_pyfftw_base.py
test/test_pyfftw_builders.py
test/test_pyfftw_call.py
diff --git a/pyfftw/__init__.py b/pyfftw/__init__.py
index a8b1541..7447736 100644
--- a/pyfftw/__init__.py
+++ b/pyfftw/__init__.py
@@ -1,7 +1,7 @@
#!/usr/bin/env python
# The pyfftw namespace
-''' The core of ``pyfftw`` consists of the :class:`FFTW` class,
+''' The core of ``pyfftw`` consists of the :class:`FFTW` class,
:ref:`wisdom functions <wisdom_functions>` and a couple of
:ref:`utility functions <utility_functions>` for dealing with aligned
arrays.
diff --git a/pyfftw/builders/_utils.py b/pyfftw/builders/_utils.py
index d3ded68..89034f9 100644
--- a/pyfftw/builders/_utils.py
+++ b/pyfftw/builders/_utils.py
@@ -2,7 +2,7 @@
#
# Copyright 2014 Knowledge Economy Developments Ltd
# Copyright 2014 David Wells
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
# David Wells
@@ -43,10 +43,10 @@ not need to use the functions directly, but they are included here for
completeness and to aid with understanding of what is happening behind
the scenes.
-Certainly, users may encounter instances of
+Certainly, users may encounter instances of
:class:`~pyfftw.builders._utils._FFTWWrapper`.
-These everything documented in this module is *not* part of the public API
+These everything documented in this module is *not* part of the public API
and may change in future versions.
'''
@@ -57,7 +57,7 @@ __all__ = ['_FFTWWrapper', '_rc_dtype_pairs', '_default_dtype', '_Xfftn',
'_setup_input_slicers', '_compute_array_shapes', '_precook_1d_args',
'_cook_nd_args']
-_valid_efforts = ('FFTW_ESTIMATE', 'FFTW_MEASURE',
+_valid_efforts = ('FFTW_ESTIMATE', 'FFTW_MEASURE',
'FFTW_PATIENT', 'FFTW_EXHAUSTIVE')
# Looking up a dtype in here returns the complex complement of the same
@@ -73,8 +73,8 @@ _rc_dtype_pairs = {numpy.dtype('float32').char: numpy.dtype('complex64'),
_default_dtype = numpy.dtype('float64')
-def _Xfftn(a, s, axes, overwrite_input,
- planner_effort, threads, auto_align_input, auto_contiguous,
+def _Xfftn(a, s, axes, overwrite_input,
+ planner_effort, threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real):
'''Generic transform interface for all the transforms. No
defaults exist. The transform must be specified exactly.
@@ -91,7 +91,7 @@ def _Xfftn(a, s, axes, overwrite_input,
raise ValueError('Invalid planner effort: ', planner_effort)
s, axes = _cook_nd_args(a, s, axes, invreal)
-
+
input_shape, output_shape = _compute_array_shapes(
a, s, axes, inverse, real)
@@ -105,7 +105,7 @@ def _Xfftn(a, s, axes, overwrite_input,
a = numpy.asarray(a, dtype=_rc_dtype_pairs[_default_dtype.char])
else:
a = numpy.asarray(a, dtype=_default_dtype)
-
+
elif not (real and not inverse) and not a_is_complex:
# We need to make it a complex dtype
a = numpy.asarray(a, dtype=_rc_dtype_pairs[a.dtype.char])
@@ -117,7 +117,7 @@ def _Xfftn(a, s, axes, overwrite_input,
# Make the output dtype correct
if not real:
output_dtype = a.dtype
-
+
else:
output_dtype = _rc_dtype_pairs[a.dtype.char]
@@ -146,7 +146,7 @@ def _Xfftn(a, s, axes, overwrite_input,
update_input_array_slicer, FFTW_array_slicer = (
_setup_input_slicers(a.shape, input_shape))
- # Also, the input array will be a different shape to the shape of
+ # Also, the input array will be a different shape to the shape of
# `a`, so we need to create a new array.
input_array = pyfftw.empty_aligned(input_shape, a.dtype)
@@ -166,7 +166,7 @@ def _Xfftn(a, s, axes, overwrite_input,
input_array = a
if auto_contiguous:
- # We only need to create a new array if it's not already
+ # We only need to create a new array if it's not already
# contiguous
if not (a.flags['C_CONTIGUOUS'] or a.flags['F_CONTIGUOUS']):
if avoid_copy:
@@ -192,7 +192,7 @@ def _Xfftn(a, s, axes, overwrite_input,
if not avoid_copy:
# Copy the data back into the (likely) destroyed array
FFTW_object.input_array[:] = a_copy
-
+
return FFTW_object
@@ -201,8 +201,8 @@ class _FFTWWrapper(pyfftw.FFTW):
stage during calls to :meth:`~pyfftw.builders._utils._FFTWWrapper.__call__`.
'''
- def __init__(self, input_array, output_array, axes=[-1],
- direction='FFTW_FORWARD', flags=['FFTW_MEASURE'],
+ def __init__(self, input_array, output_array, axes=[-1],
+ direction='FFTW_FORWARD', flags=['FFTW_MEASURE'],
threads=1, input_array_slicer=None, FFTW_array_slicer=None):
'''The arguments are as per :class:`pyfftw.FFTW`, but with the addition
of 2 keyword arguments: ``input_array_slicer`` and
@@ -225,12 +225,12 @@ class _FFTWWrapper(pyfftw.FFTW):
else:
self._input_destroyed = False
- pyfftw.FFTW.__init__(self, input_array, output_array,
+ pyfftw.FFTW.__init__(self, input_array, output_array,
axes, direction, flags, threads)
- def __call__(self, input_array=None, output_array=None,
- normalise_idft=True):
- '''Wrap :meth:`pyfftw.FFTW.__call__` by firstly slicing the
+ def __call__(self, input_array=None, output_array=None,
+ normalise_idft=True, ortho=False):
+ '''Wrap :meth:`pyfftw.FFTW.__call__` by firstly slicing the
passed-in input array and then copying it into a sliced version
of the internal array. These slicers are set at instantiation.
@@ -264,7 +264,8 @@ class _FFTWWrapper(pyfftw.FFTW):
sliced_internal[:] = sliced_input
output = super(_FFTWWrapper, self).__call__(input_array=None,
- output_array=output_array, normalise_idft=normalise_idft)
+ output_array=output_array, normalise_idft=normalise_idft,
+ ortho=ortho)
return output
@@ -276,7 +277,7 @@ def _setup_input_slicers(a_shape, input_shape):
``(update_input_array_slicer, FFTW_array_slicer)``
- On calls to :class:`~pyfftw.builders._utils._FFTWWrapper` objects,
+ On calls to :class:`~pyfftw.builders._utils._FFTWWrapper` objects,
the input array is copied in as:
``FFTW_array[FFTW_array_slicer] = input_array[update_input_array_slicer]``
@@ -309,9 +310,9 @@ def _setup_input_slicers(a_shape, input_shape):
def _compute_array_shapes(a, s, axes, inverse, real):
'''Given a passed in array ``a``, and the rest of the arguments
- (that have been fleshed out with
+ (that have been fleshed out with
:func:`~pyfftw.builders._utils._cook_nd_args`), compute
- the shape the input and output arrays need to be in order
+ the shape the input and output arrays need to be in order
to satisfy all the requirements for the transform. The input
shape *may* be different to the shape of a.
@@ -321,7 +322,7 @@ def _compute_array_shapes(a, s, axes, inverse, real):
# Start with the shape of a
orig_domain_shape = list(a.shape)
fft_domain_shape = list(a.shape)
-
+
try:
for n, axis in enumerate(axes):
orig_domain_shape[axis] = s[n]
@@ -385,4 +386,3 @@ def _cook_nd_args(a, s=None, axes=None, invreal=False):
'of the input array, a.')
return tuple(s), tuple(axes)
-
diff --git a/pyfftw/builders/_utils.rst b/pyfftw/builders/_utils.rst
new file mode 100644
index 0000000..45abab5
--- /dev/null
+++ b/pyfftw/builders/_utils.rst
@@ -0,0 +1,10 @@
+``pyfftw.builders._utils`` - Helper functions for :mod:`pyfftw.builders`
+========================================================================
+
+.. automodule:: pyfftw.builders._utils
+ :members:
+ :private-members:
+ :exclude-members: _FFTWWrapper
+
+ .. autoclass:: pyfftw.builders._utils._FFTWWrapper
+ :members: __call__
diff --git a/pyfftw/builders/builders.py b/pyfftw/builders/builders.py
index badc6f2..13806ab 100644
--- a/pyfftw/builders/builders.py
+++ b/pyfftw/builders/builders.py
@@ -2,7 +2,7 @@
#
# Copyright 2014 Knowledge Economy Developments Ltd
# Copyright 2014 David Wells
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
# David Wells
@@ -41,7 +41,7 @@
Overview
""""""""
-This module contains a set of functions that return
+This module contains a set of functions that return
:class:`pyfftw.FFTW` objects.
The interface to create these objects is mostly the same as
@@ -91,13 +91,13 @@ complexity. This results in a copy being made.
Although the array that is internal to the :class:`pyfftw.FFTW` object
will be correctly loaded with the values within the input array, it is
not necessarily the case that the internal array *is* the input array.
-The actual internal input array can always be retrieved with
+The actual internal input array can always be retrieved with
:attr:`pyfftw.FFTW.input_array`.
**Example:**
.. doctest::
-
+
>>> import pyfftw
>>> a = pyfftw.empty_aligned(4, dtype='complex128')
>>> fft = pyfftw.builders.fft(a)
@@ -139,7 +139,7 @@ to note from this is that the precision of the transform matches the
precision of the input array. So, if a single precision input array is
passed in, then a single precision transform will be used.
-The second caveat is that repeated axes are handled differently; with
+The second caveat is that repeated axes are handled differently; with
the returned :class:`pyfftw.FFTW` object, axes that are repeated in the
axes argument are considered only once, as compared to :mod:`numpy.fft`
in which repeated axes results in the DFT being taken along that axes
@@ -170,12 +170,12 @@ following additional keyword arguments:
offered for the multi-dimensional inverse real transforms, as FFTW is
unable to not overwrite the input in that case.
-* ``planner_effort``: A string dictating how much effort is spent
+* ``planner_effort``: A string dictating how much effort is spent
in planning the FFTW routines. This is passed to the creation
- of the :class:`pyfftw.FFTW` object as an entry in the flags list.
+ of the :class:`pyfftw.FFTW` object as an entry in the flags list.
They correspond to flags passed to the :class:`pyfftw.FFTW` object.
- The valid strings, in order of their increasing impact on the time
+ The valid strings, in order of their increasing impact on the time
to compute are:
``'FFTW_ESTIMATE'``, ``'FFTW_MEASURE'`` (default), ``'FFTW_PATIENT'``
and ``'FFTW_EXHAUSTIVE'``.
@@ -219,17 +219,17 @@ following additional keyword arguments:
memory before performing the transform on it. If the array is not
contiguous, it is copied into an interim array. This is because it
is often faster to copy the data before the transform and then transform
- a contiguous array than it is to try to take the transform of a
+ a contiguous array than it is to try to take the transform of a
non-contiguous array. This is particularly true in conjunction with
- the ``auto_align_input`` argument which is used to make sure that the
+ the ``auto_align_input`` argument which is used to make sure that the
transform is taken of an aligned array.
- Like ``auto_align_input``, If a new array is created, it is
- up to the calling code to acquire that new input array using
+ Like ``auto_align_input``, If a new array is created, it is
+ up to the calling code to acquire that new input array using
:attr:`pyfftw.FFTW.input_array`.
-* ``avoid_copy``: By default, these functions will always create a copy
- (and sometimes more than one) of the passed in input array. This is
+* ``avoid_copy``: By default, these functions will always create a copy
+ (and sometimes more than one) of the passed in input array. This is
because the creation of the :class:`pyfftw.FFTW` object generally
destroys the contents of the input array. Setting this argument to
``True`` will try not to create a copy of the input array, likely
@@ -245,7 +245,7 @@ following additional keyword arguments:
* The dtypes are incompatible with the FFT routine.
- * The ``auto_contiguous`` or ``auto_align`` flags are True and
+ * The ``auto_contiguous`` or ``auto_align`` flags are True and
the input array is not already contiguous or aligned.
This argument is distinct from ``overwrite_input`` in that it only
@@ -259,18 +259,18 @@ equivalents in :mod:`numpy.fft`, or as documented above.
from ._utils import _precook_1d_args, _Xfftn
__all__ = ['fft','ifft', 'fft2', 'ifft2', 'fftn',
- 'ifftn', 'rfft', 'irfft', 'rfft2', 'irfft2', 'rfftn',
+ 'ifftn', 'rfft', 'irfft', 'rfft2', 'irfft2', 'rfftn',
'irfftn']
-def fft(a, n=None, axis=-1, overwrite_input=False,
+def fft(a, n=None, axis=-1, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
'''Return a :class:`pyfftw.FFTW` object representing a 1D FFT.
-
- The first three arguments are as per :func:`numpy.fft.fft`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.fft`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
inverse = False
@@ -279,28 +279,28 @@ def fft(a, n=None, axis=-1, overwrite_input=False,
s, axes = _precook_1d_args(a, n, axis)
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
def ifft(a, n=None, axis=-1, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
- '''Return a :class:`pyfftw.FFTW` object representing a 1D
+ '''Return a :class:`pyfftw.FFTW` object representing a 1D
inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.ifft`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.ifft`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
inverse = True
real = False
-
+
s, axes = _precook_1d_args(a, n, axis)
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
@@ -309,38 +309,38 @@ def fft2(a, s=None, axes=(-2,-1), overwrite_input=False,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
'''Return a :class:`pyfftw.FFTW` object representing a 2D FFT.
-
- The first three arguments are as per :func:`numpy.fft.fft2`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.fft2`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
-
+
inverse = False
real = False
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
def ifft2(a, s=None, axes=(-2,-1), overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
- '''Return a :class:`pyfftw.FFTW` object representing a
+ '''Return a :class:`pyfftw.FFTW` object representing a
2D inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.ifft2`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.ifft2`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
-
+
inverse = True
real = False
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
@@ -349,9 +349,9 @@ def fftn(a, s=None, axes=None, overwrite_input=False,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
'''Return a :class:`pyfftw.FFTW` object representing a n-D FFT.
-
- The first three arguments are as per :func:`numpy.fft.fftn`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.fftn`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
@@ -360,18 +360,18 @@ def fftn(a, s=None, axes=None, overwrite_input=False,
real = False
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
def ifftn(a, s=None, axes=None, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
- '''Return a :class:`pyfftw.FFTW` object representing an n-D
+ '''Return a :class:`pyfftw.FFTW` object representing an n-D
inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.ifftn`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.ifftn`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
@@ -380,40 +380,40 @@ def ifftn(a, s=None, axes=None, overwrite_input=False,
real = False
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
def rfft(a, n=None, axis=-1, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
- '''Return a :class:`pyfftw.FFTW` object representing a 1D
+ '''Return a :class:`pyfftw.FFTW` object representing a 1D
real FFT.
-
- The first three arguments are as per :func:`numpy.fft.rfft`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.rfft`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
inverse = False
real = True
-
+
s, axes = _precook_1d_args(a, n, axis)
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
def irfft(a, n=None, axis=-1, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
- '''Return a :class:`pyfftw.FFTW` object representing a 1D
+ '''Return a :class:`pyfftw.FFTW` object representing a 1D
real inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.irfft`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.irfft`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
@@ -424,18 +424,18 @@ def irfft(a, n=None, axis=-1, overwrite_input=False,
s, axes = _precook_1d_args(a, n, axis)
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
def rfft2(a, s=None, axes=(-2,-1), overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
- '''Return a :class:`pyfftw.FFTW` object representing a 2D
+ '''Return a :class:`pyfftw.FFTW` object representing a 2D
real FFT.
-
- The first three arguments are as per :func:`numpy.fft.rfft2`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.rfft2`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
@@ -443,18 +443,18 @@ def rfft2(a, s=None, axes=(-2,-1), overwrite_input=False,
real = True
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
def irfft2(a, s=None, axes=(-2,-1),
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
- '''Return a :class:`pyfftw.FFTW` object representing a 2D
+ '''Return a :class:`pyfftw.FFTW` object representing a 2D
real inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.irfft2`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.irfft2`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
@@ -462,10 +462,10 @@ def irfft2(a, s=None, axes=(-2,-1),
inverse = True
real = True
- overwrite_input = True
+ overwrite_input = True
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
@@ -473,11 +473,11 @@ def rfftn(a, s=None, axes=None, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
- '''Return a :class:`pyfftw.FFTW` object representing an n-D
+ '''Return a :class:`pyfftw.FFTW` object representing an n-D
real FFT.
-
- The first three arguments are as per :func:`numpy.fft.rfftn`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.rfftn`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
@@ -486,7 +486,7 @@ def rfftn(a, s=None, axes=None, overwrite_input=False,
real = True
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
@@ -494,11 +494,11 @@ def irfftn(a, s=None, axes=None,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True,
avoid_copy=False):
- '''Return a :class:`pyfftw.FFTW` object representing an n-D
+ '''Return a :class:`pyfftw.FFTW` object representing an n-D
real inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.rfftn`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.rfftn`;
+ the rest of the arguments are documented
:ref:`in the module docs <builders_args>`.
'''
@@ -509,8 +509,5 @@ def irfftn(a, s=None, axes=None,
overwrite_input = True
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
avoid_copy, inverse, real)
-
-
-
diff --git a/pyfftw/builders/builders.rst b/pyfftw/builders/builders.rst
new file mode 100644
index 0000000..7f93570
--- /dev/null
+++ b/pyfftw/builders/builders.rst
@@ -0,0 +1,9 @@
+``pyfftw.builders`` - Get :class:`~!pyfftw.FFTW` objects using a :mod:`!numpy.fft` like interface
+=================================================================================================
+
+.. automodule:: pyfftw.builders
+ :members:
+ :undoc-members:
+
+ The Functions
+ """""""""""""
diff --git a/pyfftw/cpu.pxd b/pyfftw/cpu.pxd
index 10f0acd..48cf78d 100644
--- a/pyfftw/cpu.pxd
+++ b/pyfftw/cpu.pxd
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
diff --git a/pyfftw/interfaces/__init__.py b/pyfftw/interfaces/__init__.py
index 6f83895..153c075 100644
--- a/pyfftw/interfaces/__init__.py
+++ b/pyfftw/interfaces/__init__.py
@@ -19,8 +19,8 @@ amount of the flexibility compared to accessing the :class:`pyfftw.FFTW`
object directly, but implements a reasonable set of defaults and optional
tweaks that should satisfy most situations.
-The precision of the transform that is used is selected from the array that
-is passed in, defaulting to double precision if any type conversion is
+The precision of the transform that is used is selected from the array that
+is passed in, defaulting to double precision if any type conversion is
required.
This module works by generating a :class:`pyfftw.FFTW` object behind the
@@ -82,7 +82,7 @@ Implemented Functions
The implemented functions are listed below. :mod:`numpy.fft` is implemented
by :mod:`pyfftw.interfaces.numpy_fft` and :mod:`scipy.fftpack` by
:mod:`pyfftw.interfaces.scipy_fftpack`. All the implemented functions are
-extended by the use of additional arguments, which are
+extended by the use of additional arguments, which are
:ref:`documented below<interfaces_additional_args>`.
Not all the functions provided by :mod:`numpy.fft` and :mod:`scipy.fftpack`
@@ -91,11 +91,11 @@ not implemented, the function is imported into the namespace from the
corresponding library. This means that all the documented functionality of the
library *is* provided through :mod:`pyfftw.interfaces`.
-One known caveat is that repeated axes are potentially handled
+One known caveat is that repeated axes are potentially handled
differently. This is certainly the case for :mod:`numpy.fft` and probably
-also true for :mod:`scipy.fftpack` (though it is not defined in the
-docs); axes that are repeated in the axes argument are considered only once, as
-compared to :mod:`numpy.fft` in which repeated axes results in the DFT
+also true for :mod:`scipy.fftpack` (though it is not defined in the
+docs); axes that are repeated in the axes argument are considered only once, as
+compared to :mod:`numpy.fft` in which repeated axes results in the DFT
being taken along that axes as many times as the axis occurs.
:mod:`~pyfftw.interfaces.numpy_fft`
@@ -136,8 +136,8 @@ Additional Arguments
In addition to the equivalent arguments in :mod:`numpy.fft` and
:mod:`scipy.fftpack`, all these functions also add several additional
-arguments for finer control over the FFT. These additional arguments are
-largely a subset of the
+arguments for finer control over the FFT. These additional arguments are
+largely a subset of the
keyword arguments in :mod:`pyfftw.builders` with a few exceptions and with
different defaults.
@@ -149,18 +149,18 @@ different defaults.
*every* function in this package.
In :mod:`~pyfftw.interfaces.scipy_fftpack`, this argument is replaced
- by ``overwrite_x``, to which it is equivalent (albeit at the same
+ by ``overwrite_x``, to which it is equivalent (albeit at the same
position).
The default is ``False`` to be consistent with :mod:`numpy.fft`.
-* ``planner_effort``: A string dictating how much effort is spent
+* ``planner_effort``: A string dictating how much effort is spent
in planning the FFTW routines. This is passed to the creation
- of the intermediate :class:`pyfftw.FFTW` object as an entry
- in the flags list. They correspond to flags passed to the
+ of the intermediate :class:`pyfftw.FFTW` object as an entry
+ in the flags list. They correspond to flags passed to the
:class:`pyfftw.FFTW` object.
- The valid strings, in order of their increasing impact on the time
+ The valid strings, in order of their increasing impact on the time
to compute are:
``'FFTW_ESTIMATE'``, ``'FFTW_MEASURE'`` (default), ``'FFTW_PATIENT'``
and ``'FFTW_EXHAUSTIVE'``.
@@ -204,9 +204,9 @@ different defaults.
memory before performing the transform on it. If the array is not
contiguous, it is copied into an interim array. This is because it
is often faster to copy the data before the transform and then transform
- a contiguous array than it is to try to take the transform of a
+ a contiguous array than it is to try to take the transform of a
non-contiguous array. This is particularly true in conjunction with
- the ``auto_align_input`` argument which is used to make sure that the
+ the ``auto_align_input`` argument which is used to make sure that the
transform is taken of an aligned array.
The default is ``True``.
@@ -224,4 +224,3 @@ except ImportError:
else:
del scipy
from . import scipy_fftpack
-
diff --git a/pyfftw/interfaces/_utils.py b/pyfftw/interfaces/_utils.py
index cb42d20..0b55f46 100644
--- a/pyfftw/interfaces/_utils.py
+++ b/pyfftw/interfaces/_utils.py
@@ -1,10 +1,13 @@
#!/usr/bin/env python
#
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
+# Michael McNeil Forbes
+# michael.forbes+pyfftw at gmail.com
+#
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -44,10 +47,10 @@ import numpy
from . import cache
def _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
- calling_func, normalise_idft=True):
+ threads, auto_align_input, auto_contiguous,
+ calling_func, normalise_idft=True, ortho=False):
- reload_after_transform = False
+ work_with_copy = False
a = numpy.asanyarray(a)
@@ -63,21 +66,38 @@ def _Xfftn(a, s, axes, overwrite_input, planner_effort,
if calling_func in ('irfft2', 'irfftn'):
# overwrite_input is not an argument to irfft2 or irfftn
- args = (a, s, axes, planner_effort, threads,
- auto_align_input, auto_contiguous)
+ args = (planner_effort, threads, auto_align_input, auto_contiguous)
if not overwrite_input:
# Only irfft2 and irfftn have overwriting the input
- # as the default (and so require the input array to
+ # as the default (and so require the input array to
# be reloaded).
- reload_after_transform = True
+ work_with_copy = True
else:
- args = (a, s, axes, overwrite_input, planner_effort, threads,
+ args = (overwrite_input, planner_effort, threads,
auto_align_input, auto_contiguous)
-
+
+ if not a.flags.writeable:
+ # Special case of a locked array - always work with a
+ # copy. See issue #92.
+ work_with_copy = True
+
+ if overwrite_input:
+ raise ValueError('overwrite_input cannot be True when the ' +
+ 'input array flags.writeable is False')
+
+ if work_with_copy:
+ # We make the copy before registering the key so that the
+ # copy's stride information will be cached since this will be
+ # used for planning. Make sure the copy is byte aligned to
+ # prevent further copying
+ a_original = a
+ a = pyfftw.empty_aligned(shape=a.shape, dtype=a.dtype)
+ a[...] = a_original
+
if cache.is_enabled():
- key = (calling_func, a.shape, a.strides, a.dtype, s.__hash__(),
- axes.__hash__(), args[3:])
+ key = (calling_func, a.shape, a.strides, a.dtype, s.__hash__(),
+ axes.__hash__(), args)
try:
if key in cache._fftw_cache:
@@ -92,29 +112,29 @@ def _Xfftn(a, s, axes, overwrite_input, planner_effort,
if not cache.is_enabled() or FFTW_object is None:
- # If we're going to create a new FFTW object, we need to copy
- # the input array to preserve it, otherwise we can't actually
- # take the transform of the input array! (in general, we have
- # to assume that the input array will be destroyed during
- # planning).
- a_copy = a.copy()
+ # If we're going to create a new FFTW object and are not
+ # working with a copy, then we need to copy the input array to
+ # preserve it, otherwise we can't actually take the transform
+ # of the input array! (in general, we have to assume that the
+ # input array will be destroyed during planning).
+ if not work_with_copy:
+ a_copy = a.copy()
+
+ planner_args = (a, s, axes) + args
+
+ FFTW_object = getattr(builders, calling_func)(*planner_args)
- FFTW_object = getattr(builders, calling_func)(*args)
-
# Only copy if the input array is what was actually used
# (otherwise it shouldn't be overwritten)
- if FFTW_object.input_array is a:
+ if not work_with_copy and FFTW_object.input_array is a:
a[:] = a_copy
if cache.is_enabled():
cache._fftw_cache.insert(FFTW_object, key)
-
- output_array = FFTW_object(normalise_idft=normalise_idft)
- else:
- if reload_after_transform:
- a_copy = a.copy()
+ output_array = FFTW_object(normalise_idft=normalise_idft, ortho=ortho)
+ else:
orig_output_array = FFTW_object.output_array
output_shape = orig_output_array.shape
output_dtype = orig_output_array.dtype
@@ -123,10 +143,7 @@ def _Xfftn(a, s, axes, overwrite_input, planner_effort,
output_array = pyfftw.empty_aligned(
output_shape, output_dtype, n=output_alignment)
- FFTW_object(input_array=a, output_array=output_array,
- normalise_idft=normalise_idft)
-
- if reload_after_transform:
- a[:] = a_copy
+ FFTW_object(input_array=a, output_array=output_array,
+ normalise_idft=normalise_idft, ortho=ortho)
return output_array
diff --git a/pyfftw/interfaces/cache.py b/pyfftw/interfaces/cache.py
index 8104705..74f93eb 100644
--- a/pyfftw/interfaces/cache.py
+++ b/pyfftw/interfaces/cache.py
@@ -1,7 +1,7 @@
#!/usr/bin/env python
#
# Copyright 2015 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -44,7 +44,7 @@ still take longer than a short transform.
This module implements a method by which objects that are created through
:mod:`pyfftw.interfaces` are temporarily cached. If an equivalent
transform is then performed within a short period, the object is acquired
-from the cache rather than a new one created. The equivalency is quite
+from the cache rather than a new one created. The equivalency is quite
conservative and in practice means that if any of the arguments change, or
if the properties of the array (shape, strides, dtype) change in any way, then
the cache lookup will fail.
@@ -55,11 +55,11 @@ which can be set with :func:`pyfftw.interfaces.cache.set_keepalive_time`,
then they are removed from the cache (liberating any associated memory).
The default keepalive time is 0.1 seconds.
-Enable the cache by calling :func:`pyfftw.interfaces.cache.enable`.
+Enable the cache by calling :func:`pyfftw.interfaces.cache.enable`.
Disable it by calling :func:`pyfftw.interfaces.cache.disable`. By default,
the cache is disabled.
-Note that even with the cache enabled, there is a fixed overhead associated
+Note that even with the cache enabled, there is a fixed overhead associated
with lookups. This means that for small transforms, the overhead may exceed
the transform. At this point, it's worth looking at using :class:`pyfftw.FFTW`
directly.
@@ -68,7 +68,7 @@ When the cache is enabled, the module spawns a new thread to keep track
of the objects. If :mod:`threading` is not available, then the cache
is not available and trying to use it will raise an ImportError exception.
-The actual implementation of the cache is liable to change, but the
+The actual implementation of the cache is liable to change, but the
documented API is stable.
'''
@@ -117,19 +117,19 @@ def is_enabled():
def set_keepalive_time(keepalive_time):
'''Set the minimum time in seconds for which any :mod:`pyfftw.FFTW` object
in the cache is kept alive.
-
+
When the cache is enabled, the interim objects that are used through
a :mod:`pyfftw.interfaces` function are cached for the time set through
- this function. If the object is not used for the that time, it is
+ this function. If the object is not used for the that time, it is
removed from the cache. Using the object zeros the timer.
- The time is not precise, and sets a minimum time to be alive. In
+ The time is not precise, and sets a minimum time to be alive. In
practice, it may be quite a bit longer before the object is
deleted from the cache (due to implementational details - e.g. contention
from other threads).
'''
global _fftw_cache
-
+
if _fftw_cache is None:
raise CacheError('Cache is not currently enabled')
else:
@@ -159,7 +159,7 @@ class _Cache(object):
self._initialised = _threading.Event()
self._initialised.clear() # Explicitly clear it for clarity
-
+
self._thread_object = _threading.Thread(target=_Cache._run,
args=(weakref.proxy(self), ))
@@ -167,8 +167,8 @@ class _Cache(object):
self._thread_object.start()
while not self._initialised.is_set():
- # This loop is necessary to stop the main thread doing
- # anything until the exception handler in _run can deal with
+ # This loop is necessary to stop the main thread doing
+ # anything until the exception handler in _run can deal with
# the object being deleted.
pass
@@ -178,7 +178,7 @@ class _Cache(object):
# be raised).
try:
self._close_thread_now.set()
-
+
except TypeError:
# Not sure what's going on here, but IPython baulks on exit
pass
@@ -194,7 +194,7 @@ class _Cache(object):
self._initialised.set()
while True:
- if (not self._parent_thread.is_alive() or
+ if (not self._parent_thread.is_alive() or
self._close_thread_now.is_set()):
break
@@ -230,7 +230,7 @@ class _Cache(object):
'''Set the minimum time in seconds for which any object in the cache
is kept alive.
- The time is not precise, and sets a minimum time to be alive. In
+ The time is not precise, and sets a minimum time to be alive. In
practice, it may be up to twice as long before the object is
deleted from the cache (due to implementational details).
'''
@@ -249,7 +249,7 @@ class _Cache(object):
self._keepalive_set.add(key)
def insert(self, obj, key):
- '''Insert the passed object into the cache, referenced by key,
+ '''Insert the passed object into the cache, referenced by key,
a hashable.
'''
with self._cull_lock:
@@ -260,6 +260,5 @@ class _Cache(object):
'''Lookup the object referenced by key and return it, refreshing
the cache at the same time.
'''
- self._refresh(key)
+ self._refresh(key)
return self._cache_dict[key]
-
diff --git a/pyfftw/interfaces/interfaces.rst b/pyfftw/interfaces/interfaces.rst
new file mode 100644
index 0000000..4ebc97e
--- /dev/null
+++ b/pyfftw/interfaces/interfaces.rst
@@ -0,0 +1,16 @@
+``pyfftw.interfaces`` - Drop in replacements for other FFT implementations
+==========================================================================
+
+.. toctree::
+ :hidden:
+
+ numpy_fft
+ scipy_fftpack
+
+.. automodule:: pyfftw.interfaces
+
+Caching
+-------
+
+.. automodule:: pyfftw.interfaces.cache
+ :members:
diff --git a/pyfftw/interfaces/numpy_fft.py b/pyfftw/interfaces/numpy_fft.py
index 221f095..19b1d6f 100644
--- a/pyfftw/interfaces/numpy_fft.py
+++ b/pyfftw/interfaces/numpy_fft.py
@@ -34,12 +34,12 @@
'''
This module implements those functions that replace aspects of the
-:mod:`numpy.fft` module. This module *provides* the entire documented namespace
+:mod:`numpy.fft` module. This module *provides* the entire documented namespace
of :mod:`numpy.fft`, but those functions that are not included here are imported
directly from :mod:`numpy.fft`.
-It is notable that unlike :mod:`numpy.fftpack`, these functions will
+It is notable that unlike :mod:`numpy.fftpack`, these functions will
generally return an output array with the same precision as the input
array, and the transform that is chosen is chosen based on the precision
of the input array. That is, if the input array is 32-bit floating point,
@@ -63,161 +63,204 @@ from ._utils import _Xfftn
from numpy.fft import fftfreq, fftshift, ifftshift
import numpy
-__all__ = ['fft','ifft', 'fft2', 'ifft2', 'fftn', 'ifftn',
+__all__ = ['fft','ifft', 'fft2', 'ifft2', 'fftn', 'ifftn',
'rfft', 'irfft', 'rfft2', 'irfft2', 'rfftn', 'irfftn',
'hfft', 'ihfft', 'fftfreq', 'fftshift', 'ifftshift']
-def fft(a, n=None, axis=-1, overwrite_input=False,
+def _unitary(norm):
+ """_unitary() utility copied from numpy"""
+ if norm not in (None, "ortho"):
+ raise ValueError("Invalid norm value %s, should be None or \"ortho\"."
+ % norm)
+ return norm is not None
+
+def fft(a, n=None, axis=-1, norm=None, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 1D FFT.
-
- The first three arguments are as per :func:`numpy.fft.fft`;
- the rest of the arguments are documented
+
+ The first four arguments are as per :func:`numpy.fft.fft`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'fft'
+ if _unitary(norm):
+ ortho = True
+ normalise_idft = False
+ else:
+ ortho = False
+ normalise_idft = True
return _Xfftn(a, n, axis, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
- calling_func)
+ threads, auto_align_input, auto_contiguous,
+ calling_func, normalise_idft=normalise_idft, ortho=ortho)
-def ifft(a, n=None, axis=-1, overwrite_input=False,
+def ifft(a, n=None, axis=-1, norm=None, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 1D inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.ifft`;
- the rest of the arguments are documented
+
+ The first four arguments are as per :func:`numpy.fft.ifft`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'ifft'
+ if _unitary(norm):
+ ortho = True
+ normalise_idft = False
+ else:
+ ortho = False
+ normalise_idft = True
return _Xfftn(a, n, axis, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
- calling_func)
+ threads, auto_align_input, auto_contiguous,
+ calling_func, normalise_idft=normalise_idft, ortho=ortho)
-def fft2(a, s=None, axes=(-2,-1), overwrite_input=False,
+def fft2(a, s=None, axes=(-2,-1), norm=None, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 2D FFT.
-
- The first three arguments are as per :func:`numpy.fft.fft2`;
- the rest of the arguments are documented
+
+ The first four arguments are as per :func:`numpy.fft.fft2`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'fft2'
+ if _unitary(norm):
+ ortho = True
+ normalise_idft = False
+ else:
+ ortho = False
+ normalise_idft = True
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
- calling_func)
+ threads, auto_align_input, auto_contiguous,
+ calling_func, normalise_idft=normalise_idft, ortho=ortho)
-def ifft2(a, s=None, axes=(-2,-1), overwrite_input=False,
+def ifft2(a, s=None, axes=(-2,-1), norm=None, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 2D inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.ifft2`;
- the rest of the arguments are documented
+
+ The first four arguments are as per :func:`numpy.fft.ifft2`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'ifft2'
+ if _unitary(norm):
+ ortho = True
+ normalise_idft = False
+ else:
+ ortho = False
+ normalise_idft = True
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
- calling_func)
+ threads, auto_align_input, auto_contiguous,
+ calling_func, normalise_idft=normalise_idft, ortho=ortho)
-def fftn(a, s=None, axes=None, overwrite_input=False,
+def fftn(a, s=None, axes=None, norm=None, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform an n-D FFT.
-
- The first three arguments are as per :func:`numpy.fft.fftn`;
- the rest of the arguments are documented
+
+ The first four arguments are as per :func:`numpy.fft.fftn`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'fftn'
+ if _unitary(norm):
+ ortho = True
+ normalise_idft = False
+ else:
+ ortho = False
+ normalise_idft = True
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
- calling_func)
+ threads, auto_align_input, auto_contiguous,
+ calling_func, normalise_idft=normalise_idft, ortho=ortho)
-def ifftn(a, s=None, axes=None, overwrite_input=False,
+def ifftn(a, s=None, axes=None, norm=None, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform an n-D inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.ifftn`;
- the rest of the arguments are documented
+
+ The first four arguments are as per :func:`numpy.fft.ifftn`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'ifftn'
+ if _unitary(norm):
+ ortho = True
+ normalise_idft = False
+ else:
+ ortho = False
+ normalise_idft = True
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
- calling_func)
+ threads, auto_align_input, auto_contiguous,
+ calling_func, normalise_idft=normalise_idft, ortho=ortho)
def rfft(a, n=None, axis=-1, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 1D real FFT.
-
- The first three arguments are as per :func:`numpy.fft.rfft`;
- the rest of the arguments are documented
+
+ The three four arguments are as per :func:`numpy.fft.rfft`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'rfft'
return _Xfftn(a, n, axis, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
calling_func)
def irfft(a, n=None, axis=-1, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 1D real inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.irfft`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.irfft`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'irfft'
return _Xfftn(a, n, axis, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
calling_func)
def rfft2(a, s=None, axes=(-2,-1), overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 2D real FFT.
-
- The first three arguments are as per :func:`numpy.fft.rfft2`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.rfft2`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'rfft2'
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
calling_func)
def irfft2(a, s=None, axes=(-2,-1), overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 2D real inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.irfft2`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.irfft2`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'irfft2'
-
+
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
calling_func)
@@ -225,15 +268,15 @@ def rfftn(a, s=None, axes=None, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform an n-D real FFT.
-
- The first three arguments are as per :func:`numpy.fft.rfftn`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.rfftn`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'rfftn'
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
calling_func)
@@ -241,15 +284,15 @@ def irfftn(a, s=None, axes=None, overwrite_input=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform an n-D real inverse FFT.
-
- The first three arguments are as per :func:`numpy.fft.rfftn`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.rfftn`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
calling_func = 'irfftn'
-
+
return _Xfftn(a, s, axes, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
calling_func)
def hfft(a, n=None, axis=-1, overwrite_input=False,
@@ -259,21 +302,21 @@ def hfft(a, n=None, axis=-1, overwrite_input=False,
This yields a real output spectrum. See :func:`numpy.fft.hfft`
for more information.
- The first three arguments are as per :func:`numpy.fft.hfft`;
- the rest of the arguments are documented
+ The first three arguments are as per :func:`numpy.fft.hfft`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
- # The hermitian symmetric transform is equivalent to the
+ # The hermitian symmetric transform is equivalent to the
# irfft of the conjugate of the input (do the maths!) without
- # any normalisation of the result (so normalise_idft is set to
+ # any normalisation of the result (so normalise_idft is set to
# False).
a = numpy.conjugate(a)
calling_func = 'irfft'
return _Xfftn(a, n, axis, overwrite_input, planner_effort,
- threads, auto_align_input, auto_contiguous,
+ threads, auto_align_input, auto_contiguous,
calling_func, normalise_idft=False)
def ihfft(a, n=None, axis=-1, overwrite_input=False,
@@ -282,9 +325,9 @@ def ihfft(a, n=None, axis=-1, overwrite_input=False,
'''Perform a 1D inverse FFT of a real-spectrum, yielding
a signal with hermitian symmetry. See :func:`numpy.fft.ihfft`
for more information.
-
- The first three arguments are as per :func:`numpy.fft.ihfft`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`numpy.fft.ihfft`;
+ the rest of the arguments are documented
in the :ref:`additional arguments docs<interfaces_additional_args>`.
'''
@@ -302,4 +345,3 @@ def ihfft(a, n=None, axis=-1, overwrite_input=False,
return scaling * rfft(a, n, axis, overwrite_input, planner_effort,
threads, auto_align_input, auto_contiguous).conj()
-
diff --git a/pyfftw/interfaces/numpy_fft.rst b/pyfftw/interfaces/numpy_fft.rst
new file mode 100644
index 0000000..8923205
--- /dev/null
+++ b/pyfftw/interfaces/numpy_fft.rst
@@ -0,0 +1,5 @@
+:mod:`numpy.fft` interface
+==========================
+
+.. automodule:: pyfftw.interfaces.numpy_fft
+ :members: fft, ifft, fft2, ifft2, fftn, ifftn, rfft, irfft, rfft2, irfft2, rfftn, irfftn
diff --git a/pyfftw/interfaces/scipy_fftpack.py b/pyfftw/interfaces/scipy_fftpack.py
index 2406b9f..778c402 100644
--- a/pyfftw/interfaces/scipy_fftpack.py
+++ b/pyfftw/interfaces/scipy_fftpack.py
@@ -42,7 +42,7 @@ The exceptions raised by each of these functions are mostly as per their
equivalents in :mod:`scipy.fftpack`, though there are some corner cases in
which this may not be true.
-It is notable that unlike :mod:`scipy.fftpack`, these functions will
+It is notable that unlike :mod:`scipy.fftpack`, these functions will
generally return an output array with the same precision as the input
array, and the transform that is chosen is chosen based on the precision
of the input array. That is, if the input array is 32-bit floating point,
@@ -52,7 +52,7 @@ precision.
Some corner (mis)usages of :mod:`scipy.fftpack` may not transfer neatly.
For example, using :func:`scipy.fftpack.fft2` with a non 1D array and
-a 2D `shape` argument will return without exception whereas
+a 2D `shape` argument will return without exception whereas
:func:`pyfftw.interfaces.scipy_fftpack.fft2` will raise a `ValueError`.
'''
@@ -60,9 +60,9 @@ from . import numpy_fft
import numpy
# Complete the namespace (these are not actually used in this module)
-from scipy.fftpack import (dct, idct, diff, tilbert, itilbert,
- hilbert, ihilbert, cs_diff, sc_diff, ss_diff, cc_diff,
- shift, fftshift, ifftshift, fftfreq, rfftfreq,
+from scipy.fftpack import (dct, idct, diff, tilbert, itilbert,
+ hilbert, ihilbert, cs_diff, sc_diff, ss_diff, cc_diff,
+ shift, fftshift, ifftshift, fftfreq, rfftfreq,
convolve, _fftpack)
try:
@@ -70,71 +70,71 @@ try:
except ImportError:
pass
-__all__ = ['fft','ifft','fftn','ifftn','rfft','irfft', 'fft2','ifft2',
+__all__ = ['fft','ifft','fftn','ifftn','rfft','irfft', 'fft2','ifft2',
'diff', 'tilbert','itilbert','hilbert','ihilbert', 'sc_diff',
'cs_diff','cc_diff','ss_diff', 'shift', 'rfftfreq']
-def fft(x, n=None, axis=-1, overwrite_x=False,
+def fft(x, n=None, axis=-1, overwrite_x=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 1D FFT.
-
- The first three arguments are as per :func:`scipy.fftpack.fft`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`scipy.fftpack.fft`;
+ the rest of the arguments are documented
in the :ref:`additional argument docs<interfaces_additional_args>`.
'''
- return numpy_fft.fft(x, n, axis, overwrite_x, planner_effort,
+ return numpy_fft.fft(x, n, axis, None, overwrite_x, planner_effort,
threads, auto_align_input, auto_contiguous)
def ifft(x, n=None, axis=-1, overwrite_x=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 1D inverse FFT.
-
- The first three arguments are as per :func:`scipy.fftpack.ifft`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`scipy.fftpack.ifft`;
+ the rest of the arguments are documented
in the :ref:`additional argument docs<interfaces_additional_args>`.
'''
- return numpy_fft.ifft(x, n, axis, overwrite_x, planner_effort,
- threads, auto_align_input, auto_contiguous)
+ return numpy_fft.ifft(x, n, axis, None, overwrite_x,
+ planner_effort, threads, auto_align_input, auto_contiguous)
def fft2(x, shape=None, axes=(-2,-1), overwrite_x=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 2D FFT.
-
- The first three arguments are as per :func:`scipy.fftpack.fft2`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`scipy.fftpack.fft2`;
+ the rest of the arguments are documented
in the :ref:`additional argument docs<interfaces_additional_args>`.
'''
- return numpy_fft.fft2(x, shape, axes, overwrite_x, planner_effort,
- threads, auto_align_input, auto_contiguous)
+ return numpy_fft.fft2(x, shape, axes, None, overwrite_x,
+ planner_effort, threads, auto_align_input, auto_contiguous)
def ifft2(x, shape=None, axes=(-2,-1), overwrite_x=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 2D inverse FFT.
-
- The first three arguments are as per :func:`scipy.fftpack.ifft2`;
+
+ The first three arguments are as per :func:`scipy.fftpack.ifft2`;
the rest of the arguments are documented in the
:ref:`additional argument docs <interfaces_additional_args>`.
'''
- return numpy_fft.ifft2(x, shape, axes, overwrite_x, planner_effort,
- threads, auto_align_input, auto_contiguous)
+ return numpy_fft.ifft2(x, shape, axes, None, overwrite_x,
+ planner_effort, threads, auto_align_input, auto_contiguous)
def fftn(x, shape=None, axes=None, overwrite_x=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform an n-D FFT.
-
- The first three arguments are as per :func:`scipy.fftpack.fftn`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`scipy.fftpack.fftn`;
+ the rest of the arguments are documented
in the :ref:`additional argument docs<interfaces_additional_args>`.
'''
@@ -148,17 +148,17 @@ def fftn(x, shape=None, axes=None, overwrite_x=False,
'of axes if it is not. If this is problematic, consider '
'using the numpy interface.')
- return numpy_fft.fftn(x, shape, axes, overwrite_x, planner_effort,
- threads, auto_align_input, auto_contiguous)
+ return numpy_fft.fftn(x, shape, axes, None, overwrite_x,
+ planner_effort, threads, auto_align_input, auto_contiguous)
def ifftn(x, shape=None, axes=None, overwrite_x=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform an n-D inverse FFT.
-
- The first three arguments are as per :func:`scipy.fftpack.ifftn`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`scipy.fftpack.ifftn`;
+ the rest of the arguments are documented
in the :ref:`additional argument docs<interfaces_additional_args>`.
'''
@@ -172,11 +172,11 @@ def ifftn(x, shape=None, axes=None, overwrite_x=False,
'of axes if it is not. If this is problematic, consider '
'using the numpy interface.')
- return numpy_fft.ifftn(x, shape, axes, overwrite_x, planner_effort,
- threads, auto_align_input, auto_contiguous)
+ return numpy_fft.ifftn(x, shape, axes, None, overwrite_x,
+ planner_effort, threads, auto_align_input, auto_contiguous)
def _complex_to_rfft_output(complex_output, output_shape, axis):
- '''Convert the complex output from pyfftw to the real output expected
+ '''Convert the complex output from pyfftw to the real output expected
from :func:`scipy.fftpack.rfft`.
'''
@@ -249,9 +249,9 @@ def rfft(x, n=None, axis=-1, overwrite_x=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 1D real FFT.
-
- The first three arguments are as per :func:`scipy.fftpack.rfft`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`scipy.fftpack.rfft`;
+ the rest of the arguments are documented
in the :ref:`additional argument docs<interfaces_additional_args>`.
'''
if not numpy.isrealobj(x):
@@ -273,9 +273,9 @@ def irfft(x, n=None, axis=-1, overwrite_x=False,
planner_effort='FFTW_MEASURE', threads=1,
auto_align_input=True, auto_contiguous=True):
'''Perform a 1D real inverse FFT.
-
- The first three arguments are as per :func:`scipy.fftpack.irfft`;
- the rest of the arguments are documented
+
+ The first three arguments are as per :func:`scipy.fftpack.irfft`;
+ the rest of the arguments are documented
in the :ref:`additional argument docs<interfaces_additional_args>`.
'''
if not numpy.isrealobj(x):
@@ -289,6 +289,5 @@ def irfft(x, n=None, axis=-1, overwrite_x=False,
complex_input = _irfft_input_to_complex(x, axis)
- return numpy_fft.irfft(complex_input, n, axis, overwrite_x,
+ return numpy_fft.irfft(complex_input, n, axis, overwrite_x,
planner_effort, threads, auto_align_input, auto_contiguous)
-
diff --git a/pyfftw/interfaces/scipy_fftpack.rst b/pyfftw/interfaces/scipy_fftpack.rst
new file mode 100644
index 0000000..f8e53a6
--- /dev/null
+++ b/pyfftw/interfaces/scipy_fftpack.rst
@@ -0,0 +1,5 @@
+:mod:`scipy.fftpack` interface
+==============================
+
+.. automodule:: pyfftw.interfaces.scipy_fftpack
+ :members: fft, ifft, fftn, ifftn, rfft, irfft, fft2, ifft2
diff --git a/pyfftw/pyfftw.c b/pyfftw/pyfftw.c
index f1b9e09..5b90d16 100644
--- a/pyfftw/pyfftw.c
+++ b/pyfftw/pyfftw.c
@@ -995,6 +995,7 @@ struct __pyx_obj_6pyfftw_6pyfftw_FFTW {
PyObject *_output_dtype;
PyObject *_flags_used;
double _normalisation_scaling;
+ double _sqrt_normalisation_scaling;
int _rank;
__pyx_t_6pyfftw_6pyfftw__fftw_iodim *_dims;
int _howmany_rank;
@@ -1603,6 +1604,7 @@ static char __pyx_k_fill[] = "fill";
static char __pyx_k_int8[] = "int8";
static char __pyx_k_main[] = "__main__";
static char __pyx_k_real[] = "real";
+static char __pyx_k_sqrt[] = "sqrt";
static char __pyx_k_test[] = "__test__";
static char __pyx_k_type[] = "type";
static char __pyx_k_view[] = "view";
@@ -1616,6 +1618,7 @@ static char __pyx_k_flags[] = "flags";
static char __pyx_k_get_N[] = "_get_N";
static char __pyx_k_numpy[] = "numpy";
static char __pyx_k_order[] = "order";
+static char __pyx_k_ortho[] = "ortho";
static char __pyx_k_range[] = "range";
static char __pyx_k_shape[] = "shape";
static char __pyx_k_append[] = "append";
@@ -1742,6 +1745,7 @@ static char __pyx_k_Invalid_input_array_The_new_inpu[] = "Invalid input array: T
static char __pyx_k_Invalid_input_dtype_The_new_inpu[] = "Invalid input dtype: The new input array is not of the same dtype as was originally planned for.";
static char __pyx_k_Invalid_input_shape_The_new_inpu[] = "Invalid input shape: The new input array should be the same shape as the input array used to instantiate the object.";
static char __pyx_k_Invalid_input_striding_The_strid[] = "Invalid input striding: The strides should be identical for the new input array as for the old.";
+static char __pyx_k_Invalid_options_ortho_and_normal[] = "Invalid options: ortho and normalise_idft cannot both be True.";
static char __pyx_k_Invalid_output_alignment_The_ori[] = "Invalid output alignment: The original arrays were %d-byte aligned. It is necessary that the update output array is similarly aligned.";
static char __pyx_k_Invalid_output_alignment_The_out[] = "Invalid output alignment: The output array is expected to lie on a %d byte boundary.";
static char __pyx_k_Invalid_output_array_The_new_out[] = "Invalid output array The new output array needs to be an instance of numpy.ndarray";
@@ -1792,6 +1796,7 @@ static PyObject *__pyx_kp_s_Invalid_input_array_The_new_inpu;
static PyObject *__pyx_kp_s_Invalid_input_dtype_The_new_inpu;
static PyObject *__pyx_kp_s_Invalid_input_shape_The_new_inpu;
static PyObject *__pyx_kp_s_Invalid_input_striding_The_strid;
+static PyObject *__pyx_kp_s_Invalid_options_ortho_and_normal;
static PyObject *__pyx_kp_s_Invalid_output_alignment_The_ori;
static PyObject *__pyx_kp_s_Invalid_output_alignment_The_out;
static PyObject *__pyx_kp_s_Invalid_output_array_The_new_out;
@@ -1903,6 +1908,7 @@ static PyObject *__pyx_n_s_normalise_idft;
static PyObject *__pyx_n_s_np;
static PyObject *__pyx_n_s_numpy;
static PyObject *__pyx_n_s_order;
+static PyObject *__pyx_n_s_ortho;
static PyObject *__pyx_n_s_output_alignment;
static PyObject *__pyx_n_s_output_array;
static PyObject *__pyx_n_s_output_dtype;
@@ -1923,6 +1929,7 @@ static PyObject *__pyx_n_s_reshape;
static PyObject *__pyx_n_s_shape;
static PyObject *__pyx_n_s_simd_aligned;
static PyObject *__pyx_n_s_simd_alignment;
+static PyObject *__pyx_n_s_sqrt;
static PyObject *__pyx_n_s_strides;
static PyObject *__pyx_n_s_success;
static PyObject *__pyx_n_s_successf;
@@ -1969,7 +1976,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_28_get_axes(struct __pyx_obj_6py
static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6pyfftw_FFTW *__pyx_v_self, PyObject *__pyx_v_input_array, PyObject *__pyx_v_output_array, PyObject *__pyx_v_axes, PyObject *__pyx_v_direction, PyObject *__pyx_v_flags, unsigned int __pyx_v_threads, PyObject *__pyx_v_planning_timelimit, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */
static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_32__init__(CYTHON_UNUSED struct __pyx_obj_6pyfftw_6pyfftw_FFTW *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_input_array, CYTHON_UNUSED PyObject *__pyx_v_output_array, CYTHON_UNUSED PyObject *__pyx_v_axes, CYTHON_UNUSED PyObject *__pyx_v_direction, CYTHON_UNUSED PyObject *__pyx_v_flags, CYTHON_UNUSED int __pyx_v_threads, CYTHON_UNUSED PyObject *__pyx_v_planning_timelimit); /* proto */
static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfftw_6pyfftw_FFTW *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyfftw_6pyfftw_FFTW *__pyx_v_self, PyObject *__pyx_v_input_array, PyObject *__pyx_v_output_array, PyObject *__pyx_v_normalise_idft); /* proto */
+static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyfftw_6pyfftw_FFTW *__pyx_v_self, PyObject *__pyx_v_input_array, PyObject *__pyx_v_output_array, PyObject *__pyx_v_normalise_idft, PyObject *__pyx_v_ortho); /* proto */
static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_38update_arrays(struct __pyx_obj_6pyfftw_6pyfftw_FFTW *__pyx_v_self, PyObject *__pyx_v_new_input_array, PyObject *__pyx_v_new_output_array); /* proto */
static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_40get_input_array(struct __pyx_obj_6pyfftw_6pyfftw_FFTW *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_42get_output_array(struct __pyx_obj_6pyfftw_6pyfftw_FFTW *__pyx_v_self); /* proto */
@@ -2001,7 +2008,7 @@ static PyObject *__pyx_tuple__6;
static PyObject *__pyx_tuple__7;
static PyObject *__pyx_tuple__8;
static PyObject *__pyx_tuple__9;
-static PyObject *__pyx_slice__23;
+static PyObject *__pyx_slice__24;
static PyObject *__pyx_tuple__10;
static PyObject *__pyx_tuple__11;
static PyObject *__pyx_tuple__12;
@@ -2014,7 +2021,7 @@ static PyObject *__pyx_tuple__19;
static PyObject *__pyx_tuple__20;
static PyObject *__pyx_tuple__21;
static PyObject *__pyx_tuple__22;
-static PyObject *__pyx_tuple__24;
+static PyObject *__pyx_tuple__23;
static PyObject *__pyx_tuple__25;
static PyObject *__pyx_tuple__26;
static PyObject *__pyx_tuple__27;
@@ -2031,8 +2038,8 @@ static PyObject *__pyx_tuple__37;
static PyObject *__pyx_tuple__38;
static PyObject *__pyx_tuple__39;
static PyObject *__pyx_tuple__40;
-static PyObject *__pyx_tuple__42;
-static PyObject *__pyx_tuple__44;
+static PyObject *__pyx_tuple__41;
+static PyObject *__pyx_tuple__43;
static PyObject *__pyx_tuple__45;
static PyObject *__pyx_tuple__46;
static PyObject *__pyx_tuple__47;
@@ -2080,12 +2087,13 @@ static PyObject *__pyx_tuple__88;
static PyObject *__pyx_tuple__89;
static PyObject *__pyx_tuple__90;
static PyObject *__pyx_tuple__91;
-static PyObject *__pyx_tuple__93;
-static PyObject *__pyx_codeobj__41;
-static PyObject *__pyx_codeobj__43;
-static PyObject *__pyx_codeobj__92;
-static PyObject *__pyx_codeobj__94;
+static PyObject *__pyx_tuple__92;
+static PyObject *__pyx_tuple__94;
+static PyObject *__pyx_codeobj__42;
+static PyObject *__pyx_codeobj__44;
+static PyObject *__pyx_codeobj__93;
static PyObject *__pyx_codeobj__95;
+static PyObject *__pyx_codeobj__96;
/* "pyfftw/utils.pxi":59
* _valid_simd_alignments = ()
@@ -6411,7 +6419,7 @@ static void __pyx_f_6pyfftw_6pyfftw_make_axes_unique(int64_t *__pyx_v_axes, int6
__Pyx_RefNannyFinishContext();
}
-/* "pyfftw/pyfftw.pyx":667
+/* "pyfftw/pyfftw.pyx":668
*
* cdef int64_t _N
* def _get_N(self): # <<<<<<<<<<<<<<
@@ -6421,7 +6429,7 @@ static void __pyx_f_6pyfftw_6pyfftw_make_axes_unique(int64_t *__pyx_v_axes, int6
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_1_get_N(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW__get_N[] = "\n The product of the lengths of the DFT over all DFT axes.\n 1/N is the normalisation constant. For any input array A, \n and for any set of axes, 1/N * ifft(fft(A)) = A\n ";
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW__get_N[] = "\n The product of the lengths of the DFT over all DFT axes.\n 1/N is the normalisation constant. For any input array A,\n and for any set of axes, 1/N * ifft(fft(A)) = A\n ";
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_1_get_N(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
@@ -6442,7 +6450,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW__get_N(struct __pyx_obj_6pyfftw_
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_N", 0);
- /* "pyfftw/pyfftw.pyx":673
+ /* "pyfftw/pyfftw.pyx":674
* and for any set of axes, 1/N * ifft(fft(A)) = A
* '''
* return self._N # <<<<<<<<<<<<<<
@@ -6450,13 +6458,13 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW__get_N(struct __pyx_obj_6pyfftw_
* N = property(_get_N)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_self->_N); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_self->_N); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":667
+ /* "pyfftw/pyfftw.pyx":668
*
* cdef int64_t _N
* def _get_N(self): # <<<<<<<<<<<<<<
@@ -6475,7 +6483,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW__get_N(struct __pyx_obj_6pyfftw_
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":677
+/* "pyfftw/pyfftw.pyx":678
* N = property(_get_N)
*
* def _get_simd_aligned(self): # <<<<<<<<<<<<<<
@@ -6506,7 +6514,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_2_get_simd_aligned(struct __pyx_
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_simd_aligned", 0);
- /* "pyfftw/pyfftw.pyx":682
+ /* "pyfftw/pyfftw.pyx":683
* input and output data.
* '''
* return self._simd_allowed # <<<<<<<<<<<<<<
@@ -6514,13 +6522,13 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_2_get_simd_aligned(struct __pyx_
* simd_aligned = property(_get_simd_aligned)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_simd_allowed); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 682; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_simd_allowed); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":677
+ /* "pyfftw/pyfftw.pyx":678
* N = property(_get_N)
*
* def _get_simd_aligned(self): # <<<<<<<<<<<<<<
@@ -6539,7 +6547,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_2_get_simd_aligned(struct __pyx_
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":686
+/* "pyfftw/pyfftw.pyx":687
* simd_aligned = property(_get_simd_aligned)
*
* def _get_input_alignment(self): # <<<<<<<<<<<<<<
@@ -6549,7 +6557,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_2_get_simd_aligned(struct __pyx_
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_5_get_input_alignment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_4_get_input_alignment[] = "\n Returns the byte alignment of the input arrays for which the\n :class:`~pyfftw.FFTW` object was created.\n\n Input array updates with arrays that are not aligned on this\n byte boundary will result in a ValueError being raised, or\n a copy being made if the :meth:`~pyfftw.FFTW.__call__` \n interface is used.\n ";
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_4_get_input_alignment[] = "\n Returns the byte alignment of the input arrays for which the\n :class:`~pyfftw.FFTW` object was created.\n\n Input array updates with arrays that are not aligned on this\n byte boundary will result in a ValueError being raised, or\n a copy being made if the :meth:`~pyfftw.FFTW.__call__`\n interface is used.\n ";
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_5_get_input_alignment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
@@ -6570,7 +6578,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_4_get_input_alignment(struct __p
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_input_alignment", 0);
- /* "pyfftw/pyfftw.pyx":696
+ /* "pyfftw/pyfftw.pyx":697
* interface is used.
* '''
* return self._input_array_alignment # <<<<<<<<<<<<<<
@@ -6578,13 +6586,13 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_4_get_input_alignment(struct __p
* input_alignment = property(_get_input_alignment)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_input_array_alignment); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 696; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_input_array_alignment); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 697; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":686
+ /* "pyfftw/pyfftw.pyx":687
* simd_aligned = property(_get_simd_aligned)
*
* def _get_input_alignment(self): # <<<<<<<<<<<<<<
@@ -6603,7 +6611,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_4_get_input_alignment(struct __p
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":700
+/* "pyfftw/pyfftw.pyx":701
* input_alignment = property(_get_input_alignment)
*
* def _get_output_alignment(self): # <<<<<<<<<<<<<<
@@ -6634,7 +6642,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_6_get_output_alignment(struct __
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_output_alignment", 0);
- /* "pyfftw/pyfftw.pyx":708
+ /* "pyfftw/pyfftw.pyx":709
* byte boundary will result in a ValueError being raised.
* '''
* return self._output_array_alignment # <<<<<<<<<<<<<<
@@ -6642,13 +6650,13 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_6_get_output_alignment(struct __
* output_alignment = property(_get_output_alignment)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_output_array_alignment); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_output_array_alignment); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 709; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":700
+ /* "pyfftw/pyfftw.pyx":701
* input_alignment = property(_get_input_alignment)
*
* def _get_output_alignment(self): # <<<<<<<<<<<<<<
@@ -6667,7 +6675,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_6_get_output_alignment(struct __
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":712
+/* "pyfftw/pyfftw.pyx":713
* output_alignment = property(_get_output_alignment)
*
* def _get_flags_used(self): # <<<<<<<<<<<<<<
@@ -6677,7 +6685,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_6_get_output_alignment(struct __
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_9_get_flags_used(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_8_get_flags_used[] = "\n Return which flags were used to construct the FFTW object.\n \n This includes flags that were added during initialisation.\n ";
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_8_get_flags_used[] = "\n Return which flags were used to construct the FFTW object.\n\n This includes flags that were added during initialisation.\n ";
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_9_get_flags_used(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
@@ -6698,7 +6706,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_8_get_flags_used(struct __pyx_ob
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_flags_used", 0);
- /* "pyfftw/pyfftw.pyx":718
+ /* "pyfftw/pyfftw.pyx":719
* This includes flags that were added during initialisation.
* '''
* return tuple(self._flags_used) # <<<<<<<<<<<<<<
@@ -6706,13 +6714,13 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_8_get_flags_used(struct __pyx_ob
* flags = property(_get_flags_used)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PySequence_Tuple(__pyx_v_self->_flags_used); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 718; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_Tuple(__pyx_v_self->_flags_used); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":712
+ /* "pyfftw/pyfftw.pyx":713
* output_alignment = property(_get_output_alignment)
*
* def _get_flags_used(self): # <<<<<<<<<<<<<<
@@ -6731,7 +6739,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_8_get_flags_used(struct __pyx_ob
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":722
+/* "pyfftw/pyfftw.pyx":723
* flags = property(_get_flags_used)
*
* def _get_input_array(self): # <<<<<<<<<<<<<<
@@ -6741,7 +6749,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_8_get_flags_used(struct __pyx_ob
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_11_get_input_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_10_get_input_array[] = "\n Return the input array that is associated with the FFTW \n instance.\n ";
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_10_get_input_array[] = "\n Return the input array that is associated with the FFTW\n instance.\n ";
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_11_get_input_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
@@ -6758,7 +6766,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_10_get_input_array(struct __pyx_
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get_input_array", 0);
- /* "pyfftw/pyfftw.pyx":727
+ /* "pyfftw/pyfftw.pyx":728
* instance.
* '''
* return self._input_array # <<<<<<<<<<<<<<
@@ -6770,7 +6778,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_10_get_input_array(struct __pyx_
__pyx_r = ((PyObject *)__pyx_v_self->_input_array);
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":722
+ /* "pyfftw/pyfftw.pyx":723
* flags = property(_get_flags_used)
*
* def _get_input_array(self): # <<<<<<<<<<<<<<
@@ -6785,7 +6793,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_10_get_input_array(struct __pyx_
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":731
+/* "pyfftw/pyfftw.pyx":732
* input_array = property(_get_input_array)
*
* def _get_output_array(self): # <<<<<<<<<<<<<<
@@ -6795,7 +6803,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_10_get_input_array(struct __pyx_
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_13_get_output_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_12_get_output_array[] = "\n Return the output array that is associated with the FFTW \n instance.\n ";
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_12_get_output_array[] = "\n Return the output array that is associated with the FFTW\n instance.\n ";
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_13_get_output_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
@@ -6812,7 +6820,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_12_get_output_array(struct __pyx
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get_output_array", 0);
- /* "pyfftw/pyfftw.pyx":736
+ /* "pyfftw/pyfftw.pyx":737
* instance.
* '''
* return self._output_array # <<<<<<<<<<<<<<
@@ -6824,7 +6832,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_12_get_output_array(struct __pyx
__pyx_r = ((PyObject *)__pyx_v_self->_output_array);
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":731
+ /* "pyfftw/pyfftw.pyx":732
* input_array = property(_get_input_array)
*
* def _get_output_array(self): # <<<<<<<<<<<<<<
@@ -6839,7 +6847,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_12_get_output_array(struct __pyx
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":740
+/* "pyfftw/pyfftw.pyx":741
* output_array = property(_get_output_array)
*
* def _get_input_strides(self): # <<<<<<<<<<<<<<
@@ -6866,7 +6874,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_14_get_input_strides(struct __py
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get_input_strides", 0);
- /* "pyfftw/pyfftw.pyx":744
+ /* "pyfftw/pyfftw.pyx":745
* Return the strides of the input array for which the FFT is planned.
* '''
* return self._input_strides # <<<<<<<<<<<<<<
@@ -6878,7 +6886,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_14_get_input_strides(struct __py
__pyx_r = __pyx_v_self->_input_strides;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":740
+ /* "pyfftw/pyfftw.pyx":741
* output_array = property(_get_output_array)
*
* def _get_input_strides(self): # <<<<<<<<<<<<<<
@@ -6893,7 +6901,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_14_get_input_strides(struct __py
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":748
+/* "pyfftw/pyfftw.pyx":749
* input_strides = property(_get_input_strides)
*
* def _get_output_strides(self): # <<<<<<<<<<<<<<
@@ -6920,7 +6928,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_16_get_output_strides(struct __p
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get_output_strides", 0);
- /* "pyfftw/pyfftw.pyx":752
+ /* "pyfftw/pyfftw.pyx":753
* Return the strides of the output array for which the FFT is planned.
* '''
* return self._output_strides # <<<<<<<<<<<<<<
@@ -6932,7 +6940,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_16_get_output_strides(struct __p
__pyx_r = __pyx_v_self->_output_strides;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":748
+ /* "pyfftw/pyfftw.pyx":749
* input_strides = property(_get_input_strides)
*
* def _get_output_strides(self): # <<<<<<<<<<<<<<
@@ -6947,7 +6955,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_16_get_output_strides(struct __p
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":756
+/* "pyfftw/pyfftw.pyx":757
* output_strides = property(_get_output_strides)
*
* def _get_input_shape(self): # <<<<<<<<<<<<<<
@@ -6974,7 +6982,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_18_get_input_shape(struct __pyx_
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get_input_shape", 0);
- /* "pyfftw/pyfftw.pyx":760
+ /* "pyfftw/pyfftw.pyx":761
* Return the shape of the input array for which the FFT is planned.
* '''
* return self._input_shape # <<<<<<<<<<<<<<
@@ -6986,7 +6994,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_18_get_input_shape(struct __pyx_
__pyx_r = __pyx_v_self->_input_shape;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":756
+ /* "pyfftw/pyfftw.pyx":757
* output_strides = property(_get_output_strides)
*
* def _get_input_shape(self): # <<<<<<<<<<<<<<
@@ -7001,7 +7009,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_18_get_input_shape(struct __pyx_
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":764
+/* "pyfftw/pyfftw.pyx":765
* input_shape = property(_get_input_shape)
*
* def _get_output_shape(self): # <<<<<<<<<<<<<<
@@ -7028,7 +7036,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_20_get_output_shape(struct __pyx
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get_output_shape", 0);
- /* "pyfftw/pyfftw.pyx":768
+ /* "pyfftw/pyfftw.pyx":769
* Return the shape of the output array for which the FFT is planned.
* '''
* return self._output_shape # <<<<<<<<<<<<<<
@@ -7040,7 +7048,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_20_get_output_shape(struct __pyx
__pyx_r = __pyx_v_self->_output_shape;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":764
+ /* "pyfftw/pyfftw.pyx":765
* input_shape = property(_get_input_shape)
*
* def _get_output_shape(self): # <<<<<<<<<<<<<<
@@ -7055,7 +7063,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_20_get_output_shape(struct __pyx
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":772
+/* "pyfftw/pyfftw.pyx":773
* output_shape = property(_get_output_shape)
*
* def _get_input_dtype(self): # <<<<<<<<<<<<<<
@@ -7082,7 +7090,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_22_get_input_dtype(struct __pyx_
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get_input_dtype", 0);
- /* "pyfftw/pyfftw.pyx":776
+ /* "pyfftw/pyfftw.pyx":777
* Return the dtype of the input array for which the FFT is planned.
* '''
* return self._input_dtype # <<<<<<<<<<<<<<
@@ -7094,7 +7102,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_22_get_input_dtype(struct __pyx_
__pyx_r = __pyx_v_self->_input_dtype;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":772
+ /* "pyfftw/pyfftw.pyx":773
* output_shape = property(_get_output_shape)
*
* def _get_input_dtype(self): # <<<<<<<<<<<<<<
@@ -7109,7 +7117,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_22_get_input_dtype(struct __pyx_
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":780
+/* "pyfftw/pyfftw.pyx":781
* input_dtype = property(_get_input_dtype)
*
* def _get_output_dtype(self): # <<<<<<<<<<<<<<
@@ -7136,7 +7144,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_24_get_output_dtype(struct __pyx
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get_output_dtype", 0);
- /* "pyfftw/pyfftw.pyx":784
+ /* "pyfftw/pyfftw.pyx":785
* Return the shape of the output array for which the FFT is planned.
* '''
* return self._output_dtype # <<<<<<<<<<<<<<
@@ -7148,7 +7156,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_24_get_output_dtype(struct __pyx
__pyx_r = __pyx_v_self->_output_dtype;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":780
+ /* "pyfftw/pyfftw.pyx":781
* input_dtype = property(_get_input_dtype)
*
* def _get_output_dtype(self): # <<<<<<<<<<<<<<
@@ -7163,7 +7171,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_24_get_output_dtype(struct __pyx
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":788
+/* "pyfftw/pyfftw.pyx":789
* output_dtype = property(_get_output_dtype)
*
* def _get_direction(self): # <<<<<<<<<<<<<<
@@ -7173,7 +7181,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_24_get_output_dtype(struct __pyx
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_27_get_direction(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_26_get_direction[] = "\n Return the planned FFT direction. Either `'FFTW_FORWARD'` or \n `'FFTW_BACKWARD'`.\n ";
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_26_get_direction[] = "\n Return the planned FFT direction. Either `'FFTW_FORWARD'` or\n `'FFTW_BACKWARD'`.\n ";
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_27_get_direction(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
@@ -7194,7 +7202,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_26_get_direction(struct __pyx_ob
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_direction", 0);
- /* "pyfftw/pyfftw.pyx":793
+ /* "pyfftw/pyfftw.pyx":794
* `'FFTW_BACKWARD'`.
* '''
* return directions_lookup[self._direction] # <<<<<<<<<<<<<<
@@ -7202,13 +7210,13 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_26_get_direction(struct __pyx_ob
* direction = property(_get_direction)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_6pyfftw_6pyfftw_directions_lookup, __pyx_v_self->_direction, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 793; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_6pyfftw_6pyfftw_directions_lookup, __pyx_v_self->_direction, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":788
+ /* "pyfftw/pyfftw.pyx":789
* output_dtype = property(_get_output_dtype)
*
* def _get_direction(self): # <<<<<<<<<<<<<<
@@ -7227,7 +7235,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_26_get_direction(struct __pyx_ob
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":797
+/* "pyfftw/pyfftw.pyx":798
* direction = property(_get_direction)
*
* def _get_axes(self): # <<<<<<<<<<<<<<
@@ -7263,19 +7271,19 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_28_get_axes(struct __pyx_obj_6py
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_axes", 0);
- /* "pyfftw/pyfftw.pyx":803
+ /* "pyfftw/pyfftw.pyx":804
* is maintained.
* '''
* axes = [] # <<<<<<<<<<<<<<
* for i in range(self._rank):
* axes.append(self._axes[i])
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 804; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_axes = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":804
+ /* "pyfftw/pyfftw.pyx":805
* '''
* axes = []
* for i in range(self._rank): # <<<<<<<<<<<<<<
@@ -7286,20 +7294,20 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_28_get_axes(struct __pyx_obj_6py
for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
__pyx_v_i = __pyx_t_3;
- /* "pyfftw/pyfftw.pyx":805
+ /* "pyfftw/pyfftw.pyx":806
* axes = []
* for i in range(self._rank):
* axes.append(self._axes[i]) # <<<<<<<<<<<<<<
*
* return tuple(axes)
*/
- __pyx_t_1 = __Pyx_PyInt_From_int64_t((__pyx_v_self->_axes[__pyx_v_i])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 805; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t((__pyx_v_self->_axes[__pyx_v_i])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_axes, __pyx_t_1); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 805; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_axes, __pyx_t_1); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "pyfftw/pyfftw.pyx":807
+ /* "pyfftw/pyfftw.pyx":808
* axes.append(self._axes[i])
*
* return tuple(axes) # <<<<<<<<<<<<<<
@@ -7307,13 +7315,13 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_28_get_axes(struct __pyx_obj_6py
* axes = property(_get_axes)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyList_AsTuple(__pyx_v_axes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 807; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_AsTuple(__pyx_v_axes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 808; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":797
+ /* "pyfftw/pyfftw.pyx":798
* direction = property(_get_direction)
*
* def _get_axes(self): # <<<<<<<<<<<<<<
@@ -7333,7 +7341,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_28_get_axes(struct __pyx_obj_6py
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":811
+/* "pyfftw/pyfftw.pyx":812
* axes = property(_get_axes)
*
* def __cinit__(self, input_array, output_array, axes=(-1,), # <<<<<<<<<<<<<<
@@ -7378,7 +7386,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_31__cinit__(PyObject *__pyx_v_self, Py
values[2] = ((PyObject *)__pyx_tuple__6);
values[3] = ((PyObject *)__pyx_n_s_FFTW_FORWARD);
- /* "pyfftw/pyfftw.pyx":812
+ /* "pyfftw/pyfftw.pyx":813
*
* def __cinit__(self, input_array, output_array, axes=(-1,),
* direction='FFTW_FORWARD', flags=('FFTW_MEASURE',), # <<<<<<<<<<<<<<
@@ -7387,7 +7395,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_31__cinit__(PyObject *__pyx_v_self, Py
*/
values[4] = ((PyObject *)__pyx_tuple__7);
- /* "pyfftw/pyfftw.pyx":813
+ /* "pyfftw/pyfftw.pyx":814
* def __cinit__(self, input_array, output_array, axes=(-1,),
* direction='FFTW_FORWARD', flags=('FFTW_MEASURE',),
* unsigned int threads=1, planning_timelimit=None, # <<<<<<<<<<<<<<
@@ -7417,7 +7425,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_31__cinit__(PyObject *__pyx_v_self, Py
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_output_array)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 7, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 811; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 7, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 812; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
}
case 2:
if (kw_args > 0) {
@@ -7447,7 +7455,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_31__cinit__(PyObject *__pyx_v_self, Py
}
if (unlikely(kw_args > 0)) {
const Py_ssize_t used_pos_args = (pos_args < 7) ? pos_args : 7;
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 811; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 812; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -7471,7 +7479,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_31__cinit__(PyObject *__pyx_v_self, Py
__pyx_v_direction = values[3];
__pyx_v_flags = values[4];
if (values[5]) {
- __pyx_v_threads = __Pyx_PyInt_As_unsigned_int(values[5]); if (unlikely((__pyx_v_threads == (unsigned int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __pyx_v_threads = __Pyx_PyInt_As_unsigned_int(values[5]); if (unlikely((__pyx_v_threads == (unsigned int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 814; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
} else {
__pyx_v_threads = ((unsigned int)1);
}
@@ -7479,7 +7487,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_31__cinit__(PyObject *__pyx_v_self, Py
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 7, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 811; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 7, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 812; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
@@ -7489,7 +7497,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_31__cinit__(PyObject *__pyx_v_self, Py
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(((struct __pyx_obj_6pyfftw_6pyfftw_FFTW *)__pyx_v_self), __pyx_v_input_array, __pyx_v_output_array, __pyx_v_axes, __pyx_v_direction, __pyx_v_flags, __pyx_v_threads, __pyx_v_planning_timelimit, __pyx_v_args, __pyx_v_kwargs);
- /* "pyfftw/pyfftw.pyx":811
+ /* "pyfftw/pyfftw.pyx":812
* axes = property(_get_axes)
*
* def __cinit__(self, input_array, output_array, axes=(-1,), # <<<<<<<<<<<<<<
@@ -7557,8 +7565,8 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
intptr_t __pyx_t_15;
Py_ssize_t __pyx_t_16;
int64_t __pyx_t_17;
- unsigned int __pyx_t_18;
- PyObject *__pyx_t_19 = NULL;
+ PyObject *__pyx_t_18 = NULL;
+ unsigned int __pyx_t_19;
PyObject *__pyx_t_20 = NULL;
int __pyx_t_21;
int __pyx_t_22;
@@ -7571,7 +7579,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_RefNannySetupContext("__cinit__", 0);
__Pyx_INCREF(__pyx_v_flags);
- /* "pyfftw/pyfftw.pyx":817
+ /* "pyfftw/pyfftw.pyx":818
*
* # Initialise the pointers that need to be freed
* self._plan = NULL # <<<<<<<<<<<<<<
@@ -7580,7 +7588,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_plan = NULL;
- /* "pyfftw/pyfftw.pyx":818
+ /* "pyfftw/pyfftw.pyx":819
* # Initialise the pointers that need to be freed
* self._plan = NULL
* self._dims = NULL # <<<<<<<<<<<<<<
@@ -7589,7 +7597,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_dims = NULL;
- /* "pyfftw/pyfftw.pyx":819
+ /* "pyfftw/pyfftw.pyx":820
* self._plan = NULL
* self._dims = NULL
* self._howmany_dims = NULL # <<<<<<<<<<<<<<
@@ -7598,7 +7606,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_howmany_dims = NULL;
- /* "pyfftw/pyfftw.pyx":821
+ /* "pyfftw/pyfftw.pyx":822
* self._howmany_dims = NULL
*
* self._axes = NULL # <<<<<<<<<<<<<<
@@ -7607,7 +7615,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_axes = NULL;
- /* "pyfftw/pyfftw.pyx":822
+ /* "pyfftw/pyfftw.pyx":823
*
* self._axes = NULL
* self._not_axes = NULL # <<<<<<<<<<<<<<
@@ -7616,19 +7624,19 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_not_axes = NULL;
- /* "pyfftw/pyfftw.pyx":824
+ /* "pyfftw/pyfftw.pyx":825
* self._not_axes = NULL
*
* flags = list(flags) # <<<<<<<<<<<<<<
*
* cdef double _planning_timelimit
*/
- __pyx_t_1 = PySequence_List(__pyx_v_flags); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 824; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_List(__pyx_v_flags); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 825; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF_SET(__pyx_v_flags, __pyx_t_1);
__pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":827
+ /* "pyfftw/pyfftw.pyx":828
*
* cdef double _planning_timelimit
* if planning_timelimit is None: # <<<<<<<<<<<<<<
@@ -7639,7 +7647,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "pyfftw/pyfftw.pyx":828
+ /* "pyfftw/pyfftw.pyx":829
* cdef double _planning_timelimit
* if planning_timelimit is None:
* _planning_timelimit = FFTW_NO_TIMELIMIT # <<<<<<<<<<<<<<
@@ -7648,7 +7656,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v__planning_timelimit = FFTW_NO_TIMELIMIT;
- /* "pyfftw/pyfftw.pyx":827
+ /* "pyfftw/pyfftw.pyx":828
*
* cdef double _planning_timelimit
* if planning_timelimit is None: # <<<<<<<<<<<<<<
@@ -7658,7 +7666,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
goto __pyx_L3;
}
- /* "pyfftw/pyfftw.pyx":830
+ /* "pyfftw/pyfftw.pyx":831
* _planning_timelimit = FFTW_NO_TIMELIMIT
* else:
* try: # <<<<<<<<<<<<<<
@@ -7673,17 +7681,17 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_XGOTREF(__pyx_t_6);
/*try:*/ {
- /* "pyfftw/pyfftw.pyx":831
+ /* "pyfftw/pyfftw.pyx":832
* else:
* try:
* _planning_timelimit = planning_timelimit # <<<<<<<<<<<<<<
* except TypeError:
* raise TypeError('Invalid planning timelimit: '
*/
- __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_v_planning_timelimit); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L4_error;}
+ __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_v_planning_timelimit); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L4_error;}
__pyx_v__planning_timelimit = __pyx_t_7;
- /* "pyfftw/pyfftw.pyx":830
+ /* "pyfftw/pyfftw.pyx":831
* _planning_timelimit = FFTW_NO_TIMELIMIT
* else:
* try: # <<<<<<<<<<<<<<
@@ -7698,7 +7706,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_L4_error:;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":832
+ /* "pyfftw/pyfftw.pyx":833
* try:
* _planning_timelimit = planning_timelimit
* except TypeError: # <<<<<<<<<<<<<<
@@ -7708,28 +7716,28 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_8 = PyErr_ExceptionMatches(__pyx_builtin_TypeError);
if (__pyx_t_8) {
__Pyx_AddTraceback("pyfftw.pyfftw.FFTW.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_9, &__pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
+ if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_9, &__pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_t_10);
- /* "pyfftw/pyfftw.pyx":833
+ /* "pyfftw/pyfftw.pyx":834
* _planning_timelimit = planning_timelimit
* except TypeError:
* raise TypeError('Invalid planning timelimit: ' # <<<<<<<<<<<<<<
* 'The planning timelimit needs to be a float.')
*
*/
- __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
+ __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
__Pyx_GOTREF(__pyx_t_11);
__Pyx_Raise(__pyx_t_11, 0, 0, 0);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
- /* "pyfftw/pyfftw.pyx":830
+ /* "pyfftw/pyfftw.pyx":831
* _planning_timelimit = FFTW_NO_TIMELIMIT
* else:
* try: # <<<<<<<<<<<<<<
@@ -7746,7 +7754,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
}
__pyx_L3:;
- /* "pyfftw/pyfftw.pyx":836
+ /* "pyfftw/pyfftw.pyx":837
* 'The planning timelimit needs to be a float.')
*
* if not isinstance(input_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -7757,20 +7765,20 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":837
+ /* "pyfftw/pyfftw.pyx":838
*
* if not isinstance(input_array, np.ndarray):
* raise ValueError('Invalid input array: ' # <<<<<<<<<<<<<<
* 'The input array needs to be an instance '
* 'of numpy.ndarray')
*/
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":836
+ /* "pyfftw/pyfftw.pyx":837
* 'The planning timelimit needs to be a float.')
*
* if not isinstance(input_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -7779,7 +7787,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":841
+ /* "pyfftw/pyfftw.pyx":842
* 'of numpy.ndarray')
*
* if not isinstance(output_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -7790,20 +7798,20 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0);
if (__pyx_t_3) {
- /* "pyfftw/pyfftw.pyx":842
+ /* "pyfftw/pyfftw.pyx":843
*
* if not isinstance(output_array, np.ndarray):
* raise ValueError('Invalid output array: ' # <<<<<<<<<<<<<<
* 'The output array needs to be an instance '
* 'of numpy.ndarray')
*/
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":841
+ /* "pyfftw/pyfftw.pyx":842
* 'of numpy.ndarray')
*
* if not isinstance(output_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -7812,7 +7820,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":846
+ /* "pyfftw/pyfftw.pyx":847
* 'of numpy.ndarray')
*
* try: # <<<<<<<<<<<<<<
@@ -7826,38 +7834,38 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_XGOTREF(__pyx_t_4);
/*try:*/ {
- /* "pyfftw/pyfftw.pyx":847
+ /* "pyfftw/pyfftw.pyx":848
*
* try:
* input_dtype = input_array.dtype # <<<<<<<<<<<<<<
* output_dtype = output_array.dtype
* scheme = fftw_schemes[(input_dtype, output_dtype)]
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L16_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 848; __pyx_clineno = __LINE__; goto __pyx_L16_error;}
__Pyx_GOTREF(__pyx_t_10);
__pyx_v_input_dtype = __pyx_t_10;
__pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":848
+ /* "pyfftw/pyfftw.pyx":849
* try:
* input_dtype = input_array.dtype
* output_dtype = output_array.dtype # <<<<<<<<<<<<<<
* scheme = fftw_schemes[(input_dtype, output_dtype)]
* except KeyError:
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 848; __pyx_clineno = __LINE__; goto __pyx_L16_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L16_error;}
__Pyx_GOTREF(__pyx_t_10);
__pyx_v_output_dtype = __pyx_t_10;
__pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":849
+ /* "pyfftw/pyfftw.pyx":850
* input_dtype = input_array.dtype
* output_dtype = output_array.dtype
* scheme = fftw_schemes[(input_dtype, output_dtype)] # <<<<<<<<<<<<<<
* except KeyError:
* raise ValueError('Invalid scheme: '
*/
- __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L16_error;}
+ __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __pyx_L16_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_INCREF(__pyx_v_input_dtype);
__Pyx_GIVEREF(__pyx_v_input_dtype);
@@ -7865,13 +7873,13 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_INCREF(__pyx_v_output_dtype);
__Pyx_GIVEREF(__pyx_v_output_dtype);
PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_v_output_dtype);
- __pyx_t_9 = PyObject_GetItem(__pyx_v_6pyfftw_6pyfftw_fftw_schemes, __pyx_t_10); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L16_error;};
+ __pyx_t_9 = PyObject_GetItem(__pyx_v_6pyfftw_6pyfftw_fftw_schemes, __pyx_t_10); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __pyx_L16_error;};
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_v_scheme = __pyx_t_9;
__pyx_t_9 = 0;
- /* "pyfftw/pyfftw.pyx":846
+ /* "pyfftw/pyfftw.pyx":847
* 'of numpy.ndarray')
*
* try: # <<<<<<<<<<<<<<
@@ -7889,7 +7897,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
- /* "pyfftw/pyfftw.pyx":850
+ /* "pyfftw/pyfftw.pyx":851
* output_dtype = output_array.dtype
* scheme = fftw_schemes[(input_dtype, output_dtype)]
* except KeyError: # <<<<<<<<<<<<<<
@@ -7899,28 +7907,28 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_8 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_8) {
__Pyx_AddTraceback("pyfftw.pyfftw.FFTW.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __pyx_L18_except_error;}
+ if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 851; __pyx_clineno = __LINE__; goto __pyx_L18_except_error;}
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GOTREF(__pyx_t_1);
- /* "pyfftw/pyfftw.pyx":851
+ /* "pyfftw/pyfftw.pyx":852
* scheme = fftw_schemes[(input_dtype, output_dtype)]
* except KeyError:
* raise ValueError('Invalid scheme: ' # <<<<<<<<<<<<<<
* 'The output array and input array dtypes '
* 'do not correspond to a valid fftw scheme.')
*/
- __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 851; __pyx_clineno = __LINE__; goto __pyx_L18_except_error;}
+ __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L18_except_error;}
__Pyx_GOTREF(__pyx_t_11);
__Pyx_Raise(__pyx_t_11, 0, 0, 0);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 851; __pyx_clineno = __LINE__; goto __pyx_L18_except_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L18_except_error;}
}
goto __pyx_L18_except_error;
__pyx_L18_except_error:;
- /* "pyfftw/pyfftw.pyx":846
+ /* "pyfftw/pyfftw.pyx":847
* 'of numpy.ndarray')
*
* try: # <<<<<<<<<<<<<<
@@ -7935,7 +7943,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_L23_try_end:;
}
- /* "pyfftw/pyfftw.pyx":855
+ /* "pyfftw/pyfftw.pyx":856
* 'do not correspond to a valid fftw scheme.')
*
* self._input_dtype = input_dtype # <<<<<<<<<<<<<<
@@ -7948,7 +7956,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_DECREF(__pyx_v_self->_input_dtype);
__pyx_v_self->_input_dtype = __pyx_v_input_dtype;
- /* "pyfftw/pyfftw.pyx":856
+ /* "pyfftw/pyfftw.pyx":857
*
* self._input_dtype = input_dtype
* self._output_dtype = output_dtype # <<<<<<<<<<<<<<
@@ -7961,70 +7969,70 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_DECREF(__pyx_v_self->_output_dtype);
__pyx_v_self->_output_dtype = __pyx_v_output_dtype;
- /* "pyfftw/pyfftw.pyx":858
+ /* "pyfftw/pyfftw.pyx":859
* self._output_dtype = output_dtype
*
* functions = scheme_functions[scheme] # <<<<<<<<<<<<<<
*
* self._fftw_planner = planners[functions['planner']]
*/
- __pyx_t_1 = PyObject_GetItem(__pyx_v_6pyfftw_6pyfftw_scheme_functions, __pyx_v_scheme); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_6pyfftw_6pyfftw_scheme_functions, __pyx_v_scheme); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 859; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_functions = __pyx_t_1;
__pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":860
+ /* "pyfftw/pyfftw.pyx":861
* functions = scheme_functions[scheme]
*
* self._fftw_planner = planners[functions['planner']] # <<<<<<<<<<<<<<
* self._fftw_execute = executors[functions['executor']]
* self._fftw_destroy = destroyers[functions['generic_precision']]
*/
- __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_planner); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 860; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_planner); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 860; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_self->_fftw_planner = (__pyx_v_6pyfftw_6pyfftw_planners[__pyx_t_12]);
- /* "pyfftw/pyfftw.pyx":861
+ /* "pyfftw/pyfftw.pyx":862
*
* self._fftw_planner = planners[functions['planner']]
* self._fftw_execute = executors[functions['executor']] # <<<<<<<<<<<<<<
* self._fftw_destroy = destroyers[functions['generic_precision']]
*
*/
- __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_executor); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_executor); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 862; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 862; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_self->_fftw_execute = (__pyx_v_6pyfftw_6pyfftw_executors[__pyx_t_12]);
- /* "pyfftw/pyfftw.pyx":862
+ /* "pyfftw/pyfftw.pyx":863
* self._fftw_planner = planners[functions['planner']]
* self._fftw_execute = executors[functions['executor']]
* self._fftw_destroy = destroyers[functions['generic_precision']] # <<<<<<<<<<<<<<
*
* self._nthreads_plan_setter = (
*/
- __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_generic_precision); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 862; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_generic_precision); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 863; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 862; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 863; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_self->_fftw_destroy = (__pyx_v_6pyfftw_6pyfftw_destroyers[__pyx_t_12]);
- /* "pyfftw/pyfftw.pyx":865
+ /* "pyfftw/pyfftw.pyx":866
*
* self._nthreads_plan_setter = (
* nthreads_plan_setters[functions['generic_precision']]) # <<<<<<<<<<<<<<
*
* cdef fftw_generic_set_timelimit set_timelimit_func = (
*/
- __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_generic_precision); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 865; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_generic_precision); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 865; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":864
+ /* "pyfftw/pyfftw.pyx":865
* self._fftw_destroy = destroyers[functions['generic_precision']]
*
* self._nthreads_plan_setter = ( # <<<<<<<<<<<<<<
@@ -8033,69 +8041,69 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_nthreads_plan_setter = (__pyx_v_6pyfftw_6pyfftw_nthreads_plan_setters[__pyx_t_12]);
- /* "pyfftw/pyfftw.pyx":868
+ /* "pyfftw/pyfftw.pyx":869
*
* cdef fftw_generic_set_timelimit set_timelimit_func = (
* set_timelimit_funcs[functions['generic_precision']]) # <<<<<<<<<<<<<<
*
* # We're interested in the natural alignment on the real type, not
*/
- __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_generic_precision); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_generic_precision); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 869; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 869; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_set_timelimit_func = (__pyx_v_6pyfftw_6pyfftw_set_timelimit_funcs[__pyx_t_12]);
- /* "pyfftw/pyfftw.pyx":874
+ /* "pyfftw/pyfftw.pyx":875
* # numpy reported an alignment on a complex dtype that was different
* # to that on the real type.
* cdef int natural_input_alignment = input_array.real.dtype.alignment # <<<<<<<<<<<<<<
* cdef int natural_output_alignment = output_array.real.dtype.alignment
*
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_real); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 874; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_real); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 874; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_alignment); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 874; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_alignment); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 874; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_natural_input_alignment = __pyx_t_8;
- /* "pyfftw/pyfftw.pyx":875
+ /* "pyfftw/pyfftw.pyx":876
* # to that on the real type.
* cdef int natural_input_alignment = input_array.real.dtype.alignment
* cdef int natural_output_alignment = output_array.real.dtype.alignment # <<<<<<<<<<<<<<
*
* # If either of the arrays is not aligned on a 16-byte boundary,
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_real); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_real); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_alignment); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_alignment); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_natural_output_alignment = __pyx_t_8;
- /* "pyfftw/pyfftw.pyx":880
+ /* "pyfftw/pyfftw.pyx":881
* # we set the FFTW_UNALIGNED flag. This disables SIMD.
* # (16 bytes is assumed to be the minimal alignment)
* if 'FFTW_UNALIGNED' in flags: # <<<<<<<<<<<<<<
* self._simd_allowed = False
* self._input_array_alignment = natural_input_alignment
*/
- __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_FFTW_UNALIGNED, __pyx_v_flags, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 880; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_FFTW_UNALIGNED, __pyx_v_flags, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 881; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_t_2 = (__pyx_t_3 != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":881
+ /* "pyfftw/pyfftw.pyx":882
* # (16 bytes is assumed to be the minimal alignment)
* if 'FFTW_UNALIGNED' in flags:
* self._simd_allowed = False # <<<<<<<<<<<<<<
@@ -8104,7 +8112,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_simd_allowed = 0;
- /* "pyfftw/pyfftw.pyx":882
+ /* "pyfftw/pyfftw.pyx":883
* if 'FFTW_UNALIGNED' in flags:
* self._simd_allowed = False
* self._input_array_alignment = natural_input_alignment # <<<<<<<<<<<<<<
@@ -8113,7 +8121,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_input_array_alignment = __pyx_v_natural_input_alignment;
- /* "pyfftw/pyfftw.pyx":883
+ /* "pyfftw/pyfftw.pyx":884
* self._simd_allowed = False
* self._input_array_alignment = natural_input_alignment
* self._output_array_alignment = natural_output_alignment # <<<<<<<<<<<<<<
@@ -8122,7 +8130,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_output_array_alignment = __pyx_v_natural_output_alignment;
- /* "pyfftw/pyfftw.pyx":880
+ /* "pyfftw/pyfftw.pyx":881
* # we set the FFTW_UNALIGNED flag. This disables SIMD.
* # (16 bytes is assumed to be the minimal alignment)
* if 'FFTW_UNALIGNED' in flags: # <<<<<<<<<<<<<<
@@ -8132,7 +8140,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
goto __pyx_L26;
}
- /* "pyfftw/pyfftw.pyx":887
+ /* "pyfftw/pyfftw.pyx":888
* else:
*
* self._input_array_alignment = -1 # <<<<<<<<<<<<<<
@@ -8142,7 +8150,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
/*else*/ {
__pyx_v_self->_input_array_alignment = -1;
- /* "pyfftw/pyfftw.pyx":888
+ /* "pyfftw/pyfftw.pyx":889
*
* self._input_array_alignment = -1
* self._output_array_alignment = -1 # <<<<<<<<<<<<<<
@@ -8151,22 +8159,22 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_output_array_alignment = -1;
- /* "pyfftw/pyfftw.pyx":890
+ /* "pyfftw/pyfftw.pyx":891
* self._output_array_alignment = -1
*
* for each_alignment in _valid_simd_alignments: # <<<<<<<<<<<<<<
* if (<intptr_t>np.PyArray_DATA(input_array) %
* each_alignment == 0 and
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_valid_simd_alignments); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_valid_simd_alignments); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_10 = __pyx_t_1; __Pyx_INCREF(__pyx_t_10); __pyx_t_12 = 0;
__pyx_t_13 = NULL;
} else {
- __pyx_t_12 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_13 = Py_TYPE(__pyx_t_10)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = Py_TYPE(__pyx_t_10)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -8174,17 +8182,17 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
if (likely(PyList_CheckExact(__pyx_t_10))) {
if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_10)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_10)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -8194,7 +8202,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
break;
}
@@ -8203,31 +8211,31 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_XDECREF_SET(__pyx_v_each_alignment, __pyx_t_1);
__pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":891
+ /* "pyfftw/pyfftw.pyx":892
*
* for each_alignment in _valid_simd_alignments:
* if (<intptr_t>np.PyArray_DATA(input_array) % # <<<<<<<<<<<<<<
* each_alignment == 0 and
* <intptr_t>np.PyArray_DATA(output_array) %
*/
- if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_input_array)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_input_array)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- /* "pyfftw/pyfftw.pyx":892
+ /* "pyfftw/pyfftw.pyx":893
* for each_alignment in _valid_simd_alignments:
* if (<intptr_t>np.PyArray_DATA(input_array) %
* each_alignment == 0 and # <<<<<<<<<<<<<<
* <intptr_t>np.PyArray_DATA(output_array) %
* each_alignment == 0):
*/
- __pyx_t_9 = PyNumber_Remainder(__pyx_t_1, __pyx_v_each_alignment); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyNumber_Remainder(__pyx_t_1, __pyx_v_each_alignment); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_t_9, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_t_9, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
} else {
@@ -8235,36 +8243,36 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
goto __pyx_L30_bool_binop_done;
}
- /* "pyfftw/pyfftw.pyx":893
+ /* "pyfftw/pyfftw.pyx":894
* if (<intptr_t>np.PyArray_DATA(input_array) %
* each_alignment == 0 and
* <intptr_t>np.PyArray_DATA(output_array) % # <<<<<<<<<<<<<<
* each_alignment == 0):
*
*/
- if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_output_array)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_output_array)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- /* "pyfftw/pyfftw.pyx":894
+ /* "pyfftw/pyfftw.pyx":895
* each_alignment == 0 and
* <intptr_t>np.PyArray_DATA(output_array) %
* each_alignment == 0): # <<<<<<<<<<<<<<
*
* self._simd_allowed = True
*/
- __pyx_t_9 = PyNumber_Remainder(__pyx_t_1, __pyx_v_each_alignment); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyNumber_Remainder(__pyx_t_1, __pyx_v_each_alignment); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_t_9, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_t_9, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_2 = __pyx_t_3;
__pyx_L30_bool_binop_done:;
- /* "pyfftw/pyfftw.pyx":891
+ /* "pyfftw/pyfftw.pyx":892
*
* for each_alignment in _valid_simd_alignments:
* if (<intptr_t>np.PyArray_DATA(input_array) % # <<<<<<<<<<<<<<
@@ -8273,7 +8281,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":896
+ /* "pyfftw/pyfftw.pyx":897
* each_alignment == 0):
*
* self._simd_allowed = True # <<<<<<<<<<<<<<
@@ -8282,27 +8290,27 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_simd_allowed = 1;
- /* "pyfftw/pyfftw.pyx":898
+ /* "pyfftw/pyfftw.pyx":899
* self._simd_allowed = True
*
* self._input_array_alignment = each_alignment # <<<<<<<<<<<<<<
* self._output_array_alignment = each_alignment
*
*/
- __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_each_alignment); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 898; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_each_alignment); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 899; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_v_self->_input_array_alignment = __pyx_t_8;
- /* "pyfftw/pyfftw.pyx":899
+ /* "pyfftw/pyfftw.pyx":900
*
* self._input_array_alignment = each_alignment
* self._output_array_alignment = each_alignment # <<<<<<<<<<<<<<
*
* break
*/
- __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_each_alignment); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 899; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_each_alignment); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 900; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_v_self->_output_array_alignment = __pyx_t_8;
- /* "pyfftw/pyfftw.pyx":901
+ /* "pyfftw/pyfftw.pyx":902
* self._output_array_alignment = each_alignment
*
* break # <<<<<<<<<<<<<<
@@ -8311,7 +8319,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
goto __pyx_L28_break;
- /* "pyfftw/pyfftw.pyx":891
+ /* "pyfftw/pyfftw.pyx":892
*
* for each_alignment in _valid_simd_alignments:
* if (<intptr_t>np.PyArray_DATA(input_array) % # <<<<<<<<<<<<<<
@@ -8320,7 +8328,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":890
+ /* "pyfftw/pyfftw.pyx":891
* self._output_array_alignment = -1
*
* for each_alignment in _valid_simd_alignments: # <<<<<<<<<<<<<<
@@ -8331,7 +8339,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_L28_break:;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":903
+ /* "pyfftw/pyfftw.pyx":904
* break
*
* if (self._input_array_alignment == -1 or # <<<<<<<<<<<<<<
@@ -8345,7 +8353,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
goto __pyx_L33_bool_binop_done;
}
- /* "pyfftw/pyfftw.pyx":904
+ /* "pyfftw/pyfftw.pyx":905
*
* if (self._input_array_alignment == -1 or
* self._output_array_alignment == -1): # <<<<<<<<<<<<<<
@@ -8356,7 +8364,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_2 = __pyx_t_3;
__pyx_L33_bool_binop_done:;
- /* "pyfftw/pyfftw.pyx":903
+ /* "pyfftw/pyfftw.pyx":904
* break
*
* if (self._input_array_alignment == -1 or # <<<<<<<<<<<<<<
@@ -8365,7 +8373,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":906
+ /* "pyfftw/pyfftw.pyx":907
* self._output_array_alignment == -1):
*
* self._simd_allowed = False # <<<<<<<<<<<<<<
@@ -8374,7 +8382,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_simd_allowed = 0;
- /* "pyfftw/pyfftw.pyx":908
+ /* "pyfftw/pyfftw.pyx":909
* self._simd_allowed = False
*
* self._input_array_alignment = ( # <<<<<<<<<<<<<<
@@ -8383,7 +8391,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_input_array_alignment = __pyx_v_natural_input_alignment;
- /* "pyfftw/pyfftw.pyx":910
+ /* "pyfftw/pyfftw.pyx":911
* self._input_array_alignment = (
* natural_input_alignment)
* self._output_array_alignment = ( # <<<<<<<<<<<<<<
@@ -8392,16 +8400,16 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_output_array_alignment = __pyx_v_natural_output_alignment;
- /* "pyfftw/pyfftw.pyx":912
+ /* "pyfftw/pyfftw.pyx":913
* self._output_array_alignment = (
* natural_output_alignment)
* flags.append('FFTW_UNALIGNED') # <<<<<<<<<<<<<<
*
* if (not (<intptr_t>np.PyArray_DATA(input_array)
*/
- __pyx_t_14 = __Pyx_PyObject_Append(__pyx_v_flags, __pyx_n_s_FFTW_UNALIGNED); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 912; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_Append(__pyx_v_flags, __pyx_n_s_FFTW_UNALIGNED); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 913; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":903
+ /* "pyfftw/pyfftw.pyx":904
* break
*
* if (self._input_array_alignment == -1 or # <<<<<<<<<<<<<<
@@ -8412,17 +8420,17 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
}
__pyx_L26:;
- /* "pyfftw/pyfftw.pyx":914
+ /* "pyfftw/pyfftw.pyx":915
* flags.append('FFTW_UNALIGNED')
*
* if (not (<intptr_t>np.PyArray_DATA(input_array) # <<<<<<<<<<<<<<
* % self._input_array_alignment == 0)):
* raise ValueError('Invalid input alignment: '
*/
- if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 915; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_t_15 = ((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_input_array)));
- /* "pyfftw/pyfftw.pyx":915
+ /* "pyfftw/pyfftw.pyx":916
*
* if (not (<intptr_t>np.PyArray_DATA(input_array)
* % self._input_array_alignment == 0)): # <<<<<<<<<<<<<<
@@ -8431,10 +8439,10 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
if (unlikely(__pyx_v_self->_input_array_alignment == 0)) {
PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 915; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 916; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
- /* "pyfftw/pyfftw.pyx":914
+ /* "pyfftw/pyfftw.pyx":915
* flags.append('FFTW_UNALIGNED')
*
* if (not (<intptr_t>np.PyArray_DATA(input_array) # <<<<<<<<<<<<<<
@@ -8444,39 +8452,39 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_2 = ((!((__Pyx_mod_intptr_t(__pyx_t_15, __pyx_v_self->_input_array_alignment) == 0) != 0)) != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":918
+ /* "pyfftw/pyfftw.pyx":919
* raise ValueError('Invalid input alignment: '
* 'The input array is expected to lie on a %d '
* 'byte boundary.' % self._input_array_alignment) # <<<<<<<<<<<<<<
*
* if (not (<intptr_t>np.PyArray_DATA(output_array)
*/
- __pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_self->_input_array_alignment); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 918; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_self->_input_array_alignment); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_input_alignment_The_inpu, __pyx_t_10); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 918; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_input_alignment_The_inpu, __pyx_t_10); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":916
+ /* "pyfftw/pyfftw.pyx":917
* if (not (<intptr_t>np.PyArray_DATA(input_array)
* % self._input_array_alignment == 0)):
* raise ValueError('Invalid input alignment: ' # <<<<<<<<<<<<<<
* 'The input array is expected to lie on a %d '
* 'byte boundary.' % self._input_array_alignment)
*/
- __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 916; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 916; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 916; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":914
+ /* "pyfftw/pyfftw.pyx":915
* flags.append('FFTW_UNALIGNED')
*
* if (not (<intptr_t>np.PyArray_DATA(input_array) # <<<<<<<<<<<<<<
@@ -8485,17 +8493,17 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":920
+ /* "pyfftw/pyfftw.pyx":921
* 'byte boundary.' % self._input_array_alignment)
*
* if (not (<intptr_t>np.PyArray_DATA(output_array) # <<<<<<<<<<<<<<
* % self._output_array_alignment == 0)):
* raise ValueError('Invalid output alignment: '
*/
- if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 921; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_t_15 = ((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_output_array)));
- /* "pyfftw/pyfftw.pyx":921
+ /* "pyfftw/pyfftw.pyx":922
*
* if (not (<intptr_t>np.PyArray_DATA(output_array)
* % self._output_array_alignment == 0)): # <<<<<<<<<<<<<<
@@ -8504,10 +8512,10 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
if (unlikely(__pyx_v_self->_output_array_alignment == 0)) {
PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 921; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
- /* "pyfftw/pyfftw.pyx":920
+ /* "pyfftw/pyfftw.pyx":921
* 'byte boundary.' % self._input_array_alignment)
*
* if (not (<intptr_t>np.PyArray_DATA(output_array) # <<<<<<<<<<<<<<
@@ -8517,39 +8525,39 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_2 = ((!((__Pyx_mod_intptr_t(__pyx_t_15, __pyx_v_self->_output_array_alignment) == 0) != 0)) != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":924
+ /* "pyfftw/pyfftw.pyx":925
* raise ValueError('Invalid output alignment: '
* 'The output array is expected to lie on a %d '
* 'byte boundary.' % self._output_array_alignment) # <<<<<<<<<<<<<<
*
* if not direction in scheme_directions[scheme]:
*/
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_output_array_alignment); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 924; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_output_array_alignment); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 925; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_output_alignment_The_out, __pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 924; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_output_alignment_The_out, __pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 925; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":922
+ /* "pyfftw/pyfftw.pyx":923
* if (not (<intptr_t>np.PyArray_DATA(output_array)
* % self._output_array_alignment == 0)):
* raise ValueError('Invalid output alignment: ' # <<<<<<<<<<<<<<
* 'The output array is expected to lie on a %d '
* 'byte boundary.' % self._output_array_alignment)
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_10);
__pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":920
+ /* "pyfftw/pyfftw.pyx":921
* 'byte boundary.' % self._input_array_alignment)
*
* if (not (<intptr_t>np.PyArray_DATA(output_array) # <<<<<<<<<<<<<<
@@ -8558,34 +8566,34 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":926
+ /* "pyfftw/pyfftw.pyx":927
* 'byte boundary.' % self._output_array_alignment)
*
* if not direction in scheme_directions[scheme]: # <<<<<<<<<<<<<<
* raise ValueError('Invalid direction: '
* 'The direction is not valid for the scheme. '
*/
- __pyx_t_10 = PyObject_GetItem(__pyx_v_6pyfftw_6pyfftw_scheme_directions, __pyx_v_scheme); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_10 = PyObject_GetItem(__pyx_v_6pyfftw_6pyfftw_scheme_directions, __pyx_v_scheme); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 927; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_direction, __pyx_t_10, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_direction, __pyx_t_10, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 927; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "pyfftw/pyfftw.pyx":927
+ /* "pyfftw/pyfftw.pyx":928
*
* if not direction in scheme_directions[scheme]:
* raise ValueError('Invalid direction: ' # <<<<<<<<<<<<<<
* 'The direction is not valid for the scheme. '
* 'Try setting it explicitly if it is not already.')
*/
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 927; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 928; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 927; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 928; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":926
+ /* "pyfftw/pyfftw.pyx":927
* 'byte boundary.' % self._output_array_alignment)
*
* if not direction in scheme_directions[scheme]: # <<<<<<<<<<<<<<
@@ -8594,27 +8602,27 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":931
+ /* "pyfftw/pyfftw.pyx":932
* 'Try setting it explicitly if it is not already.')
*
* self._direction = directions[direction] # <<<<<<<<<<<<<<
* self._input_shape = input_array.shape
* self._output_shape = output_array.shape
*/
- __pyx_t_10 = PyObject_GetItem(__pyx_v_6pyfftw_6pyfftw_directions, __pyx_v_direction); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 931; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_10 = PyObject_GetItem(__pyx_v_6pyfftw_6pyfftw_directions, __pyx_v_direction); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 932; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 931; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 932; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_v_self->_direction = __pyx_t_8;
- /* "pyfftw/pyfftw.pyx":932
+ /* "pyfftw/pyfftw.pyx":933
*
* self._direction = directions[direction]
* self._input_shape = input_array.shape # <<<<<<<<<<<<<<
* self._output_shape = output_array.shape
*
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 932; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_10);
__Pyx_GOTREF(__pyx_v_self->_input_shape);
@@ -8622,14 +8630,14 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_v_self->_input_shape = __pyx_t_10;
__pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":933
+ /* "pyfftw/pyfftw.pyx":934
* self._direction = directions[direction]
* self._input_shape = input_array.shape
* self._output_shape = output_array.shape # <<<<<<<<<<<<<<
*
* self._input_array = input_array
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 934; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_10);
__Pyx_GOTREF(__pyx_v_self->_output_shape);
@@ -8637,14 +8645,14 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_v_self->_output_shape = __pyx_t_10;
__pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":935
+ /* "pyfftw/pyfftw.pyx":936
* self._output_shape = output_array.shape
*
* self._input_array = input_array # <<<<<<<<<<<<<<
* self._output_array = output_array
*
*/
- if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 935; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 936; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_t_10 = __pyx_v_input_array;
__Pyx_INCREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_10);
@@ -8653,14 +8661,14 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_v_self->_input_array = ((PyArrayObject *)__pyx_t_10);
__pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":936
+ /* "pyfftw/pyfftw.pyx":937
*
* self._input_array = input_array
* self._output_array = output_array # <<<<<<<<<<<<<<
*
* self._axes = <int64_t *>malloc(len(axes)*sizeof(int64_t))
*/
- if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 936; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 937; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_t_10 = __pyx_v_output_array;
__Pyx_INCREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_10);
@@ -8669,42 +8677,42 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_v_self->_output_array = ((PyArrayObject *)__pyx_t_10);
__pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":938
+ /* "pyfftw/pyfftw.pyx":939
* self._output_array = output_array
*
* self._axes = <int64_t *>malloc(len(axes)*sizeof(int64_t)) # <<<<<<<<<<<<<<
* for n in range(len(axes)):
* self._axes[n] = axes[n]
*/
- __pyx_t_12 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 938; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 939; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_v_self->_axes = ((int64_t *)malloc((__pyx_t_12 * (sizeof(int64_t)))));
- /* "pyfftw/pyfftw.pyx":939
+ /* "pyfftw/pyfftw.pyx":940
*
* self._axes = <int64_t *>malloc(len(axes)*sizeof(int64_t))
* for n in range(len(axes)): # <<<<<<<<<<<<<<
* self._axes[n] = axes[n]
*
*/
- __pyx_t_12 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 939; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 940; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_12; __pyx_t_16+=1) {
__pyx_v_n = __pyx_t_16;
- /* "pyfftw/pyfftw.pyx":940
+ /* "pyfftw/pyfftw.pyx":941
* self._axes = <int64_t *>malloc(len(axes)*sizeof(int64_t))
* for n in range(len(axes)):
* self._axes[n] = axes[n] # <<<<<<<<<<<<<<
*
* # Set the negative entries to their actual index (use the size
*/
- __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_axes, __pyx_v_n, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 940; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_axes, __pyx_v_n, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_17 = __Pyx_PyInt_As_int64_t(__pyx_t_10); if (unlikely((__pyx_t_17 == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 940; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_17 = __Pyx_PyInt_As_int64_t(__pyx_t_10); if (unlikely((__pyx_t_17 == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
(__pyx_v_self->_axes[__pyx_v_n]) = __pyx_t_17;
}
- /* "pyfftw/pyfftw.pyx":944
+ /* "pyfftw/pyfftw.pyx":945
* # Set the negative entries to their actual index (use the size
* # of the shape array for this)
* cdef int64_t array_dimension = len(self._input_shape) # <<<<<<<<<<<<<<
@@ -8713,22 +8721,22 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_t_10 = __pyx_v_self->_input_shape;
__Pyx_INCREF(__pyx_t_10);
- __pyx_t_12 = PyObject_Length(__pyx_t_10); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 944; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyObject_Length(__pyx_t_10); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_v_array_dimension = __pyx_t_12;
- /* "pyfftw/pyfftw.pyx":946
+ /* "pyfftw/pyfftw.pyx":947
* cdef int64_t array_dimension = len(self._input_shape)
*
* for n in range(len(axes)): # <<<<<<<<<<<<<<
* if self._axes[n] < 0:
* self._axes[n] = self._axes[n] + array_dimension
*/
- __pyx_t_12 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 946; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 947; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_12; __pyx_t_16+=1) {
__pyx_v_n = __pyx_t_16;
- /* "pyfftw/pyfftw.pyx":947
+ /* "pyfftw/pyfftw.pyx":948
*
* for n in range(len(axes)):
* if self._axes[n] < 0: # <<<<<<<<<<<<<<
@@ -8738,7 +8746,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_3 = (((__pyx_v_self->_axes[__pyx_v_n]) < 0) != 0);
if (__pyx_t_3) {
- /* "pyfftw/pyfftw.pyx":948
+ /* "pyfftw/pyfftw.pyx":949
* for n in range(len(axes)):
* if self._axes[n] < 0:
* self._axes[n] = self._axes[n] + array_dimension # <<<<<<<<<<<<<<
@@ -8747,7 +8755,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
(__pyx_v_self->_axes[__pyx_v_n]) = ((__pyx_v_self->_axes[__pyx_v_n]) + __pyx_v_array_dimension);
- /* "pyfftw/pyfftw.pyx":947
+ /* "pyfftw/pyfftw.pyx":948
*
* for n in range(len(axes)):
* if self._axes[n] < 0: # <<<<<<<<<<<<<<
@@ -8756,7 +8764,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":950
+ /* "pyfftw/pyfftw.pyx":951
* self._axes[n] = self._axes[n] + array_dimension
*
* if self._axes[n] >= array_dimension or self._axes[n] < 0: # <<<<<<<<<<<<<<
@@ -8774,20 +8782,20 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_L44_bool_binop_done:;
if (__pyx_t_3) {
- /* "pyfftw/pyfftw.pyx":951
+ /* "pyfftw/pyfftw.pyx":952
*
* if self._axes[n] >= array_dimension or self._axes[n] < 0:
* raise IndexError('Invalid axes: ' # <<<<<<<<<<<<<<
* 'The axes list cannot contain invalid axes.')
*
*/
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 951; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 952; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 951; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 952; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":950
+ /* "pyfftw/pyfftw.pyx":951
* self._axes[n] = self._axes[n] + array_dimension
*
* if self._axes[n] >= array_dimension or self._axes[n] < 0: # <<<<<<<<<<<<<<
@@ -8797,16 +8805,16 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
}
}
- /* "pyfftw/pyfftw.pyx":958
+ /* "pyfftw/pyfftw.pyx":959
* cdef int64_t *not_axes
*
* make_axes_unique(self._axes, len(axes), &unique_axes, # <<<<<<<<<<<<<<
* ¬_axes, array_dimension, &unique_axes_length)
*
*/
- __pyx_t_12 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 958; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":959
+ /* "pyfftw/pyfftw.pyx":960
*
* make_axes_unique(self._axes, len(axes), &unique_axes,
* ¬_axes, array_dimension, &unique_axes_length) # <<<<<<<<<<<<<<
@@ -8815,7 +8823,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_f_6pyfftw_6pyfftw_make_axes_unique(__pyx_v_self->_axes, __pyx_t_12, (&__pyx_v_unique_axes), (&__pyx_v_not_axes), __pyx_v_array_dimension, (&__pyx_v_unique_axes_length));
- /* "pyfftw/pyfftw.pyx":962
+ /* "pyfftw/pyfftw.pyx":963
*
* # and assign axes and not_axes to the filled arrays
* free(self._axes) # <<<<<<<<<<<<<<
@@ -8824,7 +8832,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
free(__pyx_v_self->_axes);
- /* "pyfftw/pyfftw.pyx":963
+ /* "pyfftw/pyfftw.pyx":964
* # and assign axes and not_axes to the filled arrays
* free(self._axes)
* self._axes = unique_axes # <<<<<<<<<<<<<<
@@ -8833,7 +8841,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_axes = __pyx_v_unique_axes;
- /* "pyfftw/pyfftw.pyx":964
+ /* "pyfftw/pyfftw.pyx":965
* free(self._axes)
* self._axes = unique_axes
* self._not_axes = not_axes # <<<<<<<<<<<<<<
@@ -8842,7 +8850,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_not_axes = __pyx_v_not_axes;
- /* "pyfftw/pyfftw.pyx":966
+ /* "pyfftw/pyfftw.pyx":967
* self._not_axes = not_axes
*
* total_N = 1 # <<<<<<<<<<<<<<
@@ -8852,7 +8860,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_INCREF(__pyx_int_1);
__pyx_v_total_N = __pyx_int_1;
- /* "pyfftw/pyfftw.pyx":967
+ /* "pyfftw/pyfftw.pyx":968
*
* total_N = 1
* for n in range(unique_axes_length): # <<<<<<<<<<<<<<
@@ -8863,36 +8871,36 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_17; __pyx_t_12+=1) {
__pyx_v_n = __pyx_t_12;
- /* "pyfftw/pyfftw.pyx":968
+ /* "pyfftw/pyfftw.pyx":969
* total_N = 1
* for n in range(unique_axes_length):
* if self._input_shape[self._axes[n]] == 0: # <<<<<<<<<<<<<<
* raise ValueError('Zero length array: '
* 'The input array should have no zero length'
*/
- __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_self->_input_shape, (__pyx_v_self->_axes[__pyx_v_n]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 968; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_self->_input_shape, (__pyx_v_self->_axes[__pyx_v_n]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 969; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_t_10, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 968; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_t_10, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 969; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 968; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 969; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
- /* "pyfftw/pyfftw.pyx":969
+ /* "pyfftw/pyfftw.pyx":970
* for n in range(unique_axes_length):
* if self._input_shape[self._axes[n]] == 0:
* raise ValueError('Zero length array: ' # <<<<<<<<<<<<<<
* 'The input array should have no zero length'
* 'axes over which the FFT is to be taken')
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 969; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 969; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":968
+ /* "pyfftw/pyfftw.pyx":969
* total_N = 1
* for n in range(unique_axes_length):
* if self._input_shape[self._axes[n]] == 0: # <<<<<<<<<<<<<<
@@ -8901,7 +8909,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":973
+ /* "pyfftw/pyfftw.pyx":974
* 'axes over which the FFT is to be taken')
*
* if self._direction == FFTW_FORWARD: # <<<<<<<<<<<<<<
@@ -8911,22 +8919,22 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_3 = ((__pyx_v_self->_direction == __pyx_e_6pyfftw_6pyfftw_FFTW_FORWARD) != 0);
if (__pyx_t_3) {
- /* "pyfftw/pyfftw.pyx":974
+ /* "pyfftw/pyfftw.pyx":975
*
* if self._direction == FFTW_FORWARD:
* total_N *= self._input_shape[self._axes[n]] # <<<<<<<<<<<<<<
* else:
* total_N *= self._output_shape[self._axes[n]]
*/
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_self->_input_shape, (__pyx_v_self->_axes[__pyx_v_n]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_self->_input_shape, (__pyx_v_self->_axes[__pyx_v_n]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 975; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = PyNumber_InPlaceMultiply(__pyx_v_total_N, __pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyNumber_InPlaceMultiply(__pyx_v_total_N, __pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 975; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF_SET(__pyx_v_total_N, __pyx_t_10);
__pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":973
+ /* "pyfftw/pyfftw.pyx":974
* 'axes over which the FFT is to be taken')
*
* if self._direction == FFTW_FORWARD: # <<<<<<<<<<<<<<
@@ -8936,7 +8944,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
goto __pyx_L49;
}
- /* "pyfftw/pyfftw.pyx":976
+ /* "pyfftw/pyfftw.pyx":977
* total_N *= self._input_shape[self._axes[n]]
* else:
* total_N *= self._output_shape[self._axes[n]] # <<<<<<<<<<<<<<
@@ -8944,9 +8952,9 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
* self._N = total_N
*/
/*else*/ {
- __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_self->_output_shape, (__pyx_v_self->_axes[__pyx_v_n]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 976; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_self->_output_shape, (__pyx_v_self->_axes[__pyx_v_n]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 977; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_1 = PyNumber_InPlaceMultiply(__pyx_v_total_N, __pyx_t_10); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 976; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_InPlaceMultiply(__pyx_v_total_N, __pyx_t_10); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF_SET(__pyx_v_total_N, __pyx_t_1);
@@ -8955,82 +8963,126 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_L49:;
}
- /* "pyfftw/pyfftw.pyx":978
+ /* "pyfftw/pyfftw.pyx":979
* total_N *= self._output_shape[self._axes[n]]
*
* self._N = total_N # <<<<<<<<<<<<<<
* self._normalisation_scaling = 1/float(self.N)
- *
+ * self._sqrt_normalisation_scaling = np.sqrt(self._normalisation_scaling)
*/
- __pyx_t_17 = __Pyx_PyInt_As_int64_t(__pyx_v_total_N); if (unlikely((__pyx_t_17 == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 978; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_17 = __Pyx_PyInt_As_int64_t(__pyx_v_total_N); if (unlikely((__pyx_t_17 == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_v_self->_N = __pyx_t_17;
- /* "pyfftw/pyfftw.pyx":979
+ /* "pyfftw/pyfftw.pyx":980
*
* self._N = total_N
* self._normalisation_scaling = 1/float(self.N) # <<<<<<<<<<<<<<
+ * self._sqrt_normalisation_scaling = np.sqrt(self._normalisation_scaling)
*
- * # Now we can validate the array shapes
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_N); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_N); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyObject_AsDouble(__pyx_t_1); if (unlikely(__pyx_t_7 == ((double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_AsDouble(__pyx_t_1); if (unlikely(__pyx_t_7 == ((double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (unlikely(__pyx_t_7 == 0)) {
PyErr_SetString(PyExc_ZeroDivisionError, "float division");
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
__pyx_v_self->_normalisation_scaling = (1.0 / __pyx_t_7);
- /* "pyfftw/pyfftw.pyx":984
+ /* "pyfftw/pyfftw.pyx":981
+ * self._N = total_N
+ * self._normalisation_scaling = 1/float(self.N)
+ * self._sqrt_normalisation_scaling = np.sqrt(self._normalisation_scaling) # <<<<<<<<<<<<<<
+ *
+ * # Now we can validate the array shapes
+ */
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ __pyx_t_10 = PyFloat_FromDouble(__pyx_v_self->_normalisation_scaling); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_11 = NULL;
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_9))) {
+ __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_9);
+ if (likely(__pyx_t_11)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+ __Pyx_INCREF(__pyx_t_11);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_9, function);
+ }
+ }
+ if (!__pyx_t_11) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ __pyx_t_18 = PyTuple_New(1+1); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
+ __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_11); __pyx_t_11 = NULL;
+ __Pyx_GIVEREF(__pyx_t_10);
+ PyTuple_SET_ITEM(__pyx_t_18, 0+1, __pyx_t_10);
+ __pyx_t_10 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_18, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_v_self->_sqrt_normalisation_scaling = __pyx_t_7;
+
+ /* "pyfftw/pyfftw.pyx":986
* cdef validator _validator
*
* if functions['validator'] == -1: # <<<<<<<<<<<<<<
* if not (output_array.shape == input_array.shape):
* raise ValueError('Invalid shapes: '
*/
- __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_validator); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_validator); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_9 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
if (__pyx_t_3) {
- /* "pyfftw/pyfftw.pyx":985
+ /* "pyfftw/pyfftw.pyx":987
*
* if functions['validator'] == -1:
* if not (output_array.shape == input_array.shape): # <<<<<<<<<<<<<<
* raise ValueError('Invalid shapes: '
* 'The output array should be the same shape as the '
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 985; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 985; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = PyObject_RichCompare(__pyx_t_10, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 985; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 985; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = PyObject_RichCompare(__pyx_t_9, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_18); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_18); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
__pyx_t_2 = ((!__pyx_t_3) != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":986
+ /* "pyfftw/pyfftw.pyx":988
* if functions['validator'] == -1:
* if not (output_array.shape == input_array.shape):
* raise ValueError('Invalid shapes: ' # <<<<<<<<<<<<<<
* 'The output array should be the same shape as the '
* 'input array for the given array dtypes.')
*/
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
- __Pyx_Raise(__pyx_t_9, 0, 0, 0);
- __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 988; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
+ __Pyx_Raise(__pyx_t_18, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 988; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":985
+ /* "pyfftw/pyfftw.pyx":987
*
* if functions['validator'] == -1:
* if not (output_array.shape == input_array.shape): # <<<<<<<<<<<<<<
@@ -9039,7 +9091,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":984
+ /* "pyfftw/pyfftw.pyx":986
* cdef validator _validator
*
* if functions['validator'] == -1: # <<<<<<<<<<<<<<
@@ -9049,7 +9101,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
goto __pyx_L50;
}
- /* "pyfftw/pyfftw.pyx":990
+ /* "pyfftw/pyfftw.pyx":992
* 'input array for the given array dtypes.')
* else:
* _validator = validators[functions['validator']] # <<<<<<<<<<<<<<
@@ -9057,23 +9109,23 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
* self._axes, self._not_axes, unique_axes_length):
*/
/*else*/ {
- __pyx_t_9 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_validator); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 990; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_9);
- __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 990; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __pyx_t_18 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_validator); if (unlikely(__pyx_t_18 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 992; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_18);
+ __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_18); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 992; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
__pyx_v__validator = (__pyx_v_6pyfftw_6pyfftw_validators[__pyx_t_12]);
- /* "pyfftw/pyfftw.pyx":991
+ /* "pyfftw/pyfftw.pyx":993
* else:
* _validator = validators[functions['validator']]
* if not _validator(input_array, output_array, # <<<<<<<<<<<<<<
* self._axes, self._not_axes, unique_axes_length):
* raise ValueError('Invalid shapes: '
*/
- if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 991; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 991; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":992
+ /* "pyfftw/pyfftw.pyx":994
* _validator = validators[functions['validator']]
* if not _validator(input_array, output_array,
* self._axes, self._not_axes, unique_axes_length): # <<<<<<<<<<<<<<
@@ -9082,7 +9134,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_t_2 = ((!(__pyx_v__validator(((PyArrayObject *)__pyx_v_input_array), ((PyArrayObject *)__pyx_v_output_array), __pyx_v_self->_axes, __pyx_v_self->_not_axes, __pyx_v_unique_axes_length) != 0)) != 0);
- /* "pyfftw/pyfftw.pyx":991
+ /* "pyfftw/pyfftw.pyx":993
* else:
* _validator = validators[functions['validator']]
* if not _validator(input_array, output_array, # <<<<<<<<<<<<<<
@@ -9091,20 +9143,20 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":993
+ /* "pyfftw/pyfftw.pyx":995
* if not _validator(input_array, output_array,
* self._axes, self._not_axes, unique_axes_length):
* raise ValueError('Invalid shapes: ' # <<<<<<<<<<<<<<
* 'The input array and output array are invalid '
* 'complementary shapes for their dtypes.')
*/
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
- __Pyx_Raise(__pyx_t_9, 0, 0, 0);
- __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
+ __Pyx_Raise(__pyx_t_18, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":991
+ /* "pyfftw/pyfftw.pyx":993
* else:
* _validator = validators[functions['validator']]
* if not _validator(input_array, output_array, # <<<<<<<<<<<<<<
@@ -9115,7 +9167,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
}
__pyx_L50:;
- /* "pyfftw/pyfftw.pyx":997
+ /* "pyfftw/pyfftw.pyx":999
* 'complementary shapes for their dtypes.')
*
* self._rank = unique_axes_length # <<<<<<<<<<<<<<
@@ -9124,7 +9176,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_rank = __pyx_v_unique_axes_length;
- /* "pyfftw/pyfftw.pyx":998
+ /* "pyfftw/pyfftw.pyx":1000
*
* self._rank = unique_axes_length
* self._howmany_rank = self._input_array.ndim - unique_axes_length # <<<<<<<<<<<<<<
@@ -9133,7 +9185,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_howmany_rank = (__pyx_v_self->_input_array->nd - __pyx_v_unique_axes_length);
- /* "pyfftw/pyfftw.pyx":1000
+ /* "pyfftw/pyfftw.pyx":1002
* self._howmany_rank = self._input_array.ndim - unique_axes_length
*
* self._flags = 0 # <<<<<<<<<<<<<<
@@ -9142,22 +9194,22 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_flags = 0;
- /* "pyfftw/pyfftw.pyx":1001
+ /* "pyfftw/pyfftw.pyx":1003
*
* self._flags = 0
* self._flags_used = [] # <<<<<<<<<<<<<<
* for each_flag in flags:
* try:
*/
- __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1001; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
- __Pyx_GIVEREF(__pyx_t_9);
+ __pyx_t_18 = PyList_New(0); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
+ __Pyx_GIVEREF(__pyx_t_18);
__Pyx_GOTREF(__pyx_v_self->_flags_used);
__Pyx_DECREF(__pyx_v_self->_flags_used);
- __pyx_v_self->_flags_used = __pyx_t_9;
- __pyx_t_9 = 0;
+ __pyx_v_self->_flags_used = __pyx_t_18;
+ __pyx_t_18 = 0;
- /* "pyfftw/pyfftw.pyx":1002
+ /* "pyfftw/pyfftw.pyx":1004
* self._flags = 0
* self._flags_used = []
* for each_flag in flags: # <<<<<<<<<<<<<<
@@ -9165,39 +9217,39 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
* self._flags |= flag_dict[each_flag]
*/
if (likely(PyList_CheckExact(__pyx_v_flags)) || PyTuple_CheckExact(__pyx_v_flags)) {
- __pyx_t_9 = __pyx_v_flags; __Pyx_INCREF(__pyx_t_9); __pyx_t_12 = 0;
+ __pyx_t_18 = __pyx_v_flags; __Pyx_INCREF(__pyx_t_18); __pyx_t_12 = 0;
__pyx_t_13 = NULL;
} else {
- __pyx_t_12 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_v_flags); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
- __pyx_t_13 = Py_TYPE(__pyx_t_9)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = -1; __pyx_t_18 = PyObject_GetIter(__pyx_v_flags); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
+ __pyx_t_13 = Py_TYPE(__pyx_t_18)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
for (;;) {
if (likely(!__pyx_t_13)) {
- if (likely(PyList_CheckExact(__pyx_t_9))) {
- if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_9)) break;
+ if (likely(PyList_CheckExact(__pyx_t_18))) {
+ if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_18)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_9, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_18, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_9, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_18, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
- if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_9)) break;
+ if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_18)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_18, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_9, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_18, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
#endif
}
} else {
- __pyx_t_1 = __pyx_t_13(__pyx_t_9);
+ __pyx_t_1 = __pyx_t_13(__pyx_t_18);
if (unlikely(!__pyx_t_1)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
break;
}
@@ -9206,7 +9258,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_XDECREF_SET(__pyx_v_each_flag, __pyx_t_1);
__pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1003
+ /* "pyfftw/pyfftw.pyx":1005
* self._flags_used = []
* for each_flag in flags:
* try: # <<<<<<<<<<<<<<
@@ -9220,35 +9272,35 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_XGOTREF(__pyx_t_6);
/*try:*/ {
- /* "pyfftw/pyfftw.pyx":1004
+ /* "pyfftw/pyfftw.pyx":1006
* for each_flag in flags:
* try:
* self._flags |= flag_dict[each_flag] # <<<<<<<<<<<<<<
* self._flags_used.append(each_flag)
* except KeyError:
*/
- __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L55_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1006; __pyx_clineno = __LINE__; goto __pyx_L55_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = PyObject_GetItem(__pyx_v_6pyfftw_6pyfftw_flag_dict, __pyx_v_each_flag); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L55_error;};
+ __pyx_t_9 = PyObject_GetItem(__pyx_v_6pyfftw_6pyfftw_flag_dict, __pyx_v_each_flag); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1006; __pyx_clineno = __LINE__; goto __pyx_L55_error;};
+ __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_10 = PyNumber_InPlaceOr(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1006; __pyx_clineno = __LINE__; goto __pyx_L55_error;}
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_11 = PyNumber_InPlaceOr(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L55_error;}
- __Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __pyx_t_19 = __Pyx_PyInt_As_unsigned_int(__pyx_t_10); if (unlikely((__pyx_t_19 == (unsigned int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1006; __pyx_clineno = __LINE__; goto __pyx_L55_error;}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_18 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_18 == (unsigned int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L55_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- __pyx_v_self->_flags = __pyx_t_18;
+ __pyx_v_self->_flags = __pyx_t_19;
- /* "pyfftw/pyfftw.pyx":1005
+ /* "pyfftw/pyfftw.pyx":1007
* try:
* self._flags |= flag_dict[each_flag]
* self._flags_used.append(each_flag) # <<<<<<<<<<<<<<
* except KeyError:
* raise ValueError('Invalid flag: ' + '\'' +
*/
- __pyx_t_14 = __Pyx_PyObject_Append(__pyx_v_self->_flags_used, __pyx_v_each_flag); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1005; __pyx_clineno = __LINE__; goto __pyx_L55_error;}
+ __pyx_t_14 = __Pyx_PyObject_Append(__pyx_v_self->_flags_used, __pyx_v_each_flag); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L55_error;}
- /* "pyfftw/pyfftw.pyx":1003
+ /* "pyfftw/pyfftw.pyx":1005
* self._flags_used = []
* for each_flag in flags:
* try: # <<<<<<<<<<<<<<
@@ -9261,11 +9313,12 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L62_try_end;
__pyx_L55_error:;
+ __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
- __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "pyfftw/pyfftw.pyx":1006
+ /* "pyfftw/pyfftw.pyx":1008
* self._flags |= flag_dict[each_flag]
* self._flags_used.append(each_flag)
* except KeyError: # <<<<<<<<<<<<<<
@@ -9275,58 +9328,58 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_8 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_8) {
__Pyx_AddTraceback("pyfftw.pyfftw.FFTW.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_10, &__pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1006; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
- __Pyx_GOTREF(__pyx_t_11);
+ if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_9, &__pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
__Pyx_GOTREF(__pyx_t_10);
+ __Pyx_GOTREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_t_1);
- /* "pyfftw/pyfftw.pyx":1007
+ /* "pyfftw/pyfftw.pyx":1009
* self._flags_used.append(each_flag)
* except KeyError:
* raise ValueError('Invalid flag: ' + '\'' + # <<<<<<<<<<<<<<
* each_flag + '\' is not a valid planner flag.')
*
*/
- __pyx_t_19 = PyNumber_Add(__pyx_kp_s_Invalid_flag, __pyx_kp_s__17); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
- __Pyx_GOTREF(__pyx_t_19);
+ __pyx_t_11 = PyNumber_Add(__pyx_kp_s_Invalid_flag, __pyx_kp_s__17); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1009; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
+ __Pyx_GOTREF(__pyx_t_11);
- /* "pyfftw/pyfftw.pyx":1008
+ /* "pyfftw/pyfftw.pyx":1010
* except KeyError:
* raise ValueError('Invalid flag: ' + '\'' +
* each_flag + '\' is not a valid planner flag.') # <<<<<<<<<<<<<<
*
*
*/
- __pyx_t_20 = PyNumber_Add(__pyx_t_19, __pyx_v_each_flag); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
+ __pyx_t_20 = PyNumber_Add(__pyx_t_11, __pyx_v_each_flag); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1009; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
__Pyx_GOTREF(__pyx_t_20);
- __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
- __pyx_t_19 = PyNumber_Add(__pyx_t_20, __pyx_kp_s_is_not_a_valid_planner_flag); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
- __Pyx_GOTREF(__pyx_t_19);
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_11 = PyNumber_Add(__pyx_t_20, __pyx_kp_s_is_not_a_valid_planner_flag); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1010; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
+ __Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
- /* "pyfftw/pyfftw.pyx":1007
+ /* "pyfftw/pyfftw.pyx":1009
* self._flags_used.append(each_flag)
* except KeyError:
* raise ValueError('Invalid flag: ' + '\'' + # <<<<<<<<<<<<<<
* each_flag + '\' is not a valid planner flag.')
*
*/
- __pyx_t_20 = PyTuple_New(1); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
+ __pyx_t_20 = PyTuple_New(1); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1009; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
__Pyx_GOTREF(__pyx_t_20);
- __Pyx_GIVEREF(__pyx_t_19);
- PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_19);
- __pyx_t_19 = 0;
- __pyx_t_19 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_20, NULL); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
- __Pyx_GOTREF(__pyx_t_19);
+ __Pyx_GIVEREF(__pyx_t_11);
+ PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_11);
+ __pyx_t_11 = 0;
+ __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_20, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1009; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
+ __Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
- __Pyx_Raise(__pyx_t_19, 0, 0, 0);
- __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
+ __Pyx_Raise(__pyx_t_11, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1009; __pyx_clineno = __LINE__; goto __pyx_L57_except_error;}
}
goto __pyx_L57_except_error;
__pyx_L57_except_error:;
- /* "pyfftw/pyfftw.pyx":1003
+ /* "pyfftw/pyfftw.pyx":1005
* self._flags_used = []
* for each_flag in flags:
* try: # <<<<<<<<<<<<<<
@@ -9341,7 +9394,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_L62_try_end:;
}
- /* "pyfftw/pyfftw.pyx":1002
+ /* "pyfftw/pyfftw.pyx":1004
* self._flags = 0
* self._flags_used = []
* for each_flag in flags: # <<<<<<<<<<<<<<
@@ -9349,16 +9402,16 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
* self._flags |= flag_dict[each_flag]
*/
}
- __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
- /* "pyfftw/pyfftw.pyx":1011
+ /* "pyfftw/pyfftw.pyx":1013
*
*
* if ('FFTW_DESTROY_INPUT' not in flags) and ( # <<<<<<<<<<<<<<
* (scheme[0] != 'c2r') or not self._rank > 1):
* # The default in all possible cases is to preserve the input
*/
- __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_FFTW_DESTROY_INPUT, __pyx_v_flags, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_FFTW_DESTROY_INPUT, __pyx_v_flags, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1013; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_t_21 = (__pyx_t_3 != 0);
if (__pyx_t_21) {
} else {
@@ -9366,17 +9419,17 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
goto __pyx_L66_bool_binop_done;
}
- /* "pyfftw/pyfftw.pyx":1012
+ /* "pyfftw/pyfftw.pyx":1014
*
* if ('FFTW_DESTROY_INPUT' not in flags) and (
* (scheme[0] != 'c2r') or not self._rank > 1): # <<<<<<<<<<<<<<
* # The default in all possible cases is to preserve the input
* # This is not possible for r2c arrays with rank > 1
*/
- __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_scheme, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1012; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_9);
- __pyx_t_21 = (__Pyx_PyString_Equals(__pyx_t_9, __pyx_n_s_c2r, Py_NE)); if (unlikely(__pyx_t_21 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1012; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __pyx_t_18 = __Pyx_GetItemInt(__pyx_v_scheme, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_18 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1014; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_18);
+ __pyx_t_21 = (__Pyx_PyString_Equals(__pyx_t_18, __pyx_n_s_c2r, Py_NE)); if (unlikely(__pyx_t_21 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
if (!__pyx_t_21) {
} else {
__pyx_t_2 = __pyx_t_21;
@@ -9386,7 +9439,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_2 = __pyx_t_21;
__pyx_L66_bool_binop_done:;
- /* "pyfftw/pyfftw.pyx":1011
+ /* "pyfftw/pyfftw.pyx":1013
*
*
* if ('FFTW_DESTROY_INPUT' not in flags) and ( # <<<<<<<<<<<<<<
@@ -9395,7 +9448,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1015
+ /* "pyfftw/pyfftw.pyx":1017
* # The default in all possible cases is to preserve the input
* # This is not possible for r2c arrays with rank > 1
* self._flags |= FFTW_PRESERVE_INPUT # <<<<<<<<<<<<<<
@@ -9404,7 +9457,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_flags = (__pyx_v_self->_flags | __pyx_e_6pyfftw_6pyfftw_FFTW_PRESERVE_INPUT);
- /* "pyfftw/pyfftw.pyx":1011
+ /* "pyfftw/pyfftw.pyx":1013
*
*
* if ('FFTW_DESTROY_INPUT' not in flags) and ( # <<<<<<<<<<<<<<
@@ -9413,7 +9466,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":1019
+ /* "pyfftw/pyfftw.pyx":1021
* # Set up the arrays of structs for holding the stride shape
* # information
* self._dims = <_fftw_iodim *>malloc( # <<<<<<<<<<<<<<
@@ -9422,7 +9475,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_dims = ((__pyx_t_6pyfftw_6pyfftw__fftw_iodim *)malloc((__pyx_v_self->_rank * (sizeof(__pyx_t_6pyfftw_6pyfftw__fftw_iodim)))));
- /* "pyfftw/pyfftw.pyx":1021
+ /* "pyfftw/pyfftw.pyx":1023
* self._dims = <_fftw_iodim *>malloc(
* self._rank * sizeof(_fftw_iodim))
* self._howmany_dims = <_fftw_iodim *>malloc( # <<<<<<<<<<<<<<
@@ -9431,7 +9484,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_howmany_dims = ((__pyx_t_6pyfftw_6pyfftw__fftw_iodim *)malloc((__pyx_v_self->_howmany_rank * (sizeof(__pyx_t_6pyfftw_6pyfftw__fftw_iodim)))));
- /* "pyfftw/pyfftw.pyx":1024
+ /* "pyfftw/pyfftw.pyx":1026
* self._howmany_rank * sizeof(_fftw_iodim))
*
* if self._dims == NULL or self._howmany_dims == NULL: # <<<<<<<<<<<<<<
@@ -9449,16 +9502,16 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_L70_bool_binop_done:;
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1026
+ /* "pyfftw/pyfftw.pyx":1028
* if self._dims == NULL or self._howmany_dims == NULL:
* # Not much else to do than raise an exception
* raise MemoryError # <<<<<<<<<<<<<<
*
* # Find the strides for all the axes of both arrays in terms of the
*/
- PyErr_NoMemory(); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1026; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyErr_NoMemory(); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1028; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1024
+ /* "pyfftw/pyfftw.pyx":1026
* self._howmany_rank * sizeof(_fftw_iodim))
*
* if self._dims == NULL or self._howmany_dims == NULL: # <<<<<<<<<<<<<<
@@ -9467,75 +9520,75 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":1030
+ /* "pyfftw/pyfftw.pyx":1032
* # Find the strides for all the axes of both arrays in terms of the
* # number of items (as opposed to the number of bytes).
* self._input_strides = input_array.strides # <<<<<<<<<<<<<<
* self._input_item_strides = tuple([stride/input_array.itemsize
* for stride in input_array.strides])
*/
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1030; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
- __Pyx_GIVEREF(__pyx_t_9);
+ __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
+ __Pyx_GIVEREF(__pyx_t_18);
__Pyx_GOTREF(__pyx_v_self->_input_strides);
__Pyx_DECREF(__pyx_v_self->_input_strides);
- __pyx_v_self->_input_strides = __pyx_t_9;
- __pyx_t_9 = 0;
+ __pyx_v_self->_input_strides = __pyx_t_18;
+ __pyx_t_18 = 0;
- /* "pyfftw/pyfftw.pyx":1031
+ /* "pyfftw/pyfftw.pyx":1033
* # number of items (as opposed to the number of bytes).
* self._input_strides = input_array.strides
* self._input_item_strides = tuple([stride/input_array.itemsize # <<<<<<<<<<<<<<
* for stride in input_array.strides])
* self._output_strides = output_array.strides
*/
- __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1031; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_18 = PyList_New(0); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1033; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
- /* "pyfftw/pyfftw.pyx":1032
+ /* "pyfftw/pyfftw.pyx":1034
* self._input_strides = input_array.strides
* self._input_item_strides = tuple([stride/input_array.itemsize
* for stride in input_array.strides]) # <<<<<<<<<<<<<<
* self._output_strides = output_array.strides
* self._output_item_strides = tuple([stride/output_array.itemsize
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
- __pyx_t_10 = __pyx_t_1; __Pyx_INCREF(__pyx_t_10); __pyx_t_12 = 0;
+ __pyx_t_9 = __pyx_t_1; __Pyx_INCREF(__pyx_t_9); __pyx_t_12 = 0;
__pyx_t_13 = NULL;
} else {
- __pyx_t_12 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
- __pyx_t_13 = Py_TYPE(__pyx_t_10)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_13 = Py_TYPE(__pyx_t_9)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
if (likely(!__pyx_t_13)) {
- if (likely(PyList_CheckExact(__pyx_t_10))) {
- if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_10)) break;
+ if (likely(PyList_CheckExact(__pyx_t_9))) {
+ if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_9)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_9, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_9, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
- if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_10)) break;
+ if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_9)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_9, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
#endif
}
} else {
- __pyx_t_1 = __pyx_t_13(__pyx_t_10);
+ __pyx_t_1 = __pyx_t_13(__pyx_t_9);
if (unlikely(!__pyx_t_1)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
break;
}
@@ -9544,22 +9597,22 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_XDECREF_SET(__pyx_v_stride, __pyx_t_1);
__pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1031
+ /* "pyfftw/pyfftw.pyx":1033
* # number of items (as opposed to the number of bytes).
* self._input_strides = input_array.strides
* self._input_item_strides = tuple([stride/input_array.itemsize # <<<<<<<<<<<<<<
* for stride in input_array.strides])
* self._output_strides = output_array.strides
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1031; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1033; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_11 = __Pyx_PyNumber_Divide(__pyx_v_stride, __pyx_t_1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1031; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_10 = __Pyx_PyNumber_Divide(__pyx_v_stride, __pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1033; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_9, (PyObject*)__pyx_t_11))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1031; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_18, (PyObject*)__pyx_t_10))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1033; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1032
+ /* "pyfftw/pyfftw.pyx":1034
* self._input_strides = input_array.strides
* self._input_item_strides = tuple([stride/input_array.itemsize
* for stride in input_array.strides]) # <<<<<<<<<<<<<<
@@ -9567,117 +9620,117 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
* self._output_item_strides = tuple([stride/output_array.itemsize
*/
}
- __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- /* "pyfftw/pyfftw.pyx":1031
+ /* "pyfftw/pyfftw.pyx":1033
* # number of items (as opposed to the number of bytes).
* self._input_strides = input_array.strides
* self._input_item_strides = tuple([stride/input_array.itemsize # <<<<<<<<<<<<<<
* for stride in input_array.strides])
* self._output_strides = output_array.strides
*/
- __pyx_t_10 = PyList_AsTuple(((PyObject*)__pyx_t_9)); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1031; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
- __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __Pyx_GIVEREF(__pyx_t_10);
+ __pyx_t_9 = PyList_AsTuple(((PyObject*)__pyx_t_18)); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1033; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+ __Pyx_GIVEREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_v_self->_input_item_strides);
__Pyx_DECREF(__pyx_v_self->_input_item_strides);
- __pyx_v_self->_input_item_strides = __pyx_t_10;
- __pyx_t_10 = 0;
+ __pyx_v_self->_input_item_strides = __pyx_t_9;
+ __pyx_t_9 = 0;
- /* "pyfftw/pyfftw.pyx":1033
+ /* "pyfftw/pyfftw.pyx":1035
* self._input_item_strides = tuple([stride/input_array.itemsize
* for stride in input_array.strides])
* self._output_strides = output_array.strides # <<<<<<<<<<<<<<
* self._output_item_strides = tuple([stride/output_array.itemsize
* for stride in output_array.strides])
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1033; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
- __Pyx_GIVEREF(__pyx_t_10);
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_v_self->_output_strides);
__Pyx_DECREF(__pyx_v_self->_output_strides);
- __pyx_v_self->_output_strides = __pyx_t_10;
- __pyx_t_10 = 0;
+ __pyx_v_self->_output_strides = __pyx_t_9;
+ __pyx_t_9 = 0;
- /* "pyfftw/pyfftw.pyx":1034
+ /* "pyfftw/pyfftw.pyx":1036
* for stride in input_array.strides])
* self._output_strides = output_array.strides
* self._output_item_strides = tuple([stride/output_array.itemsize # <<<<<<<<<<<<<<
* for stride in output_array.strides])
*
*/
- __pyx_t_10 = PyList_New(0); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1036; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
- /* "pyfftw/pyfftw.pyx":1035
+ /* "pyfftw/pyfftw.pyx":1037
* self._output_strides = output_array.strides
* self._output_item_strides = tuple([stride/output_array.itemsize
* for stride in output_array.strides]) # <<<<<<<<<<<<<<
*
* # Make sure that the arrays are not too big for fftw
*/
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
- if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
- __pyx_t_11 = __pyx_t_9; __Pyx_INCREF(__pyx_t_11); __pyx_t_12 = 0;
+ __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
+ if (likely(PyList_CheckExact(__pyx_t_18)) || PyTuple_CheckExact(__pyx_t_18)) {
+ __pyx_t_10 = __pyx_t_18; __Pyx_INCREF(__pyx_t_10); __pyx_t_12 = 0;
__pyx_t_13 = NULL;
} else {
- __pyx_t_12 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_13 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_18); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_13 = Py_TYPE(__pyx_t_10)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
- __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
for (;;) {
if (likely(!__pyx_t_13)) {
- if (likely(PyList_CheckExact(__pyx_t_11))) {
- if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_11)) break;
+ if (likely(PyList_CheckExact(__pyx_t_10))) {
+ if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_10)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_9 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_9); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_18); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
#else
- __pyx_t_9 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_18 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
#endif
} else {
- if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_11)) break;
+ if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_10)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_9); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_18); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
#else
- __pyx_t_9 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_18 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
#endif
}
} else {
- __pyx_t_9 = __pyx_t_13(__pyx_t_11);
- if (unlikely(!__pyx_t_9)) {
+ __pyx_t_18 = __pyx_t_13(__pyx_t_10);
+ if (unlikely(!__pyx_t_18)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
break;
}
- __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GOTREF(__pyx_t_18);
}
- __Pyx_XDECREF_SET(__pyx_v_stride, __pyx_t_9);
- __pyx_t_9 = 0;
+ __Pyx_XDECREF_SET(__pyx_v_stride, __pyx_t_18);
+ __pyx_t_18 = 0;
- /* "pyfftw/pyfftw.pyx":1034
+ /* "pyfftw/pyfftw.pyx":1036
* for stride in input_array.strides])
* self._output_strides = output_array.strides
* self._output_item_strides = tuple([stride/output_array.itemsize # <<<<<<<<<<<<<<
* for stride in output_array.strides])
*
*/
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
- __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_v_stride, __pyx_t_9); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1036; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
+ __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_v_stride, __pyx_t_18); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1036; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_10, (PyObject*)__pyx_t_1))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_9, (PyObject*)__pyx_t_1))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1036; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1035
+ /* "pyfftw/pyfftw.pyx":1037
* self._output_strides = output_array.strides
* self._output_item_strides = tuple([stride/output_array.itemsize
* for stride in output_array.strides]) # <<<<<<<<<<<<<<
@@ -9685,107 +9738,107 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
* # Make sure that the arrays are not too big for fftw
*/
}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1034
+ /* "pyfftw/pyfftw.pyx":1036
* for stride in input_array.strides])
* self._output_strides = output_array.strides
* self._output_item_strides = tuple([stride/output_array.itemsize # <<<<<<<<<<<<<<
* for stride in output_array.strides])
*
*/
- __pyx_t_11 = PyList_AsTuple(((PyObject*)__pyx_t_10)); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __Pyx_GIVEREF(__pyx_t_11);
+ __pyx_t_10 = PyList_AsTuple(((PyObject*)__pyx_t_9)); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1036; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __Pyx_GIVEREF(__pyx_t_10);
__Pyx_GOTREF(__pyx_v_self->_output_item_strides);
__Pyx_DECREF(__pyx_v_self->_output_item_strides);
- __pyx_v_self->_output_item_strides = __pyx_t_11;
- __pyx_t_11 = 0;
+ __pyx_v_self->_output_item_strides = __pyx_t_10;
+ __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1041
+ /* "pyfftw/pyfftw.pyx":1043
* # best (any suggestions, please get in touch).
* cdef int i
* for i in range(0, len(self._input_shape)): # <<<<<<<<<<<<<<
* if self._input_shape[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Dimensions of the input array must be ' +
*/
- __pyx_t_11 = __pyx_v_self->_input_shape;
- __Pyx_INCREF(__pyx_t_11);
- __pyx_t_12 = PyObject_Length(__pyx_t_11); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = __pyx_v_self->_input_shape;
+ __Pyx_INCREF(__pyx_t_10);
+ __pyx_t_12 = PyObject_Length(__pyx_t_10); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1043; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_12; __pyx_t_8+=1) {
__pyx_v_i = __pyx_t_8;
- /* "pyfftw/pyfftw.pyx":1042
+ /* "pyfftw/pyfftw.pyx":1044
* cdef int i
* for i in range(0, len(self._input_shape)):
* if self._input_shape[i] >= <Py_ssize_t> limits.INT_MAX: # <<<<<<<<<<<<<<
* raise ValueError('Dimensions of the input array must be ' +
* 'less than ', str(limits.INT_MAX))
*/
- __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_self->_input_shape, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1042; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_10 = PyInt_FromSsize_t(((Py_ssize_t)INT_MAX)); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1042; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_self->_input_shape, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1044; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_11, __pyx_t_10, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1042; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_9 = PyInt_FromSsize_t(((Py_ssize_t)INT_MAX)); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1044; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_10, __pyx_t_9, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1044; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1042; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1044; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1043
+ /* "pyfftw/pyfftw.pyx":1045
* for i in range(0, len(self._input_shape)):
* if self._input_shape[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Dimensions of the input array must be ' + # <<<<<<<<<<<<<<
* 'less than ', str(limits.INT_MAX))
*
*/
- __pyx_t_1 = PyNumber_Add(__pyx_kp_s_Dimensions_of_the_input_array_mu, __pyx_kp_s_less_than); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1043; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_kp_s_Dimensions_of_the_input_array_mu, __pyx_kp_s_less_than); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1045; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- /* "pyfftw/pyfftw.pyx":1044
+ /* "pyfftw/pyfftw.pyx":1046
* if self._input_shape[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Dimensions of the input array must be ' +
* 'less than ', str(limits.INT_MAX)) # <<<<<<<<<<<<<<
*
* if self._input_item_strides[i] >= <Py_ssize_t> limits.INT_MAX:
*/
- __pyx_t_10 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1044; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
- __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1044; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __Pyx_GIVEREF(__pyx_t_10);
- PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10);
- __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1044; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1046; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1046; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __Pyx_GIVEREF(__pyx_t_9);
+ PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9);
+ __pyx_t_9 = 0;
+ __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1046; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1043
+ /* "pyfftw/pyfftw.pyx":1045
* for i in range(0, len(self._input_shape)):
* if self._input_shape[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Dimensions of the input array must be ' + # <<<<<<<<<<<<<<
* 'less than ', str(limits.INT_MAX))
*
*/
- __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1043; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1045; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_1);
- __Pyx_GIVEREF(__pyx_t_10);
- PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_10);
+ PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_9);
+ PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_9);
__pyx_t_1 = 0;
- __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1043; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- __Pyx_Raise(__pyx_t_10, 0, 0, 0);
+ __pyx_t_9 = 0;
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1045; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1043; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_Raise(__pyx_t_9, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1045; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1042
+ /* "pyfftw/pyfftw.pyx":1044
* cdef int i
* for i in range(0, len(self._input_shape)):
* if self._input_shape[i] >= <Py_ssize_t> limits.INT_MAX: # <<<<<<<<<<<<<<
@@ -9794,75 +9847,75 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":1046
+ /* "pyfftw/pyfftw.pyx":1048
* 'less than ', str(limits.INT_MAX))
*
* if self._input_item_strides[i] >= <Py_ssize_t> limits.INT_MAX: # <<<<<<<<<<<<<<
* raise ValueError('Strides of the input array must be ' +
* 'less than ', str(limits.INT_MAX))
*/
- __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_self->_input_item_strides, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1046; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_self->_input_item_strides, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1048; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_10 = PyInt_FromSsize_t(((Py_ssize_t)INT_MAX)); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1048; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_11 = PyInt_FromSsize_t(((Py_ssize_t)INT_MAX)); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1046; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_10, __pyx_t_11, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1046; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_9, __pyx_t_10, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1048; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1046; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1048; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1047
+ /* "pyfftw/pyfftw.pyx":1049
*
* if self._input_item_strides[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Strides of the input array must be ' + # <<<<<<<<<<<<<<
* 'less than ', str(limits.INT_MAX))
*
*/
- __pyx_t_1 = PyNumber_Add(__pyx_kp_s_Strides_of_the_input_array_must, __pyx_kp_s_less_than); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_kp_s_Strides_of_the_input_array_must, __pyx_kp_s_less_than); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1049; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- /* "pyfftw/pyfftw.pyx":1048
+ /* "pyfftw/pyfftw.pyx":1050
* if self._input_item_strides[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Strides of the input array must be ' +
* 'less than ', str(limits.INT_MAX)) # <<<<<<<<<<<<<<
*
* for i in range(0, len(self._output_shape)):
*/
- __pyx_t_11 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1048; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1048; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1050; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
- __Pyx_GIVEREF(__pyx_t_11);
- PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11);
- __pyx_t_11 = 0;
- __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_10, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1048; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1050; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_10);
+ PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10);
+ __pyx_t_10 = 0;
+ __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_9, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1050; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- /* "pyfftw/pyfftw.pyx":1047
+ /* "pyfftw/pyfftw.pyx":1049
*
* if self._input_item_strides[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Strides of the input array must be ' + # <<<<<<<<<<<<<<
* 'less than ', str(limits.INT_MAX))
*
*/
- __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1049; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1);
- __Pyx_GIVEREF(__pyx_t_11);
- PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_11);
+ PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_10);
+ PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_10);
__pyx_t_1 = 0;
- __pyx_t_11 = 0;
- __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_10 = 0;
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1049; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __Pyx_Raise(__pyx_t_11, 0, 0, 0);
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1049; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1046
+ /* "pyfftw/pyfftw.pyx":1048
* 'less than ', str(limits.INT_MAX))
*
* if self._input_item_strides[i] >= <Py_ssize_t> limits.INT_MAX: # <<<<<<<<<<<<<<
@@ -9872,89 +9925,89 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
}
}
- /* "pyfftw/pyfftw.pyx":1050
+ /* "pyfftw/pyfftw.pyx":1052
* 'less than ', str(limits.INT_MAX))
*
* for i in range(0, len(self._output_shape)): # <<<<<<<<<<<<<<
* if self._output_shape[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Dimensions of the output array must be ' +
*/
- __pyx_t_11 = __pyx_v_self->_output_shape;
- __Pyx_INCREF(__pyx_t_11);
- __pyx_t_12 = PyObject_Length(__pyx_t_11); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1050; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = __pyx_v_self->_output_shape;
+ __Pyx_INCREF(__pyx_t_10);
+ __pyx_t_12 = PyObject_Length(__pyx_t_10); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1052; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_12; __pyx_t_8+=1) {
__pyx_v_i = __pyx_t_8;
- /* "pyfftw/pyfftw.pyx":1051
+ /* "pyfftw/pyfftw.pyx":1053
*
* for i in range(0, len(self._output_shape)):
* if self._output_shape[i] >= <Py_ssize_t> limits.INT_MAX: # <<<<<<<<<<<<<<
* raise ValueError('Dimensions of the output array must be ' +
* 'less than ', str(limits.INT_MAX))
*/
- __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_self->_output_shape, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1051; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_10 = PyInt_FromSsize_t(((Py_ssize_t)INT_MAX)); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1051; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_self->_output_shape, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_11, __pyx_t_10, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1051; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_9 = PyInt_FromSsize_t(((Py_ssize_t)INT_MAX)); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_10, __pyx_t_9, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1051; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1052
+ /* "pyfftw/pyfftw.pyx":1054
* for i in range(0, len(self._output_shape)):
* if self._output_shape[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Dimensions of the output array must be ' + # <<<<<<<<<<<<<<
* 'less than ', str(limits.INT_MAX))
*
*/
- __pyx_t_1 = PyNumber_Add(__pyx_kp_s_Dimensions_of_the_output_array_m, __pyx_kp_s_less_than); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1052; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_kp_s_Dimensions_of_the_output_array_m, __pyx_kp_s_less_than); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1054; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- /* "pyfftw/pyfftw.pyx":1053
+ /* "pyfftw/pyfftw.pyx":1055
* if self._output_shape[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Dimensions of the output array must be ' +
* 'less than ', str(limits.INT_MAX)) # <<<<<<<<<<<<<<
*
* if self._output_item_strides[i] >= <Py_ssize_t> limits.INT_MAX:
*/
- __pyx_t_10 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
- __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __Pyx_GIVEREF(__pyx_t_10);
- PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10);
- __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __Pyx_GIVEREF(__pyx_t_9);
+ PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9);
+ __pyx_t_9 = 0;
+ __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1052
+ /* "pyfftw/pyfftw.pyx":1054
* for i in range(0, len(self._output_shape)):
* if self._output_shape[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Dimensions of the output array must be ' + # <<<<<<<<<<<<<<
* 'less than ', str(limits.INT_MAX))
*
*/
- __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1052; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1054; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_1);
- __Pyx_GIVEREF(__pyx_t_10);
- PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_10);
+ PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_9);
+ PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_9);
__pyx_t_1 = 0;
- __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1052; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- __Pyx_Raise(__pyx_t_10, 0, 0, 0);
+ __pyx_t_9 = 0;
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1054; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1052; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_Raise(__pyx_t_9, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1054; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1051
+ /* "pyfftw/pyfftw.pyx":1053
*
* for i in range(0, len(self._output_shape)):
* if self._output_shape[i] >= <Py_ssize_t> limits.INT_MAX: # <<<<<<<<<<<<<<
@@ -9963,75 +10016,75 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":1055
+ /* "pyfftw/pyfftw.pyx":1057
* 'less than ', str(limits.INT_MAX))
*
* if self._output_item_strides[i] >= <Py_ssize_t> limits.INT_MAX: # <<<<<<<<<<<<<<
* raise ValueError('Strides of the output array must be ' +
* 'less than ', str(limits.INT_MAX))
*/
- __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_self->_output_item_strides, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_self->_output_item_strides, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_10 = PyInt_FromSsize_t(((Py_ssize_t)INT_MAX)); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_11 = PyInt_FromSsize_t(((Py_ssize_t)INT_MAX)); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_10, __pyx_t_11, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_9, __pyx_t_10, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1056
+ /* "pyfftw/pyfftw.pyx":1058
*
* if self._output_item_strides[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Strides of the output array must be ' + # <<<<<<<<<<<<<<
* 'less than ', str(limits.INT_MAX))
*
*/
- __pyx_t_1 = PyNumber_Add(__pyx_kp_s_Strides_of_the_output_array_must, __pyx_kp_s_less_than); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_kp_s_Strides_of_the_output_array_must, __pyx_kp_s_less_than); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- /* "pyfftw/pyfftw.pyx":1057
+ /* "pyfftw/pyfftw.pyx":1059
* if self._output_item_strides[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Strides of the output array must be ' +
* 'less than ', str(limits.INT_MAX)) # <<<<<<<<<<<<<<
*
* fft_shape_lookup = functions['fft_shape_lookup']
*/
- __pyx_t_11 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
- __Pyx_GIVEREF(__pyx_t_11);
- PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11);
- __pyx_t_11 = 0;
- __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_10, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_10);
+ PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10);
+ __pyx_t_10 = 0;
+ __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_9, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- /* "pyfftw/pyfftw.pyx":1056
+ /* "pyfftw/pyfftw.pyx":1058
*
* if self._output_item_strides[i] >= <Py_ssize_t> limits.INT_MAX:
* raise ValueError('Strides of the output array must be ' + # <<<<<<<<<<<<<<
* 'less than ', str(limits.INT_MAX))
*
*/
- __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1);
- __Pyx_GIVEREF(__pyx_t_11);
- PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_11);
+ PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_10);
+ PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_10);
__pyx_t_1 = 0;
- __pyx_t_11 = 0;
- __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_10 = 0;
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __Pyx_Raise(__pyx_t_11, 0, 0, 0);
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1055
+ /* "pyfftw/pyfftw.pyx":1057
* 'less than ', str(limits.INT_MAX))
*
* if self._output_item_strides[i] >= <Py_ssize_t> limits.INT_MAX: # <<<<<<<<<<<<<<
@@ -10041,44 +10094,44 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
}
}
- /* "pyfftw/pyfftw.pyx":1059
+ /* "pyfftw/pyfftw.pyx":1061
* 'less than ', str(limits.INT_MAX))
*
* fft_shape_lookup = functions['fft_shape_lookup'] # <<<<<<<<<<<<<<
* if fft_shape_lookup == -1:
* fft_shape = self._input_shape
*/
- __pyx_t_11 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_fft_shape_lookup); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1059; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_v_fft_shape_lookup = __pyx_t_11;
- __pyx_t_11 = 0;
+ __pyx_t_10 = PyObject_GetItem(__pyx_v_functions, __pyx_n_s_fft_shape_lookup); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1061; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_v_fft_shape_lookup = __pyx_t_10;
+ __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1060
+ /* "pyfftw/pyfftw.pyx":1062
*
* fft_shape_lookup = functions['fft_shape_lookup']
* if fft_shape_lookup == -1: # <<<<<<<<<<<<<<
* fft_shape = self._input_shape
* else:
*/
- __pyx_t_11 = __Pyx_PyInt_EqObjC(__pyx_v_fft_shape_lookup, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1060; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1060; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = __Pyx_PyInt_EqObjC(__pyx_v_fft_shape_lookup, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1062; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1062; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1061
+ /* "pyfftw/pyfftw.pyx":1063
* fft_shape_lookup = functions['fft_shape_lookup']
* if fft_shape_lookup == -1:
* fft_shape = self._input_shape # <<<<<<<<<<<<<<
* else:
* fft_shape = fft_shape_lookup(input_array, output_array)
*/
- __pyx_t_11 = __pyx_v_self->_input_shape;
- __Pyx_INCREF(__pyx_t_11);
- __pyx_v_fft_shape = __pyx_t_11;
- __pyx_t_11 = 0;
+ __pyx_t_10 = __pyx_v_self->_input_shape;
+ __Pyx_INCREF(__pyx_t_10);
+ __pyx_v_fft_shape = __pyx_t_10;
+ __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1060
+ /* "pyfftw/pyfftw.pyx":1062
*
* fft_shape_lookup = functions['fft_shape_lookup']
* if fft_shape_lookup == -1: # <<<<<<<<<<<<<<
@@ -10088,7 +10141,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
goto __pyx_L84;
}
- /* "pyfftw/pyfftw.pyx":1063
+ /* "pyfftw/pyfftw.pyx":1065
* fft_shape = self._input_shape
* else:
* fft_shape = fft_shape_lookup(input_array, output_array) # <<<<<<<<<<<<<<
@@ -10097,63 +10150,63 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
/*else*/ {
__Pyx_INCREF(__pyx_v_fft_shape_lookup);
- __pyx_t_10 = __pyx_v_fft_shape_lookup; __pyx_t_1 = NULL;
+ __pyx_t_9 = __pyx_v_fft_shape_lookup; __pyx_t_1 = NULL;
__pyx_t_12 = 0;
- if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_10))) {
- __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_10);
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_9))) {
+ __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9);
if (likely(__pyx_t_1)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_10, function);
+ __Pyx_DECREF_SET(__pyx_t_9, function);
__pyx_t_12 = 1;
}
}
- __pyx_t_9 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1063; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_18 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1065; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_18);
if (__pyx_t_1) {
- __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_1); __pyx_t_1 = NULL;
+ __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_1); __pyx_t_1 = NULL;
}
__Pyx_INCREF(__pyx_v_input_array);
__Pyx_GIVEREF(__pyx_v_input_array);
- PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_12, __pyx_v_input_array);
+ PyTuple_SET_ITEM(__pyx_t_18, 0+__pyx_t_12, __pyx_v_input_array);
__Pyx_INCREF(__pyx_v_output_array);
__Pyx_GIVEREF(__pyx_v_output_array);
- PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_12, __pyx_v_output_array);
- __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_9, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1063; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
+ PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_12, __pyx_v_output_array);
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_18, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1065; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_v_fft_shape = __pyx_t_11;
- __pyx_t_11 = 0;
+ __pyx_v_fft_shape = __pyx_t_10;
+ __pyx_t_10 = 0;
}
__pyx_L84:;
- /* "pyfftw/pyfftw.pyx":1066
+ /* "pyfftw/pyfftw.pyx":1068
*
* # Fill in the stride and shape information
* input_strides_array = self._input_item_strides # <<<<<<<<<<<<<<
* output_strides_array = self._output_item_strides
* for i in range(0, self._rank):
*/
- __pyx_t_11 = __pyx_v_self->_input_item_strides;
- __Pyx_INCREF(__pyx_t_11);
- __pyx_v_input_strides_array = __pyx_t_11;
- __pyx_t_11 = 0;
+ __pyx_t_10 = __pyx_v_self->_input_item_strides;
+ __Pyx_INCREF(__pyx_t_10);
+ __pyx_v_input_strides_array = __pyx_t_10;
+ __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1067
+ /* "pyfftw/pyfftw.pyx":1069
* # Fill in the stride and shape information
* input_strides_array = self._input_item_strides
* output_strides_array = self._output_item_strides # <<<<<<<<<<<<<<
* for i in range(0, self._rank):
* self._dims[i]._n = fft_shape[self._axes[i]]
*/
- __pyx_t_11 = __pyx_v_self->_output_item_strides;
- __Pyx_INCREF(__pyx_t_11);
- __pyx_v_output_strides_array = __pyx_t_11;
- __pyx_t_11 = 0;
+ __pyx_t_10 = __pyx_v_self->_output_item_strides;
+ __Pyx_INCREF(__pyx_t_10);
+ __pyx_v_output_strides_array = __pyx_t_10;
+ __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1068
+ /* "pyfftw/pyfftw.pyx":1070
* input_strides_array = self._input_item_strides
* output_strides_array = self._output_item_strides
* for i in range(0, self._rank): # <<<<<<<<<<<<<<
@@ -10164,47 +10217,47 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
for (__pyx_t_22 = 0; __pyx_t_22 < __pyx_t_8; __pyx_t_22+=1) {
__pyx_v_i = __pyx_t_22;
- /* "pyfftw/pyfftw.pyx":1069
+ /* "pyfftw/pyfftw.pyx":1071
* output_strides_array = self._output_item_strides
* for i in range(0, self._rank):
* self._dims[i]._n = fft_shape[self._axes[i]] # <<<<<<<<<<<<<<
* self._dims[i]._is = input_strides_array[self._axes[i]]
* self._dims[i]._os = output_strides_array[self._axes[i]]
*/
- __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_fft_shape, (__pyx_v_self->_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1069; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1069; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_fft_shape, (__pyx_v_self->_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1071; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1071; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
(__pyx_v_self->_dims[__pyx_v_i])._n = __pyx_t_23;
- /* "pyfftw/pyfftw.pyx":1070
+ /* "pyfftw/pyfftw.pyx":1072
* for i in range(0, self._rank):
* self._dims[i]._n = fft_shape[self._axes[i]]
* self._dims[i]._is = input_strides_array[self._axes[i]] # <<<<<<<<<<<<<<
* self._dims[i]._os = output_strides_array[self._axes[i]]
*
*/
- __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_input_strides_array, (__pyx_v_self->_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1070; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1070; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_input_strides_array, (__pyx_v_self->_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1072; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1072; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
(__pyx_v_self->_dims[__pyx_v_i])._is = __pyx_t_23;
- /* "pyfftw/pyfftw.pyx":1071
+ /* "pyfftw/pyfftw.pyx":1073
* self._dims[i]._n = fft_shape[self._axes[i]]
* self._dims[i]._is = input_strides_array[self._axes[i]]
* self._dims[i]._os = output_strides_array[self._axes[i]] # <<<<<<<<<<<<<<
*
* for i in range(0, self._howmany_rank):
*/
- __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_output_strides_array, (__pyx_v_self->_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1071; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1071; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_output_strides_array, (__pyx_v_self->_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1073; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1073; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
(__pyx_v_self->_dims[__pyx_v_i])._os = __pyx_t_23;
}
- /* "pyfftw/pyfftw.pyx":1073
+ /* "pyfftw/pyfftw.pyx":1075
* self._dims[i]._os = output_strides_array[self._axes[i]]
*
* for i in range(0, self._howmany_rank): # <<<<<<<<<<<<<<
@@ -10215,47 +10268,47 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
for (__pyx_t_22 = 0; __pyx_t_22 < __pyx_t_8; __pyx_t_22+=1) {
__pyx_v_i = __pyx_t_22;
- /* "pyfftw/pyfftw.pyx":1074
+ /* "pyfftw/pyfftw.pyx":1076
*
* for i in range(0, self._howmany_rank):
* self._howmany_dims[i]._n = fft_shape[self._not_axes[i]] # <<<<<<<<<<<<<<
* self._howmany_dims[i]._is = input_strides_array[self._not_axes[i]]
* self._howmany_dims[i]._os = output_strides_array[self._not_axes[i]]
*/
- __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_fft_shape, (__pyx_v_self->_not_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1074; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1074; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_fft_shape, (__pyx_v_self->_not_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1076; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1076; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
(__pyx_v_self->_howmany_dims[__pyx_v_i])._n = __pyx_t_23;
- /* "pyfftw/pyfftw.pyx":1075
+ /* "pyfftw/pyfftw.pyx":1077
* for i in range(0, self._howmany_rank):
* self._howmany_dims[i]._n = fft_shape[self._not_axes[i]]
* self._howmany_dims[i]._is = input_strides_array[self._not_axes[i]] # <<<<<<<<<<<<<<
* self._howmany_dims[i]._os = output_strides_array[self._not_axes[i]]
*
*/
- __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_input_strides_array, (__pyx_v_self->_not_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1075; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1075; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_input_strides_array, (__pyx_v_self->_not_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1077; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1077; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
(__pyx_v_self->_howmany_dims[__pyx_v_i])._is = __pyx_t_23;
- /* "pyfftw/pyfftw.pyx":1076
+ /* "pyfftw/pyfftw.pyx":1078
* self._howmany_dims[i]._n = fft_shape[self._not_axes[i]]
* self._howmany_dims[i]._is = input_strides_array[self._not_axes[i]]
* self._howmany_dims[i]._os = output_strides_array[self._not_axes[i]] # <<<<<<<<<<<<<<
*
* ## Point at which FFTW calls are made
*/
- __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_output_strides_array, (__pyx_v_self->_not_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1076; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1076; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_output_strides_array, (__pyx_v_self->_not_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1078; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __Pyx_GOTREF(__pyx_t_10);
+ __pyx_t_23 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_23 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1078; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
(__pyx_v_self->_howmany_dims[__pyx_v_i])._os = __pyx_t_23;
}
- /* "pyfftw/pyfftw.pyx":1080
+ /* "pyfftw/pyfftw.pyx":1082
* ## Point at which FFTW calls are made
* ## (and none should be made before this)
* self._nthreads_plan_setter(threads) # <<<<<<<<<<<<<<
@@ -10264,7 +10317,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_nthreads_plan_setter(__pyx_v_threads);
- /* "pyfftw/pyfftw.pyx":1083
+ /* "pyfftw/pyfftw.pyx":1085
*
* # Set the timelimit
* set_timelimit_func(_planning_timelimit) # <<<<<<<<<<<<<<
@@ -10273,7 +10326,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_set_timelimit_func(__pyx_v__planning_timelimit);
- /* "pyfftw/pyfftw.pyx":1091
+ /* "pyfftw/pyfftw.pyx":1093
* # no self-lookups allowed in nogil block, so must grab all these first
* cdef void *plan
* cdef fftw_generic_plan_guru fftw_planner = self._fftw_planner # <<<<<<<<<<<<<<
@@ -10283,7 +10336,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_24 = __pyx_v_self->_fftw_planner;
__pyx_v_fftw_planner = __pyx_t_24;
- /* "pyfftw/pyfftw.pyx":1092
+ /* "pyfftw/pyfftw.pyx":1094
* cdef void *plan
* cdef fftw_generic_plan_guru fftw_planner = self._fftw_planner
* cdef int rank = self._rank # <<<<<<<<<<<<<<
@@ -10293,7 +10346,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_8 = __pyx_v_self->_rank;
__pyx_v_rank = __pyx_t_8;
- /* "pyfftw/pyfftw.pyx":1093
+ /* "pyfftw/pyfftw.pyx":1095
* cdef fftw_generic_plan_guru fftw_planner = self._fftw_planner
* cdef int rank = self._rank
* cdef fftw_iodim *dims = <fftw_iodim *>self._dims # <<<<<<<<<<<<<<
@@ -10302,7 +10355,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_dims = ((fftw_iodim *)__pyx_v_self->_dims);
- /* "pyfftw/pyfftw.pyx":1094
+ /* "pyfftw/pyfftw.pyx":1096
* cdef int rank = self._rank
* cdef fftw_iodim *dims = <fftw_iodim *>self._dims
* cdef int howmany_rank = self._howmany_rank # <<<<<<<<<<<<<<
@@ -10312,7 +10365,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_8 = __pyx_v_self->_howmany_rank;
__pyx_v_howmany_rank = __pyx_t_8;
- /* "pyfftw/pyfftw.pyx":1095
+ /* "pyfftw/pyfftw.pyx":1097
* cdef fftw_iodim *dims = <fftw_iodim *>self._dims
* cdef int howmany_rank = self._howmany_rank
* cdef fftw_iodim *howmany_dims = <fftw_iodim *>self._howmany_dims # <<<<<<<<<<<<<<
@@ -10321,31 +10374,31 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_howmany_dims = ((fftw_iodim *)__pyx_v_self->_howmany_dims);
- /* "pyfftw/pyfftw.pyx":1096
+ /* "pyfftw/pyfftw.pyx":1098
* cdef int howmany_rank = self._howmany_rank
* cdef fftw_iodim *howmany_dims = <fftw_iodim *>self._howmany_dims
* cdef void *_in = <void *>np.PyArray_DATA(self._input_array) # <<<<<<<<<<<<<<
* cdef void *_out = <void *>np.PyArray_DATA(self._output_array)
* cdef int sign = self._direction
*/
- __pyx_t_11 = ((PyObject *)__pyx_v_self->_input_array);
- __Pyx_INCREF(__pyx_t_11);
- __pyx_v__in = ((void *)PyArray_DATA(((PyArrayObject *)__pyx_t_11)));
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = ((PyObject *)__pyx_v_self->_input_array);
+ __Pyx_INCREF(__pyx_t_10);
+ __pyx_v__in = ((void *)PyArray_DATA(((PyArrayObject *)__pyx_t_10)));
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1097
+ /* "pyfftw/pyfftw.pyx":1099
* cdef fftw_iodim *howmany_dims = <fftw_iodim *>self._howmany_dims
* cdef void *_in = <void *>np.PyArray_DATA(self._input_array)
* cdef void *_out = <void *>np.PyArray_DATA(self._output_array) # <<<<<<<<<<<<<<
* cdef int sign = self._direction
* cdef unsigned c_flags = self._flags
*/
- __pyx_t_11 = ((PyObject *)__pyx_v_self->_output_array);
- __Pyx_INCREF(__pyx_t_11);
- __pyx_v__out = ((void *)PyArray_DATA(((PyArrayObject *)__pyx_t_11)));
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_10 = ((PyObject *)__pyx_v_self->_output_array);
+ __Pyx_INCREF(__pyx_t_10);
+ __pyx_v__out = ((void *)PyArray_DATA(((PyArrayObject *)__pyx_t_10)));
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- /* "pyfftw/pyfftw.pyx":1098
+ /* "pyfftw/pyfftw.pyx":1100
* cdef void *_in = <void *>np.PyArray_DATA(self._input_array)
* cdef void *_out = <void *>np.PyArray_DATA(self._output_array)
* cdef int sign = self._direction # <<<<<<<<<<<<<<
@@ -10355,17 +10408,17 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_8 = __pyx_v_self->_direction;
__pyx_v_sign = __pyx_t_8;
- /* "pyfftw/pyfftw.pyx":1099
+ /* "pyfftw/pyfftw.pyx":1101
* cdef void *_out = <void *>np.PyArray_DATA(self._output_array)
* cdef int sign = self._direction
* cdef unsigned c_flags = self._flags # <<<<<<<<<<<<<<
*
* with plan_lock, nogil:
*/
- __pyx_t_18 = __pyx_v_self->_flags;
- __pyx_v_c_flags = __pyx_t_18;
+ __pyx_t_19 = __pyx_v_self->_flags;
+ __pyx_v_c_flags = __pyx_t_19;
- /* "pyfftw/pyfftw.pyx":1101
+ /* "pyfftw/pyfftw.pyx":1103
* cdef unsigned c_flags = self._flags
*
* with plan_lock, nogil: # <<<<<<<<<<<<<<
@@ -10373,29 +10426,29 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
* _in, _out, sign, c_flags)
*/
/*with:*/ {
- __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_v_6pyfftw_6pyfftw_plan_lock, __pyx_n_s_exit); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1101; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_v_6pyfftw_6pyfftw_plan_lock, __pyx_n_s_exit); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1103; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = __Pyx_PyObject_LookupSpecial(__pyx_v_6pyfftw_6pyfftw_plan_lock, __pyx_n_s_enter); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1101; __pyx_clineno = __LINE__; goto __pyx_L89_error;}
- __Pyx_GOTREF(__pyx_t_10);
- __pyx_t_9 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_10))) {
- __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10);
- if (likely(__pyx_t_9)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
- __Pyx_INCREF(__pyx_t_9);
+ __pyx_t_9 = __Pyx_PyObject_LookupSpecial(__pyx_v_6pyfftw_6pyfftw_plan_lock, __pyx_n_s_enter); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1103; __pyx_clineno = __LINE__; goto __pyx_L89_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __pyx_t_18 = NULL;
+ if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_9))) {
+ __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_9);
+ if (likely(__pyx_t_18)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+ __Pyx_INCREF(__pyx_t_18);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_10, function);
+ __Pyx_DECREF_SET(__pyx_t_9, function);
}
}
- if (__pyx_t_9) {
- __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1101; __pyx_clineno = __LINE__; goto __pyx_L89_error;}
- __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ if (__pyx_t_18) {
+ __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_18); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1103; __pyx_clineno = __LINE__; goto __pyx_L89_error;}
+ __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
} else {
- __pyx_t_11 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1101; __pyx_clineno = __LINE__; goto __pyx_L89_error;}
+ __pyx_t_10 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1103; __pyx_clineno = __LINE__; goto __pyx_L89_error;}
}
- __Pyx_GOTREF(__pyx_t_11);
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/*try:*/ {
{
if (__pyx_t_5||__pyx_t_4||__pyx_t_25); else {/*mark used*/}
@@ -10407,7 +10460,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
#endif
/*try:*/ {
- /* "pyfftw/pyfftw.pyx":1102
+ /* "pyfftw/pyfftw.pyx":1104
*
* with plan_lock, nogil:
* plan = fftw_planner(rank, dims, howmany_rank, howmany_dims, # <<<<<<<<<<<<<<
@@ -10417,7 +10470,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_v_plan = __pyx_v_fftw_planner(__pyx_v_rank, __pyx_v_dims, __pyx_v_howmany_rank, __pyx_v_howmany_dims, __pyx_v__in, __pyx_v__out, __pyx_v_sign, __pyx_v_c_flags);
}
- /* "pyfftw/pyfftw.pyx":1101
+ /* "pyfftw/pyfftw.pyx":1103
* cdef unsigned c_flags = self._flags
*
* with plan_lock, nogil: # <<<<<<<<<<<<<<
@@ -10442,7 +10495,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
if (__pyx_t_6) {
__pyx_t_25 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__18, NULL);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (unlikely(!__pyx_t_25)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1101; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(!__pyx_t_25)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1103; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_25);
__Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
}
@@ -10457,7 +10510,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_L106:;
}
- /* "pyfftw/pyfftw.pyx":1104
+ /* "pyfftw/pyfftw.pyx":1106
* plan = fftw_planner(rank, dims, howmany_rank, howmany_dims,
* _in, _out, sign, c_flags)
* self._plan = plan # <<<<<<<<<<<<<<
@@ -10466,7 +10519,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
__pyx_v_self->_plan = __pyx_v_plan;
- /* "pyfftw/pyfftw.pyx":1106
+ /* "pyfftw/pyfftw.pyx":1108
* self._plan = plan
*
* if self._plan == NULL: # <<<<<<<<<<<<<<
@@ -10476,31 +10529,31 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__pyx_t_2 = ((__pyx_v_self->_plan == NULL) != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1107
+ /* "pyfftw/pyfftw.pyx":1109
*
* if self._plan == NULL:
* if 'FFTW_WISDOM_ONLY' in flags: # <<<<<<<<<<<<<<
* raise RuntimeError('No FFTW wisdom is known for this plan.')
* else:
*/
- __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_FFTW_WISDOM_ONLY, __pyx_v_flags, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1107; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_FFTW_WISDOM_ONLY, __pyx_v_flags, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1109; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_t_21 = (__pyx_t_2 != 0);
if (__pyx_t_21) {
- /* "pyfftw/pyfftw.pyx":1108
+ /* "pyfftw/pyfftw.pyx":1110
* if self._plan == NULL:
* if 'FFTW_WISDOM_ONLY' in flags:
* raise RuntimeError('No FFTW wisdom is known for this plan.') # <<<<<<<<<<<<<<
* else:
* raise RuntimeError('The data has an uncaught error that led '+
*/
- __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1108; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __Pyx_Raise(__pyx_t_11, 0, 0, 0);
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1108; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_Raise(__pyx_t_10, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1107
+ /* "pyfftw/pyfftw.pyx":1109
*
* if self._plan == NULL:
* if 'FFTW_WISDOM_ONLY' in flags: # <<<<<<<<<<<<<<
@@ -10509,7 +10562,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":1110
+ /* "pyfftw/pyfftw.pyx":1112
* raise RuntimeError('No FFTW wisdom is known for this plan.')
* else:
* raise RuntimeError('The data has an uncaught error that led '+ # <<<<<<<<<<<<<<
@@ -10517,22 +10570,22 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*
*/
/*else*/ {
- __pyx_t_11 = PyNumber_Add(__pyx_kp_s_The_data_has_an_uncaught_error_t, __pyx_kp_s_to_the_planner_returning_NULL_Th); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyNumber_Add(__pyx_kp_s_The_data_has_an_uncaught_error_t, __pyx_kp_s_to_the_planner_returning_NULL_Th); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1112; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_10);
- __Pyx_GIVEREF(__pyx_t_11);
- PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11);
- __pyx_t_11 = 0;
- __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1112; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_10);
+ PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10);
+ __pyx_t_10 = 0;
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1112; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __Pyx_Raise(__pyx_t_11, 0, 0, 0);
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1112; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
- /* "pyfftw/pyfftw.pyx":1106
+ /* "pyfftw/pyfftw.pyx":1108
* self._plan = plan
*
* if self._plan == NULL: # <<<<<<<<<<<<<<
@@ -10541,7 +10594,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
*/
}
- /* "pyfftw/pyfftw.pyx":811
+ /* "pyfftw/pyfftw.pyx":812
* axes = property(_get_axes)
*
* def __cinit__(self, input_array, output_array, axes=(-1,), # <<<<<<<<<<<<<<
@@ -10557,7 +10610,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_11);
- __Pyx_XDECREF(__pyx_t_19);
+ __Pyx_XDECREF(__pyx_t_18);
__Pyx_XDECREF(__pyx_t_20);
__Pyx_AddTraceback("pyfftw.pyfftw.FFTW.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
@@ -10579,7 +10632,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":1113
+/* "pyfftw/pyfftw.pyx":1115
* 'to the planner returning NULL. This is a bug.')
*
* def __init__(self, input_array, output_array, axes=(-1,), # <<<<<<<<<<<<<<
@@ -10589,7 +10642,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_30__cinit__(struct __pyx_obj_6pyfftw_6
/* Python wrapper */
static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_33__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_32__init__[] = "\n **Arguments**:\n\n * ``input_array`` and ``output_array`` should be numpy arrays.\n The contents of these arrays will be destroyed by the planning \n process during initialisation. Information on supported \n dtypes for the arrays is :ref:`given below <scheme_table>`.\n \n * ``axes`` describes along which axes the DFT should be taken.\n This should be a valid lis [...]
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_32__init__[] = "\n **Arguments**:\n\n * ``input_array`` and ``output_array`` should be numpy arrays.\n The contents of these arrays will be destroyed by the planning\n process during initialisation. Information on supported\n dtypes for the arrays is :ref:`given below <scheme_table>`.\n\n * ``axes`` describes along which axes the DFT should be taken.\n This should be a valid list of axes. [...]
#if CYTHON_COMPILING_IN_CPYTHON
struct wrapperbase __pyx_wrapperbase_6pyfftw_6pyfftw_4FFTW_32__init__;
#endif
@@ -10613,7 +10666,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_33__init__(PyObject *__pyx_v_self, PyO
values[2] = ((PyObject *)__pyx_tuple__20);
values[3] = ((PyObject *)__pyx_n_s_FFTW_FORWARD);
- /* "pyfftw/pyfftw.pyx":1114
+ /* "pyfftw/pyfftw.pyx":1116
*
* def __init__(self, input_array, output_array, axes=(-1,),
* direction='FFTW_FORWARD', flags=('FFTW_MEASURE',), # <<<<<<<<<<<<<<
@@ -10622,7 +10675,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_33__init__(PyObject *__pyx_v_self, PyO
*/
values[4] = ((PyObject *)__pyx_tuple__21);
- /* "pyfftw/pyfftw.pyx":1115
+ /* "pyfftw/pyfftw.pyx":1117
* def __init__(self, input_array, output_array, axes=(-1,),
* direction='FFTW_FORWARD', flags=('FFTW_MEASURE',),
* int threads=1, planning_timelimit=None): # <<<<<<<<<<<<<<
@@ -10652,7 +10705,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_33__init__(PyObject *__pyx_v_self, PyO
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_output_array)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 7, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 7, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1115; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
}
case 2:
if (kw_args > 0) {
@@ -10681,7 +10734,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_33__init__(PyObject *__pyx_v_self, PyO
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1115; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -10702,7 +10755,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_33__init__(PyObject *__pyx_v_self, PyO
__pyx_v_direction = values[3];
__pyx_v_flags = values[4];
if (values[5]) {
- __pyx_v_threads = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_threads == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1115; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __pyx_v_threads = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_threads == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1117; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
} else {
__pyx_v_threads = ((int)1);
}
@@ -10710,7 +10763,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_33__init__(PyObject *__pyx_v_self, PyO
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 7, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 7, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1115; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
__pyx_L3_error:;
__Pyx_AddTraceback("pyfftw.pyfftw.FFTW.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -10718,7 +10771,7 @@ static int __pyx_pw_6pyfftw_6pyfftw_4FFTW_33__init__(PyObject *__pyx_v_self, PyO
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6pyfftw_6pyfftw_4FFTW_32__init__(((struct __pyx_obj_6pyfftw_6pyfftw_FFTW *)__pyx_v_self), __pyx_v_input_array, __pyx_v_output_array, __pyx_v_axes, __pyx_v_direction, __pyx_v_flags, __pyx_v_threads, __pyx_v_planning_timelimit);
- /* "pyfftw/pyfftw.pyx":1113
+ /* "pyfftw/pyfftw.pyx":1115
* 'to the planner returning NULL. This is a bug.')
*
* def __init__(self, input_array, output_array, axes=(-1,), # <<<<<<<<<<<<<<
@@ -10742,7 +10795,7 @@ static int __pyx_pf_6pyfftw_6pyfftw_4FFTW_32__init__(CYTHON_UNUSED struct __pyx_
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":1322
+/* "pyfftw/pyfftw.pyx":1324
* pass
*
* def __dealloc__(self): # <<<<<<<<<<<<<<
@@ -10766,7 +10819,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
int __pyx_t_1;
__Pyx_RefNannySetupContext("__dealloc__", 0);
- /* "pyfftw/pyfftw.pyx":1324
+ /* "pyfftw/pyfftw.pyx":1326
* def __dealloc__(self):
*
* if not self._axes == NULL: # <<<<<<<<<<<<<<
@@ -10776,7 +10829,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
__pyx_t_1 = ((!((__pyx_v_self->_axes == NULL) != 0)) != 0);
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1325
+ /* "pyfftw/pyfftw.pyx":1327
*
* if not self._axes == NULL:
* free(self._axes) # <<<<<<<<<<<<<<
@@ -10785,7 +10838,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
*/
free(__pyx_v_self->_axes);
- /* "pyfftw/pyfftw.pyx":1324
+ /* "pyfftw/pyfftw.pyx":1326
* def __dealloc__(self):
*
* if not self._axes == NULL: # <<<<<<<<<<<<<<
@@ -10794,7 +10847,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
*/
}
- /* "pyfftw/pyfftw.pyx":1327
+ /* "pyfftw/pyfftw.pyx":1329
* free(self._axes)
*
* if not self._not_axes == NULL: # <<<<<<<<<<<<<<
@@ -10804,7 +10857,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
__pyx_t_1 = ((!((__pyx_v_self->_not_axes == NULL) != 0)) != 0);
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1328
+ /* "pyfftw/pyfftw.pyx":1330
*
* if not self._not_axes == NULL:
* free(self._not_axes) # <<<<<<<<<<<<<<
@@ -10813,7 +10866,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
*/
free(__pyx_v_self->_not_axes);
- /* "pyfftw/pyfftw.pyx":1327
+ /* "pyfftw/pyfftw.pyx":1329
* free(self._axes)
*
* if not self._not_axes == NULL: # <<<<<<<<<<<<<<
@@ -10822,7 +10875,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
*/
}
- /* "pyfftw/pyfftw.pyx":1330
+ /* "pyfftw/pyfftw.pyx":1332
* free(self._not_axes)
*
* if not self._plan == NULL: # <<<<<<<<<<<<<<
@@ -10832,7 +10885,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
__pyx_t_1 = ((!((__pyx_v_self->_plan == NULL) != 0)) != 0);
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1331
+ /* "pyfftw/pyfftw.pyx":1333
*
* if not self._plan == NULL:
* self._fftw_destroy(self._plan) # <<<<<<<<<<<<<<
@@ -10841,7 +10894,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
*/
__pyx_v_self->_fftw_destroy(__pyx_v_self->_plan);
- /* "pyfftw/pyfftw.pyx":1330
+ /* "pyfftw/pyfftw.pyx":1332
* free(self._not_axes)
*
* if not self._plan == NULL: # <<<<<<<<<<<<<<
@@ -10850,7 +10903,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
*/
}
- /* "pyfftw/pyfftw.pyx":1333
+ /* "pyfftw/pyfftw.pyx":1335
* self._fftw_destroy(self._plan)
*
* if not self._dims == NULL: # <<<<<<<<<<<<<<
@@ -10860,7 +10913,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
__pyx_t_1 = ((!((__pyx_v_self->_dims == NULL) != 0)) != 0);
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1334
+ /* "pyfftw/pyfftw.pyx":1336
*
* if not self._dims == NULL:
* free(self._dims) # <<<<<<<<<<<<<<
@@ -10869,7 +10922,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
*/
free(__pyx_v_self->_dims);
- /* "pyfftw/pyfftw.pyx":1333
+ /* "pyfftw/pyfftw.pyx":1335
* self._fftw_destroy(self._plan)
*
* if not self._dims == NULL: # <<<<<<<<<<<<<<
@@ -10878,7 +10931,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
*/
}
- /* "pyfftw/pyfftw.pyx":1336
+ /* "pyfftw/pyfftw.pyx":1338
* free(self._dims)
*
* if not self._howmany_dims == NULL: # <<<<<<<<<<<<<<
@@ -10888,7 +10941,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
__pyx_t_1 = ((!((__pyx_v_self->_howmany_dims == NULL) != 0)) != 0);
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1337
+ /* "pyfftw/pyfftw.pyx":1339
*
* if not self._howmany_dims == NULL:
* free(self._howmany_dims) # <<<<<<<<<<<<<<
@@ -10897,7 +10950,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
*/
free(__pyx_v_self->_howmany_dims);
- /* "pyfftw/pyfftw.pyx":1336
+ /* "pyfftw/pyfftw.pyx":1338
* free(self._dims)
*
* if not self._howmany_dims == NULL: # <<<<<<<<<<<<<<
@@ -10906,7 +10959,7 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
*/
}
- /* "pyfftw/pyfftw.pyx":1322
+ /* "pyfftw/pyfftw.pyx":1324
* pass
*
* def __dealloc__(self): # <<<<<<<<<<<<<<
@@ -10918,17 +10971,17 @@ static void __pyx_pf_6pyfftw_6pyfftw_4FFTW_34__dealloc__(struct __pyx_obj_6pyfft
__Pyx_RefNannyFinishContext();
}
-/* "pyfftw/pyfftw.pyx":1339
+/* "pyfftw/pyfftw.pyx":1341
* free(self._howmany_dims)
*
* def __call__(self, input_array=None, output_array=None, # <<<<<<<<<<<<<<
- * normalise_idft=True):
- * '''__call__(input_array=None, output_array=None, normalise_idft=True)
+ * normalise_idft=True, ortho=False):
+ * '''__call__(input_array=None, output_array=None, normalise_idft=True,
*/
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_37__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_36__call__[] = "__call__(input_array=None, output_array=None, normalise_idft=True)\n\n Calling the class instance (optionally) updates the arrays, then\n calls :meth:`~pyfftw.FFTW.execute`, before optionally normalising \n the output and returning the output array.\n\n It has some built-in helpers to make life simpler for the calling\n functions (as distinct from manually updating the arrays and\n calli [...]
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_36__call__[] = "__call__(input_array=None, output_array=None, normalise_idft=True,\n ortho=False)\n\n Calling the class instance (optionally) updates the arrays, then\n calls :meth:`~pyfftw.FFTW.execute`, before optionally normalising\n the output and returning the output array.\n\n It has some built-in helpers to make life simpler for the calling\n functions (as distinct from manually updat [...]
#if CYTHON_COMPILING_IN_CPYTHON
struct wrapperbase __pyx_wrapperbase_6pyfftw_6pyfftw_4FFTW_36__call__;
#endif
@@ -10936,6 +10989,7 @@ static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_37__call__(PyObject *__pyx_v_sel
PyObject *__pyx_v_input_array = 0;
PyObject *__pyx_v_output_array = 0;
PyObject *__pyx_v_normalise_idft = 0;
+ PyObject *__pyx_v_ortho = 0;
int __pyx_lineno = 0;
const char *__pyx_filename = NULL;
int __pyx_clineno = 0;
@@ -10943,23 +10997,25 @@ static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_37__call__(PyObject *__pyx_v_sel
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__call__ (wrapper)", 0);
{
- static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_input_array,&__pyx_n_s_output_array,&__pyx_n_s_normalise_idft,0};
- PyObject* values[3] = {0,0,0};
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_input_array,&__pyx_n_s_output_array,&__pyx_n_s_normalise_idft,&__pyx_n_s_ortho,0};
+ PyObject* values[4] = {0,0,0,0};
values[0] = ((PyObject *)Py_None);
values[1] = ((PyObject *)Py_None);
- /* "pyfftw/pyfftw.pyx":1340
+ /* "pyfftw/pyfftw.pyx":1342
*
* def __call__(self, input_array=None, output_array=None,
- * normalise_idft=True): # <<<<<<<<<<<<<<
- * '''__call__(input_array=None, output_array=None, normalise_idft=True)
- *
+ * normalise_idft=True, ortho=False): # <<<<<<<<<<<<<<
+ * '''__call__(input_array=None, output_array=None, normalise_idft=True,
+ * ortho=False)
*/
values[2] = ((PyObject *)Py_True);
+ values[3] = ((PyObject *)Py_False);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
@@ -10983,12 +11039,18 @@ static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_37__call__(PyObject *__pyx_v_sel
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_normalise_idft);
if (value) { values[2] = value; kw_args--; }
}
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ortho);
+ if (value) { values[3] = value; kw_args--; }
+ }
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1339; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1341; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
@@ -10999,23 +11061,24 @@ static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_37__call__(PyObject *__pyx_v_sel
__pyx_v_input_array = values[0];
__pyx_v_output_array = values[1];
__pyx_v_normalise_idft = values[2];
+ __pyx_v_ortho = values[3];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__call__", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1339; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__call__", 0, 0, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1341; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
__pyx_L3_error:;
__Pyx_AddTraceback("pyfftw.pyfftw.FFTW.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
- __pyx_r = __pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(((struct __pyx_obj_6pyfftw_6pyfftw_FFTW *)__pyx_v_self), __pyx_v_input_array, __pyx_v_output_array, __pyx_v_normalise_idft);
+ __pyx_r = __pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(((struct __pyx_obj_6pyfftw_6pyfftw_FFTW *)__pyx_v_self), __pyx_v_input_array, __pyx_v_output_array, __pyx_v_normalise_idft, __pyx_v_ortho);
- /* "pyfftw/pyfftw.pyx":1339
+ /* "pyfftw/pyfftw.pyx":1341
* free(self._howmany_dims)
*
* def __call__(self, input_array=None, output_array=None, # <<<<<<<<<<<<<<
- * normalise_idft=True):
- * '''__call__(input_array=None, output_array=None, normalise_idft=True)
+ * normalise_idft=True, ortho=False):
+ * '''__call__(input_array=None, output_array=None, normalise_idft=True,
*/
/* function exit code */
@@ -11023,14 +11086,14 @@ static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_37__call__(PyObject *__pyx_v_sel
return __pyx_r;
}
-static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyfftw_6pyfftw_FFTW *__pyx_v_self, PyObject *__pyx_v_input_array, PyObject *__pyx_v_output_array, PyObject *__pyx_v_normalise_idft) {
+static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyfftw_6pyfftw_FFTW *__pyx_v_self, PyObject *__pyx_v_input_array, PyObject *__pyx_v_output_array, PyObject *__pyx_v_normalise_idft, PyObject *__pyx_v_ortho) {
int __pyx_v_copy_needed;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
- int __pyx_t_3;
- PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
@@ -11041,27 +11104,67 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
__Pyx_INCREF(__pyx_v_input_array);
__Pyx_INCREF(__pyx_v_output_array);
- /* "pyfftw/pyfftw.pyx":1397
+ /* "pyfftw/pyfftw.pyx":1411
+ * '''
+ *
+ * if ortho and normalise_idft: # <<<<<<<<<<<<<<
+ * raise ValueError('Invalid options: ortho and normalise_idft cannot'
+ * ' both be True.')
+ */
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_ortho); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__pyx_t_2) {
+ } else {
+ __pyx_t_1 = __pyx_t_2;
+ goto __pyx_L4_bool_binop_done;
+ }
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_normalise_idft); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_t_2;
+ __pyx_L4_bool_binop_done:;
+ if (__pyx_t_1) {
+
+ /* "pyfftw/pyfftw.pyx":1412
+ *
+ * if ortho and normalise_idft:
+ * raise ValueError('Invalid options: ortho and normalise_idft cannot' # <<<<<<<<<<<<<<
+ * ' both be True.')
+ *
+ */
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+
+ /* "pyfftw/pyfftw.pyx":1411
* '''
*
+ * if ortho and normalise_idft: # <<<<<<<<<<<<<<
+ * raise ValueError('Invalid options: ortho and normalise_idft cannot'
+ * ' both be True.')
+ */
+ }
+
+ /* "pyfftw/pyfftw.pyx":1415
+ * ' both be True.')
+ *
* if input_array is not None or output_array is not None: # <<<<<<<<<<<<<<
*
* if input_array is None:
*/
__pyx_t_2 = (__pyx_v_input_array != Py_None);
- __pyx_t_3 = (__pyx_t_2 != 0);
- if (!__pyx_t_3) {
+ __pyx_t_4 = (__pyx_t_2 != 0);
+ if (!__pyx_t_4) {
} else {
- __pyx_t_1 = __pyx_t_3;
- goto __pyx_L4_bool_binop_done;
+ __pyx_t_1 = __pyx_t_4;
+ goto __pyx_L7_bool_binop_done;
}
- __pyx_t_3 = (__pyx_v_output_array != Py_None);
- __pyx_t_2 = (__pyx_t_3 != 0);
+ __pyx_t_4 = (__pyx_v_output_array != Py_None);
+ __pyx_t_2 = (__pyx_t_4 != 0);
__pyx_t_1 = __pyx_t_2;
- __pyx_L4_bool_binop_done:;
+ __pyx_L7_bool_binop_done:;
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1399
+ /* "pyfftw/pyfftw.pyx":1417
* if input_array is not None or output_array is not None:
*
* if input_array is None: # <<<<<<<<<<<<<<
@@ -11072,19 +11175,19 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1400
+ /* "pyfftw/pyfftw.pyx":1418
*
* if input_array is None:
* input_array = self._input_array # <<<<<<<<<<<<<<
*
* if output_array is None:
*/
- __pyx_t_4 = ((PyObject *)__pyx_v_self->_input_array);
- __Pyx_INCREF(__pyx_t_4);
- __Pyx_DECREF_SET(__pyx_v_input_array, __pyx_t_4);
- __pyx_t_4 = 0;
+ __pyx_t_3 = ((PyObject *)__pyx_v_self->_input_array);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_DECREF_SET(__pyx_v_input_array, __pyx_t_3);
+ __pyx_t_3 = 0;
- /* "pyfftw/pyfftw.pyx":1399
+ /* "pyfftw/pyfftw.pyx":1417
* if input_array is not None or output_array is not None:
*
* if input_array is None: # <<<<<<<<<<<<<<
@@ -11093,7 +11196,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
*/
}
- /* "pyfftw/pyfftw.pyx":1402
+ /* "pyfftw/pyfftw.pyx":1420
* input_array = self._input_array
*
* if output_array is None: # <<<<<<<<<<<<<<
@@ -11104,19 +11207,19 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1403
+ /* "pyfftw/pyfftw.pyx":1421
*
* if output_array is None:
* output_array = self._output_array # <<<<<<<<<<<<<<
*
* if not isinstance(input_array, np.ndarray):
*/
- __pyx_t_4 = ((PyObject *)__pyx_v_self->_output_array);
- __Pyx_INCREF(__pyx_t_4);
- __Pyx_DECREF_SET(__pyx_v_output_array, __pyx_t_4);
- __pyx_t_4 = 0;
+ __pyx_t_3 = ((PyObject *)__pyx_v_self->_output_array);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_DECREF_SET(__pyx_v_output_array, __pyx_t_3);
+ __pyx_t_3 = 0;
- /* "pyfftw/pyfftw.pyx":1402
+ /* "pyfftw/pyfftw.pyx":1420
* input_array = self._input_array
*
* if output_array is None: # <<<<<<<<<<<<<<
@@ -11125,7 +11228,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
*/
}
- /* "pyfftw/pyfftw.pyx":1405
+ /* "pyfftw/pyfftw.pyx":1423
* output_array = self._output_array
*
* if not isinstance(input_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -11136,7 +11239,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
__pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1406
+ /* "pyfftw/pyfftw.pyx":1424
*
* if not isinstance(input_array, np.ndarray):
* copy_needed = True # <<<<<<<<<<<<<<
@@ -11145,33 +11248,33 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
*/
__pyx_v_copy_needed = 1;
- /* "pyfftw/pyfftw.pyx":1405
+ /* "pyfftw/pyfftw.pyx":1423
* output_array = self._output_array
*
* if not isinstance(input_array, np.ndarray): # <<<<<<<<<<<<<<
* copy_needed = True
* elif (not input_array.dtype == self._input_dtype):
*/
- goto __pyx_L8;
+ goto __pyx_L11;
}
- /* "pyfftw/pyfftw.pyx":1407
+ /* "pyfftw/pyfftw.pyx":1425
* if not isinstance(input_array, np.ndarray):
* copy_needed = True
* elif (not input_array.dtype == self._input_dtype): # <<<<<<<<<<<<<<
* copy_needed = True
* elif (not input_array.strides == self._input_strides):
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1407; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_v_self->_input_dtype, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1407; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1407; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1425; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_v_self->_input_dtype, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1425; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1425; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_1 = ((!__pyx_t_2) != 0);
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1408
+ /* "pyfftw/pyfftw.pyx":1426
* copy_needed = True
* elif (not input_array.dtype == self._input_dtype):
* copy_needed = True # <<<<<<<<<<<<<<
@@ -11180,33 +11283,33 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
*/
__pyx_v_copy_needed = 1;
- /* "pyfftw/pyfftw.pyx":1407
+ /* "pyfftw/pyfftw.pyx":1425
* if not isinstance(input_array, np.ndarray):
* copy_needed = True
* elif (not input_array.dtype == self._input_dtype): # <<<<<<<<<<<<<<
* copy_needed = True
* elif (not input_array.strides == self._input_strides):
*/
- goto __pyx_L8;
+ goto __pyx_L11;
}
- /* "pyfftw/pyfftw.pyx":1409
+ /* "pyfftw/pyfftw.pyx":1427
* elif (not input_array.dtype == self._input_dtype):
* copy_needed = True
* elif (not input_array.strides == self._input_strides): # <<<<<<<<<<<<<<
* copy_needed = True
* elif not (<intptr_t>np.PyArray_DATA(input_array)
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1427; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_v_self->_input_strides, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_v_self->_input_strides, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1427; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1427; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = ((!__pyx_t_1) != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1410
+ /* "pyfftw/pyfftw.pyx":1428
* copy_needed = True
* elif (not input_array.strides == self._input_strides):
* copy_needed = True # <<<<<<<<<<<<<<
@@ -11215,47 +11318,47 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
*/
__pyx_v_copy_needed = 1;
- /* "pyfftw/pyfftw.pyx":1409
+ /* "pyfftw/pyfftw.pyx":1427
* elif (not input_array.dtype == self._input_dtype):
* copy_needed = True
* elif (not input_array.strides == self._input_strides): # <<<<<<<<<<<<<<
* copy_needed = True
* elif not (<intptr_t>np.PyArray_DATA(input_array)
*/
- goto __pyx_L8;
+ goto __pyx_L11;
}
- /* "pyfftw/pyfftw.pyx":1411
+ /* "pyfftw/pyfftw.pyx":1429
* elif (not input_array.strides == self._input_strides):
* copy_needed = True
* elif not (<intptr_t>np.PyArray_DATA(input_array) # <<<<<<<<<<<<<<
* % self.input_alignment == 0):
* copy_needed = True
*/
- if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_4 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_input_array)))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
+ if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1429; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_input_array)))); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1429; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_3);
- /* "pyfftw/pyfftw.pyx":1412
+ /* "pyfftw/pyfftw.pyx":1430
* copy_needed = True
* elif not (<intptr_t>np.PyArray_DATA(input_array)
* % self.input_alignment == 0): # <<<<<<<<<<<<<<
* copy_needed = True
* else:
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_alignment); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_alignment); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1430; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = PyNumber_Remainder(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Remainder(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1430; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_6);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_t_6, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_t_6, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1430; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1430; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "pyfftw/pyfftw.pyx":1411
+ /* "pyfftw/pyfftw.pyx":1429
* elif (not input_array.strides == self._input_strides):
* copy_needed = True
* elif not (<intptr_t>np.PyArray_DATA(input_array) # <<<<<<<<<<<<<<
@@ -11265,7 +11368,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
__pyx_t_1 = ((!__pyx_t_2) != 0);
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1413
+ /* "pyfftw/pyfftw.pyx":1431
* elif not (<intptr_t>np.PyArray_DATA(input_array)
* % self.input_alignment == 0):
* copy_needed = True # <<<<<<<<<<<<<<
@@ -11274,17 +11377,17 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
*/
__pyx_v_copy_needed = 1;
- /* "pyfftw/pyfftw.pyx":1411
+ /* "pyfftw/pyfftw.pyx":1429
* elif (not input_array.strides == self._input_strides):
* copy_needed = True
* elif not (<intptr_t>np.PyArray_DATA(input_array) # <<<<<<<<<<<<<<
* % self.input_alignment == 0):
* copy_needed = True
*/
- goto __pyx_L8;
+ goto __pyx_L11;
}
- /* "pyfftw/pyfftw.pyx":1415
+ /* "pyfftw/pyfftw.pyx":1433
* copy_needed = True
* else:
* copy_needed = False # <<<<<<<<<<<<<<
@@ -11294,9 +11397,9 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
/*else*/ {
__pyx_v_copy_needed = 0;
}
- __pyx_L8:;
+ __pyx_L11:;
- /* "pyfftw/pyfftw.pyx":1417
+ /* "pyfftw/pyfftw.pyx":1435
* copy_needed = False
*
* if copy_needed: # <<<<<<<<<<<<<<
@@ -11306,7 +11409,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
__pyx_t_1 = (__pyx_v_copy_needed != 0);
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1419
+ /* "pyfftw/pyfftw.pyx":1437
* if copy_needed:
*
* if not isinstance(input_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -11317,47 +11420,47 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
__pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1420
+ /* "pyfftw/pyfftw.pyx":1438
*
* if not isinstance(input_array, np.ndarray):
* input_array = np.asanyarray(input_array) # <<<<<<<<<<<<<<
*
* if not input_array.shape == self._input_shape:
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1420; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_asanyarray); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1420; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_asanyarray); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) {
- __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_6)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_4, function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_6) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_input_array); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1420; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_input_array); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_5);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1420; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_input_array);
__Pyx_GIVEREF(__pyx_v_input_array);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_input_array);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1420; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_input_array, __pyx_t_5);
__pyx_t_5 = 0;
- /* "pyfftw/pyfftw.pyx":1419
+ /* "pyfftw/pyfftw.pyx":1437
* if copy_needed:
*
* if not isinstance(input_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -11366,36 +11469,36 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
*/
}
- /* "pyfftw/pyfftw.pyx":1422
+ /* "pyfftw/pyfftw.pyx":1440
* input_array = np.asanyarray(input_array)
*
* if not input_array.shape == self._input_shape: # <<<<<<<<<<<<<<
* raise ValueError('Invalid input shape: '
* 'The new input array should be the same shape '
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1422; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_v_self->_input_shape, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1422; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_v_self->_input_shape, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1422; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_1 = ((!__pyx_t_2) != 0);
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1423
+ /* "pyfftw/pyfftw.pyx":1441
*
* if not input_array.shape == self._input_shape:
* raise ValueError('Invalid input shape: ' # <<<<<<<<<<<<<<
* 'The new input array should be the same shape '
* 'as the input array used to instantiate the '
*/
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1423; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_Raise(__pyx_t_4, 0, 0, 0);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1423; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1422
+ /* "pyfftw/pyfftw.pyx":1440
* input_array = np.asanyarray(input_array)
*
* if not input_array.shape == self._input_shape: # <<<<<<<<<<<<<<
@@ -11404,16 +11507,16 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
*/
}
- /* "pyfftw/pyfftw.pyx":1428
+ /* "pyfftw/pyfftw.pyx":1446
* 'object.')
*
* self._input_array[:] = input_array # <<<<<<<<<<<<<<
*
* if output_array is not None:
*/
- if (__Pyx_PyObject_SetSlice(((PyObject *)__pyx_v_self->_input_array), __pyx_v_input_array, 0, 0, NULL, NULL, &__pyx_slice__23, 0, 0, 1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1428; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetSlice(((PyObject *)__pyx_v_self->_input_array), __pyx_v_input_array, 0, 0, NULL, NULL, &__pyx_slice__24, 0, 0, 1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1430
+ /* "pyfftw/pyfftw.pyx":1448
* self._input_array[:] = input_array
*
* if output_array is not None: # <<<<<<<<<<<<<<
@@ -11424,30 +11527,30 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1433
+ /* "pyfftw/pyfftw.pyx":1451
* # No point wasting time if no update is necessary
* # (which the copy above may have avoided)
* input_array = self._input_array # <<<<<<<<<<<<<<
* self.update_arrays(input_array, output_array)
*
*/
- __pyx_t_4 = ((PyObject *)__pyx_v_self->_input_array);
- __Pyx_INCREF(__pyx_t_4);
- __Pyx_DECREF_SET(__pyx_v_input_array, __pyx_t_4);
- __pyx_t_4 = 0;
+ __pyx_t_3 = ((PyObject *)__pyx_v_self->_input_array);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_DECREF_SET(__pyx_v_input_array, __pyx_t_3);
+ __pyx_t_3 = 0;
- /* "pyfftw/pyfftw.pyx":1434
+ /* "pyfftw/pyfftw.pyx":1452
* # (which the copy above may have avoided)
* input_array = self._input_array
* self.update_arrays(input_array, output_array) # <<<<<<<<<<<<<<
*
* else:
*/
- __pyx_t_4 = ((struct __pyx_vtabstruct_6pyfftw_6pyfftw_FFTW *)__pyx_v_self->__pyx_vtab)->update_arrays(__pyx_v_self, __pyx_v_input_array, __pyx_v_output_array, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1434; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_3 = ((struct __pyx_vtabstruct_6pyfftw_6pyfftw_FFTW *)__pyx_v_self->__pyx_vtab)->update_arrays(__pyx_v_self, __pyx_v_input_array, __pyx_v_output_array, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1452; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "pyfftw/pyfftw.pyx":1430
+ /* "pyfftw/pyfftw.pyx":1448
* self._input_array[:] = input_array
*
* if output_array is not None: # <<<<<<<<<<<<<<
@@ -11456,17 +11559,17 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
*/
}
- /* "pyfftw/pyfftw.pyx":1417
+ /* "pyfftw/pyfftw.pyx":1435
* copy_needed = False
*
* if copy_needed: # <<<<<<<<<<<<<<
*
* if not isinstance(input_array, np.ndarray):
*/
- goto __pyx_L9;
+ goto __pyx_L12;
}
- /* "pyfftw/pyfftw.pyx":1437
+ /* "pyfftw/pyfftw.pyx":1455
*
* else:
* self.update_arrays(input_array, output_array) # <<<<<<<<<<<<<<
@@ -11474,14 +11577,14 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
* self.execute()
*/
/*else*/ {
- __pyx_t_4 = ((struct __pyx_vtabstruct_6pyfftw_6pyfftw_FFTW *)__pyx_v_self->__pyx_vtab)->update_arrays(__pyx_v_self, __pyx_v_input_array, __pyx_v_output_array, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_3 = ((struct __pyx_vtabstruct_6pyfftw_6pyfftw_FFTW *)__pyx_v_self->__pyx_vtab)->update_arrays(__pyx_v_self, __pyx_v_input_array, __pyx_v_output_array, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- __pyx_L9:;
+ __pyx_L12:;
- /* "pyfftw/pyfftw.pyx":1397
- * '''
+ /* "pyfftw/pyfftw.pyx":1415
+ * ' both be True.')
*
* if input_array is not None or output_array is not None: # <<<<<<<<<<<<<<
*
@@ -11489,21 +11592,62 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
*/
}
- /* "pyfftw/pyfftw.pyx":1439
+ /* "pyfftw/pyfftw.pyx":1457
* self.update_arrays(input_array, output_array)
*
* self.execute() # <<<<<<<<<<<<<<
*
- * if self._direction == FFTW_BACKWARD and normalise_idft:
+ * if ortho == True:
*/
- __pyx_t_4 = ((struct __pyx_vtabstruct_6pyfftw_6pyfftw_FFTW *)__pyx_v_self->__pyx_vtab)->execute(__pyx_v_self, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_3 = ((struct __pyx_vtabstruct_6pyfftw_6pyfftw_FFTW *)__pyx_v_self->__pyx_vtab)->execute(__pyx_v_self, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "pyfftw/pyfftw.pyx":1441
+ /* "pyfftw/pyfftw.pyx":1459
+ * self.execute()
+ *
+ * if ortho == True: # <<<<<<<<<<<<<<
+ * self._output_array *= self._sqrt_normalisation_scaling
+ * elif self._direction == FFTW_BACKWARD and normalise_idft:
+ */
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_ortho, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (__pyx_t_2) {
+
+ /* "pyfftw/pyfftw.pyx":1460
+ *
+ * if ortho == True:
+ * self._output_array *= self._sqrt_normalisation_scaling # <<<<<<<<<<<<<<
+ * elif self._direction == FFTW_BACKWARD and normalise_idft:
+ * self._output_array *= self._normalisation_scaling
+ */
+ __pyx_t_3 = PyFloat_FromDouble(__pyx_v_self->_sqrt_normalisation_scaling); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = PyNumber_InPlaceMultiply(((PyObject *)__pyx_v_self->_output_array), __pyx_t_3); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GIVEREF(__pyx_t_5);
+ __Pyx_GOTREF(__pyx_v_self->_output_array);
+ __Pyx_DECREF(((PyObject *)__pyx_v_self->_output_array));
+ __pyx_v_self->_output_array = ((PyArrayObject *)__pyx_t_5);
+ __pyx_t_5 = 0;
+
+ /* "pyfftw/pyfftw.pyx":1459
* self.execute()
*
- * if self._direction == FFTW_BACKWARD and normalise_idft: # <<<<<<<<<<<<<<
+ * if ortho == True: # <<<<<<<<<<<<<<
+ * self._output_array *= self._sqrt_normalisation_scaling
+ * elif self._direction == FFTW_BACKWARD and normalise_idft:
+ */
+ goto __pyx_L16;
+ }
+
+ /* "pyfftw/pyfftw.pyx":1461
+ * if ortho == True:
+ * self._output_array *= self._sqrt_normalisation_scaling
+ * elif self._direction == FFTW_BACKWARD and normalise_idft: # <<<<<<<<<<<<<<
* self._output_array *= self._normalisation_scaling
*
*/
@@ -11511,42 +11655,43 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
if (__pyx_t_1) {
} else {
__pyx_t_2 = __pyx_t_1;
- goto __pyx_L14_bool_binop_done;
+ goto __pyx_L17_bool_binop_done;
}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_normalise_idft); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_normalise_idft); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_t_2 = __pyx_t_1;
- __pyx_L14_bool_binop_done:;
+ __pyx_L17_bool_binop_done:;
if (__pyx_t_2) {
- /* "pyfftw/pyfftw.pyx":1442
- *
- * if self._direction == FFTW_BACKWARD and normalise_idft:
+ /* "pyfftw/pyfftw.pyx":1462
+ * self._output_array *= self._sqrt_normalisation_scaling
+ * elif self._direction == FFTW_BACKWARD and normalise_idft:
* self._output_array *= self._normalisation_scaling # <<<<<<<<<<<<<<
*
* return self._output_array
*/
- __pyx_t_4 = PyFloat_FromDouble(__pyx_v_self->_normalisation_scaling); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = PyNumber_InPlaceMultiply(((PyObject *)__pyx_v_self->_output_array), __pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->_normalisation_scaling); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GIVEREF(__pyx_t_5);
+ __pyx_t_3 = PyNumber_InPlaceMultiply(((PyObject *)__pyx_v_self->_output_array), __pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GIVEREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_v_self->_output_array);
__Pyx_DECREF(((PyObject *)__pyx_v_self->_output_array));
- __pyx_v_self->_output_array = ((PyArrayObject *)__pyx_t_5);
- __pyx_t_5 = 0;
+ __pyx_v_self->_output_array = ((PyArrayObject *)__pyx_t_3);
+ __pyx_t_3 = 0;
- /* "pyfftw/pyfftw.pyx":1441
- * self.execute()
- *
- * if self._direction == FFTW_BACKWARD and normalise_idft: # <<<<<<<<<<<<<<
+ /* "pyfftw/pyfftw.pyx":1461
+ * if ortho == True:
+ * self._output_array *= self._sqrt_normalisation_scaling
+ * elif self._direction == FFTW_BACKWARD and normalise_idft: # <<<<<<<<<<<<<<
* self._output_array *= self._normalisation_scaling
*
*/
}
+ __pyx_L16:;
- /* "pyfftw/pyfftw.pyx":1444
+ /* "pyfftw/pyfftw.pyx":1464
* self._output_array *= self._normalisation_scaling
*
* return self._output_array # <<<<<<<<<<<<<<
@@ -11558,17 +11703,17 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
__pyx_r = ((PyObject *)__pyx_v_self->_output_array);
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":1339
+ /* "pyfftw/pyfftw.pyx":1341
* free(self._howmany_dims)
*
* def __call__(self, input_array=None, output_array=None, # <<<<<<<<<<<<<<
- * normalise_idft=True):
- * '''__call__(input_array=None, output_array=None, normalise_idft=True)
+ * normalise_idft=True, ortho=False):
+ * '''__call__(input_array=None, output_array=None, normalise_idft=True,
*/
/* function exit code */
__pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
@@ -11582,7 +11727,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_36__call__(struct __pyx_obj_6pyf
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":1446
+/* "pyfftw/pyfftw.pyx":1466
* return self._output_array
*
* cpdef update_arrays(self, # <<<<<<<<<<<<<<
@@ -11614,7 +11759,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
if (unlikely(__pyx_skip_dispatch)) ;
/* Check if overridden in Python */
else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_update_arrays); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_update_arrays); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6pyfftw_6pyfftw_4FFTW_39update_arrays)) {
__Pyx_XDECREF(__pyx_r);
@@ -11631,7 +11776,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
__pyx_t_5 = 1;
}
}
- __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_4) {
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
@@ -11642,7 +11787,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
__Pyx_INCREF(__pyx_v_new_output_array);
__Pyx_GIVEREF(__pyx_v_new_output_array);
PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_new_output_array);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -11654,7 +11799,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "pyfftw/pyfftw.pyx":1469
+ /* "pyfftw/pyfftw.pyx":1489
* object will still be in a sane state).
* '''
* if not isinstance(new_input_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -11665,20 +11810,20 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
__pyx_t_8 = ((!(__pyx_t_7 != 0)) != 0);
if (__pyx_t_8) {
- /* "pyfftw/pyfftw.pyx":1470
+ /* "pyfftw/pyfftw.pyx":1490
* '''
* if not isinstance(new_input_array, np.ndarray):
* raise ValueError('Invalid input array: ' # <<<<<<<<<<<<<<
* 'The new input array needs to be an instance '
* 'of numpy.ndarray')
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1470; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1470; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1469
+ /* "pyfftw/pyfftw.pyx":1489
* object will still be in a sane state).
* '''
* if not isinstance(new_input_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -11687,7 +11832,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
*/
}
- /* "pyfftw/pyfftw.pyx":1474
+ /* "pyfftw/pyfftw.pyx":1494
* 'of numpy.ndarray')
*
* if not isinstance(new_output_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -11698,20 +11843,20 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
__pyx_t_7 = ((!(__pyx_t_8 != 0)) != 0);
if (__pyx_t_7) {
- /* "pyfftw/pyfftw.pyx":1475
+ /* "pyfftw/pyfftw.pyx":1495
*
* if not isinstance(new_output_array, np.ndarray):
* raise ValueError('Invalid output array ' # <<<<<<<<<<<<<<
* 'The new output array needs to be an instance '
* 'of numpy.ndarray')
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1495; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1495; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1474
+ /* "pyfftw/pyfftw.pyx":1494
* 'of numpy.ndarray')
*
* if not isinstance(new_output_array, np.ndarray): # <<<<<<<<<<<<<<
@@ -11720,53 +11865,53 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
*/
}
- /* "pyfftw/pyfftw.pyx":1479
+ /* "pyfftw/pyfftw.pyx":1499
* 'of numpy.ndarray')
*
* if not (<intptr_t>np.PyArray_DATA(new_input_array) % # <<<<<<<<<<<<<<
* self.input_alignment == 0):
* raise ValueError('Invalid input alignment: '
*/
- if (!(likely(((__pyx_v_new_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1479; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_new_input_array)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1479; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_new_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_new_input_array)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- /* "pyfftw/pyfftw.pyx":1480
+ /* "pyfftw/pyfftw.pyx":1500
*
* if not (<intptr_t>np.PyArray_DATA(new_input_array) %
* self.input_alignment == 0): # <<<<<<<<<<<<<<
* raise ValueError('Invalid input alignment: '
* 'The original arrays were %d-byte aligned. It is '
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1480; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1500; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- /* "pyfftw/pyfftw.pyx":1479
+ /* "pyfftw/pyfftw.pyx":1499
* 'of numpy.ndarray')
*
* if not (<intptr_t>np.PyArray_DATA(new_input_array) % # <<<<<<<<<<<<<<
* self.input_alignment == 0):
* raise ValueError('Invalid input alignment: '
*/
- __pyx_t_3 = PyNumber_Remainder(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1479; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Remainder(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "pyfftw/pyfftw.pyx":1480
+ /* "pyfftw/pyfftw.pyx":1500
*
* if not (<intptr_t>np.PyArray_DATA(new_input_array) %
* self.input_alignment == 0): # <<<<<<<<<<<<<<
* raise ValueError('Invalid input alignment: '
* 'The original arrays were %d-byte aligned. It is '
*/
- __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1480; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1500; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1480; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1500; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "pyfftw/pyfftw.pyx":1479
+ /* "pyfftw/pyfftw.pyx":1499
* 'of numpy.ndarray')
*
* if not (<intptr_t>np.PyArray_DATA(new_input_array) % # <<<<<<<<<<<<<<
@@ -11776,39 +11921,39 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
__pyx_t_8 = ((!__pyx_t_7) != 0);
if (__pyx_t_8) {
- /* "pyfftw/pyfftw.pyx":1484
+ /* "pyfftw/pyfftw.pyx":1504
* 'The original arrays were %d-byte aligned. It is '
* 'necessary that the update input array is similarly '
* 'aligned.' % self.input_alignment) # <<<<<<<<<<<<<<
*
* if not (<intptr_t>np.PyArray_DATA(new_output_array) %
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1484; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1504; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_input_alignment_The_orig, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1484; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_input_alignment_The_orig, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1504; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "pyfftw/pyfftw.pyx":1481
+ /* "pyfftw/pyfftw.pyx":1501
* if not (<intptr_t>np.PyArray_DATA(new_input_array) %
* self.input_alignment == 0):
* raise ValueError('Invalid input alignment: ' # <<<<<<<<<<<<<<
* 'The original arrays were %d-byte aligned. It is '
* 'necessary that the update input array is similarly '
*/
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1481; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1481; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1481; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1479
+ /* "pyfftw/pyfftw.pyx":1499
* 'of numpy.ndarray')
*
* if not (<intptr_t>np.PyArray_DATA(new_input_array) % # <<<<<<<<<<<<<<
@@ -11817,53 +11962,53 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
*/
}
- /* "pyfftw/pyfftw.pyx":1486
+ /* "pyfftw/pyfftw.pyx":1506
* 'aligned.' % self.input_alignment)
*
* if not (<intptr_t>np.PyArray_DATA(new_output_array) % # <<<<<<<<<<<<<<
* self.output_alignment == 0):
* raise ValueError('Invalid output alignment: '
*/
- if (!(likely(((__pyx_v_new_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_3 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_new_output_array)))); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_new_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1506; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_new_output_array)))); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1506; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
- /* "pyfftw/pyfftw.pyx":1487
+ /* "pyfftw/pyfftw.pyx":1507
*
* if not (<intptr_t>np.PyArray_DATA(new_output_array) %
* self.output_alignment == 0): # <<<<<<<<<<<<<<
* raise ValueError('Invalid output alignment: '
* 'The original arrays were %d-byte aligned. It is '
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- /* "pyfftw/pyfftw.pyx":1486
+ /* "pyfftw/pyfftw.pyx":1506
* 'aligned.' % self.input_alignment)
*
* if not (<intptr_t>np.PyArray_DATA(new_output_array) % # <<<<<<<<<<<<<<
* self.output_alignment == 0):
* raise ValueError('Invalid output alignment: '
*/
- __pyx_t_1 = PyNumber_Remainder(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Remainder(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1506; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "pyfftw/pyfftw.pyx":1487
+ /* "pyfftw/pyfftw.pyx":1507
*
* if not (<intptr_t>np.PyArray_DATA(new_output_array) %
* self.output_alignment == 0): # <<<<<<<<<<<<<<
* raise ValueError('Invalid output alignment: '
* 'The original arrays were %d-byte aligned. It is '
*/
- __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "pyfftw/pyfftw.pyx":1486
+ /* "pyfftw/pyfftw.pyx":1506
* 'aligned.' % self.input_alignment)
*
* if not (<intptr_t>np.PyArray_DATA(new_output_array) % # <<<<<<<<<<<<<<
@@ -11873,39 +12018,39 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
__pyx_t_7 = ((!__pyx_t_8) != 0);
if (__pyx_t_7) {
- /* "pyfftw/pyfftw.pyx":1491
+ /* "pyfftw/pyfftw.pyx":1511
* 'The original arrays were %d-byte aligned. It is '
* 'necessary that the update output array is similarly '
* 'aligned.' % self.output_alignment) # <<<<<<<<<<<<<<
*
* if not new_input_array.dtype == self._input_dtype:
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1491; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1511; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_output_alignment_The_ori, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1491; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_output_alignment_The_ori, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1511; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "pyfftw/pyfftw.pyx":1488
+ /* "pyfftw/pyfftw.pyx":1508
* if not (<intptr_t>np.PyArray_DATA(new_output_array) %
* self.output_alignment == 0):
* raise ValueError('Invalid output alignment: ' # <<<<<<<<<<<<<<
* 'The original arrays were %d-byte aligned. It is '
* 'necessary that the update output array is similarly '
*/
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1488; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1508; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1488; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1508; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1488; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1508; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1486
+ /* "pyfftw/pyfftw.pyx":1506
* 'aligned.' % self.input_alignment)
*
* if not (<intptr_t>np.PyArray_DATA(new_output_array) % # <<<<<<<<<<<<<<
@@ -11914,36 +12059,36 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
*/
}
- /* "pyfftw/pyfftw.pyx":1493
+ /* "pyfftw/pyfftw.pyx":1513
* 'aligned.' % self.output_alignment)
*
* if not new_input_array.dtype == self._input_dtype: # <<<<<<<<<<<<<<
* raise ValueError('Invalid input dtype: '
* 'The new input array is not of the same '
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_input_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1493; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_input_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1513; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_v_self->_input_dtype, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1493; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_v_self->_input_dtype, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1513; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1493; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1513; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_8 = ((!__pyx_t_7) != 0);
if (__pyx_t_8) {
- /* "pyfftw/pyfftw.pyx":1494
+ /* "pyfftw/pyfftw.pyx":1514
*
* if not new_input_array.dtype == self._input_dtype:
* raise ValueError('Invalid input dtype: ' # <<<<<<<<<<<<<<
* 'The new input array is not of the same '
* 'dtype as was originally planned for.')
*/
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1494; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1494; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1493
+ /* "pyfftw/pyfftw.pyx":1513
* 'aligned.' % self.output_alignment)
*
* if not new_input_array.dtype == self._input_dtype: # <<<<<<<<<<<<<<
@@ -11952,36 +12097,36 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
*/
}
- /* "pyfftw/pyfftw.pyx":1498
+ /* "pyfftw/pyfftw.pyx":1518
* 'dtype as was originally planned for.')
*
* if not new_output_array.dtype == self._output_dtype: # <<<<<<<<<<<<<<
* raise ValueError('Invalid output dtype: '
* 'The new output array is not of the same '
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_output_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1498; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_output_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_v_self->_output_dtype, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1498; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_v_self->_output_dtype, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1498; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_7 = ((!__pyx_t_8) != 0);
if (__pyx_t_7) {
- /* "pyfftw/pyfftw.pyx":1499
+ /* "pyfftw/pyfftw.pyx":1519
*
* if not new_output_array.dtype == self._output_dtype:
* raise ValueError('Invalid output dtype: ' # <<<<<<<<<<<<<<
* 'The new output array is not of the same '
* 'dtype as was originally planned for.')
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1498
+ /* "pyfftw/pyfftw.pyx":1518
* 'dtype as was originally planned for.')
*
* if not new_output_array.dtype == self._output_dtype: # <<<<<<<<<<<<<<
@@ -11990,81 +12135,81 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
*/
}
- /* "pyfftw/pyfftw.pyx":1503
+ /* "pyfftw/pyfftw.pyx":1523
* 'dtype as was originally planned for.')
*
* new_input_shape = new_input_array.shape # <<<<<<<<<<<<<<
* new_output_shape = new_output_array.shape
*
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1503; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_new_input_shape = __pyx_t_1;
__pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1504
+ /* "pyfftw/pyfftw.pyx":1524
*
* new_input_shape = new_input_array.shape
* new_output_shape = new_output_array.shape # <<<<<<<<<<<<<<
*
* new_input_strides = new_input_array.strides
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_output_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1504; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_output_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1524; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_new_output_shape = __pyx_t_1;
__pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1506
+ /* "pyfftw/pyfftw.pyx":1526
* new_output_shape = new_output_array.shape
*
* new_input_strides = new_input_array.strides # <<<<<<<<<<<<<<
* new_output_strides = new_output_array.strides
*
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1506; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1526; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_new_input_strides = __pyx_t_1;
__pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1507
+ /* "pyfftw/pyfftw.pyx":1527
*
* new_input_strides = new_input_array.strides
* new_output_strides = new_output_array.strides # <<<<<<<<<<<<<<
*
* if not new_input_shape == self._input_shape:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_output_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_output_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_new_output_strides = __pyx_t_1;
__pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1509
+ /* "pyfftw/pyfftw.pyx":1529
* new_output_strides = new_output_array.strides
*
* if not new_input_shape == self._input_shape: # <<<<<<<<<<<<<<
* raise ValueError('Invalid input shape: '
* 'The new input array should be the same shape as '
*/
- __pyx_t_1 = PyObject_RichCompare(__pyx_v_new_input_shape, __pyx_v_self->_input_shape, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1509; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1509; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_v_new_input_shape, __pyx_v_self->_input_shape, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_8 = ((!__pyx_t_7) != 0);
if (__pyx_t_8) {
- /* "pyfftw/pyfftw.pyx":1510
+ /* "pyfftw/pyfftw.pyx":1530
*
* if not new_input_shape == self._input_shape:
* raise ValueError('Invalid input shape: ' # <<<<<<<<<<<<<<
* 'The new input array should be the same shape as '
* 'the input array used to instantiate the object.')
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1510; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1530; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1510; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1530; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1509
+ /* "pyfftw/pyfftw.pyx":1529
* new_output_strides = new_output_array.strides
*
* if not new_input_shape == self._input_shape: # <<<<<<<<<<<<<<
@@ -12073,33 +12218,33 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
*/
}
- /* "pyfftw/pyfftw.pyx":1514
+ /* "pyfftw/pyfftw.pyx":1534
* 'the input array used to instantiate the object.')
*
* if not new_output_shape == self._output_shape: # <<<<<<<<<<<<<<
* raise ValueError('Invalid output shape: '
* 'The new output array should be the same shape as '
*/
- __pyx_t_1 = PyObject_RichCompare(__pyx_v_new_output_shape, __pyx_v_self->_output_shape, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_v_new_output_shape, __pyx_v_self->_output_shape, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1534; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1534; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_7 = ((!__pyx_t_8) != 0);
if (__pyx_t_7) {
- /* "pyfftw/pyfftw.pyx":1515
+ /* "pyfftw/pyfftw.pyx":1535
*
* if not new_output_shape == self._output_shape:
* raise ValueError('Invalid output shape: ' # <<<<<<<<<<<<<<
* 'The new output array should be the same shape as '
* 'the output array used to instantiate the object.')
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1515; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1535; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1515; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1535; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1514
+ /* "pyfftw/pyfftw.pyx":1534
* 'the input array used to instantiate the object.')
*
* if not new_output_shape == self._output_shape: # <<<<<<<<<<<<<<
@@ -12108,33 +12253,33 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
*/
}
- /* "pyfftw/pyfftw.pyx":1519
+ /* "pyfftw/pyfftw.pyx":1539
* 'the output array used to instantiate the object.')
*
* if not new_input_strides == self._input_strides: # <<<<<<<<<<<<<<
* raise ValueError('Invalid input striding: '
* 'The strides should be identical for the new '
*/
- __pyx_t_1 = PyObject_RichCompare(__pyx_v_new_input_strides, __pyx_v_self->_input_strides, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_v_new_input_strides, __pyx_v_self->_input_strides, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1539; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1539; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_8 = ((!__pyx_t_7) != 0);
if (__pyx_t_8) {
- /* "pyfftw/pyfftw.pyx":1520
+ /* "pyfftw/pyfftw.pyx":1540
*
* if not new_input_strides == self._input_strides:
* raise ValueError('Invalid input striding: ' # <<<<<<<<<<<<<<
* 'The strides should be identical for the new '
* 'input array as for the old.')
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1519
+ /* "pyfftw/pyfftw.pyx":1539
* 'the output array used to instantiate the object.')
*
* if not new_input_strides == self._input_strides: # <<<<<<<<<<<<<<
@@ -12143,33 +12288,33 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
*/
}
- /* "pyfftw/pyfftw.pyx":1524
+ /* "pyfftw/pyfftw.pyx":1544
* 'input array as for the old.')
*
* if not new_output_strides == self._output_strides: # <<<<<<<<<<<<<<
* raise ValueError('Invalid output striding: '
* 'The strides should be identical for the new '
*/
- __pyx_t_1 = PyObject_RichCompare(__pyx_v_new_output_strides, __pyx_v_self->_output_strides, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1524; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1524; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_v_new_output_strides, __pyx_v_self->_output_strides, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1544; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1544; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_7 = ((!__pyx_t_8) != 0);
if (__pyx_t_7) {
- /* "pyfftw/pyfftw.pyx":1525
+ /* "pyfftw/pyfftw.pyx":1545
*
* if not new_output_strides == self._output_strides:
* raise ValueError('Invalid output striding: ' # <<<<<<<<<<<<<<
* 'The strides should be identical for the new '
* 'output array as for the old.')
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1525; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1545; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1525; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1545; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1524
+ /* "pyfftw/pyfftw.pyx":1544
* 'input array as for the old.')
*
* if not new_output_strides == self._output_strides: # <<<<<<<<<<<<<<
@@ -12178,20 +12323,20 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
*/
}
- /* "pyfftw/pyfftw.pyx":1529
+ /* "pyfftw/pyfftw.pyx":1549
* 'output array as for the old.')
*
* self._update_arrays(new_input_array, new_output_array) # <<<<<<<<<<<<<<
*
* cdef _update_arrays(self,
*/
- if (!(likely(((__pyx_v_new_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (!(likely(((__pyx_v_new_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = ((struct __pyx_vtabstruct_6pyfftw_6pyfftw_FFTW *)__pyx_v_self->__pyx_vtab)->_update_arrays(__pyx_v_self, ((PyArrayObject *)__pyx_v_new_input_array), ((PyArrayObject *)__pyx_v_new_output_array)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_new_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_input_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_new_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_output_array, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = ((struct __pyx_vtabstruct_6pyfftw_6pyfftw_FFTW *)__pyx_v_self->__pyx_vtab)->_update_arrays(__pyx_v_self, ((PyArrayObject *)__pyx_v_new_input_array), ((PyArrayObject *)__pyx_v_new_output_array)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1446
+ /* "pyfftw/pyfftw.pyx":1466
* return self._output_array
*
* cpdef update_arrays(self, # <<<<<<<<<<<<<<
@@ -12222,7 +12367,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6p
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_39update_arrays(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_38update_arrays[] = "update_arrays(new_input_array, new_output_array)\n\n Update the arrays upon which the DFT is taken.\n\n The new arrays should be of the same dtypes as the originals, the same\n shapes as the originals and should have the same strides between axes.\n If the original data was aligned so as to allow SIMD instructions\n (e.g. by being aligned on a 16-byte boundary), then the new array must\n [...]
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_38update_arrays[] = "update_arrays(new_input_array, new_output_array)\n\n Update the arrays upon which the DFT is taken.\n\n The new arrays should be of the same dtypes as the originals, the same\n shapes as the originals and should have the same strides between axes.\n If the original data was aligned so as to allow SIMD instructions\n (e.g. by being aligned on a 16-byte boundary), then the new array must\n [...]
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_39update_arrays(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_new_input_array = 0;
PyObject *__pyx_v_new_output_array = 0;
@@ -12252,11 +12397,11 @@ static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_39update_arrays(PyObject *__pyx_
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_new_output_array)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("update_arrays", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1446; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("update_arrays", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "update_arrays") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1446; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "update_arrays") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -12269,7 +12414,7 @@ static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_39update_arrays(PyObject *__pyx_
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("update_arrays", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1446; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("update_arrays", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
__pyx_L3_error:;
__Pyx_AddTraceback("pyfftw.pyfftw.FFTW.update_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -12291,7 +12436,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_38update_arrays(struct __pyx_obj
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("update_arrays", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(__pyx_v_self, __pyx_v_new_input_array, __pyx_v_new_output_array, 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_6pyfftw_6pyfftw_4FFTW_update_arrays(__pyx_v_self, __pyx_v_new_input_array, __pyx_v_new_output_array, 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -12308,7 +12453,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_38update_arrays(struct __pyx_obj
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":1531
+/* "pyfftw/pyfftw.pyx":1551
* self._update_arrays(new_input_array, new_output_array)
*
* cdef _update_arrays(self, # <<<<<<<<<<<<<<
@@ -12321,7 +12466,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW__update_arrays(struct __pyx_obj_6
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_update_arrays", 0);
- /* "pyfftw/pyfftw.pyx":1536
+ /* "pyfftw/pyfftw.pyx":1556
* perform any checks on strides being correct and so on.
* '''
* self._input_array = new_input_array # <<<<<<<<<<<<<<
@@ -12334,7 +12479,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW__update_arrays(struct __pyx_obj_6
__Pyx_DECREF(((PyObject *)__pyx_v_self->_input_array));
__pyx_v_self->_input_array = __pyx_v_new_input_array;
- /* "pyfftw/pyfftw.pyx":1537
+ /* "pyfftw/pyfftw.pyx":1557
* '''
* self._input_array = new_input_array
* self._output_array = new_output_array # <<<<<<<<<<<<<<
@@ -12347,7 +12492,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW__update_arrays(struct __pyx_obj_6
__Pyx_DECREF(((PyObject *)__pyx_v_self->_output_array));
__pyx_v_self->_output_array = __pyx_v_new_output_array;
- /* "pyfftw/pyfftw.pyx":1531
+ /* "pyfftw/pyfftw.pyx":1551
* self._update_arrays(new_input_array, new_output_array)
*
* cdef _update_arrays(self, # <<<<<<<<<<<<<<
@@ -12362,7 +12507,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW__update_arrays(struct __pyx_obj_6
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":1539
+/* "pyfftw/pyfftw.pyx":1559
* self._output_array = new_output_array
*
* def get_input_array(self): # <<<<<<<<<<<<<<
@@ -12372,7 +12517,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW__update_arrays(struct __pyx_obj_6
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_41get_input_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_40get_input_array[] = "get_input_array()\n\n Return the input array that is associated with the FFTW \n instance.\n\n *Deprecated since 0.10. Consider using the* :attr:`FFTW.input_array` \n *property instead.*\n ";
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_40get_input_array[] = "get_input_array()\n\n Return the input array that is associated with the FFTW\n instance.\n\n *Deprecated since 0.10. Consider using the* :attr:`FFTW.input_array`\n *property instead.*\n ";
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_41get_input_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
@@ -12397,20 +12542,20 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_40get_input_array(struct __pyx_o
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_input_array", 0);
- /* "pyfftw/pyfftw.pyx":1548
+ /* "pyfftw/pyfftw.pyx":1568
* *property instead.*
* '''
* warnings.warn('get_input_array is deprecated. ' # <<<<<<<<<<<<<<
* 'Consider using the input_array property instead.',
* DeprecationWarning)
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1548; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1568; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_warn); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1548; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_warn); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1568; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "pyfftw/pyfftw.pyx":1550
+ /* "pyfftw/pyfftw.pyx":1570
* warnings.warn('get_input_array is deprecated. '
* 'Consider using the input_array property instead.',
* DeprecationWarning) # <<<<<<<<<<<<<<
@@ -12429,7 +12574,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_40get_input_array(struct __pyx_o
__pyx_t_4 = 1;
}
}
- __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1548; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1568; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_5);
if (__pyx_t_2) {
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL;
@@ -12440,13 +12585,13 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_40get_input_array(struct __pyx_o
__Pyx_INCREF(__pyx_builtin_DeprecationWarning);
__Pyx_GIVEREF(__pyx_builtin_DeprecationWarning);
PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_builtin_DeprecationWarning);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1548; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1568; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1552
+ /* "pyfftw/pyfftw.pyx":1572
* DeprecationWarning)
*
* return self._input_array # <<<<<<<<<<<<<<
@@ -12458,7 +12603,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_40get_input_array(struct __pyx_o
__pyx_r = ((PyObject *)__pyx_v_self->_input_array);
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":1539
+ /* "pyfftw/pyfftw.pyx":1559
* self._output_array = new_output_array
*
* def get_input_array(self): # <<<<<<<<<<<<<<
@@ -12480,7 +12625,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_40get_input_array(struct __pyx_o
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":1554
+/* "pyfftw/pyfftw.pyx":1574
* return self._input_array
*
* def get_output_array(self): # <<<<<<<<<<<<<<
@@ -12490,7 +12635,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_40get_input_array(struct __pyx_o
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_43get_output_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_42get_output_array[] = "get_output_array()\n\n Return the output array that is associated with the FFTW\n instance.\n\n *Deprecated since 0.10. Consider using the* :attr:`FFTW.output_array` \n *property instead.*\n ";
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_42get_output_array[] = "get_output_array()\n\n Return the output array that is associated with the FFTW\n instance.\n\n *Deprecated since 0.10. Consider using the* :attr:`FFTW.output_array`\n *property instead.*\n ";
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_43get_output_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
@@ -12515,20 +12660,20 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_42get_output_array(struct __pyx_
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_output_array", 0);
- /* "pyfftw/pyfftw.pyx":1563
+ /* "pyfftw/pyfftw.pyx":1583
* *property instead.*
* '''
* warnings.warn('get_output_array is deprecated. ' # <<<<<<<<<<<<<<
* 'Consider using the output_array property instead.',
* DeprecationWarning)
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1563; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1583; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_warn); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1563; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_warn); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1583; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "pyfftw/pyfftw.pyx":1565
+ /* "pyfftw/pyfftw.pyx":1585
* warnings.warn('get_output_array is deprecated. '
* 'Consider using the output_array property instead.',
* DeprecationWarning) # <<<<<<<<<<<<<<
@@ -12547,7 +12692,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_42get_output_array(struct __pyx_
__pyx_t_4 = 1;
}
}
- __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1563; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1583; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_5);
if (__pyx_t_2) {
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL;
@@ -12558,13 +12703,13 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_42get_output_array(struct __pyx_
__Pyx_INCREF(__pyx_builtin_DeprecationWarning);
__Pyx_GIVEREF(__pyx_builtin_DeprecationWarning);
PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_builtin_DeprecationWarning);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1563; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1583; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1567
+ /* "pyfftw/pyfftw.pyx":1587
* DeprecationWarning)
*
* return self._output_array # <<<<<<<<<<<<<<
@@ -12576,7 +12721,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_42get_output_array(struct __pyx_
__pyx_r = ((PyObject *)__pyx_v_self->_output_array);
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":1554
+ /* "pyfftw/pyfftw.pyx":1574
* return self._input_array
*
* def get_output_array(self): # <<<<<<<<<<<<<<
@@ -12598,7 +12743,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_42get_output_array(struct __pyx_
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":1569
+/* "pyfftw/pyfftw.pyx":1589
* return self._output_array
*
* cpdef execute(self): # <<<<<<<<<<<<<<
@@ -12628,7 +12773,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
if (unlikely(__pyx_skip_dispatch)) ;
/* Check if overridden in Python */
else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_execute); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1569; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_execute); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_6pyfftw_6pyfftw_4FFTW_45execute)) {
__Pyx_XDECREF(__pyx_r);
@@ -12644,10 +12789,10 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
}
}
if (__pyx_t_4) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1569; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1569; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -12659,7 +12804,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "pyfftw/pyfftw.pyx":1578
+ /* "pyfftw/pyfftw.pyx":1598
* '''
* cdef void *input_pointer = (
* <void *>np.PyArray_DATA(self._input_array)) # <<<<<<<<<<<<<<
@@ -12671,7 +12816,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
__pyx_v_input_pointer = ((void *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1580
+ /* "pyfftw/pyfftw.pyx":1600
* <void *>np.PyArray_DATA(self._input_array))
* cdef void *output_pointer = (
* <void *>np.PyArray_DATA(self._output_array)) # <<<<<<<<<<<<<<
@@ -12683,7 +12828,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
__pyx_v_output_pointer = ((void *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1582
+ /* "pyfftw/pyfftw.pyx":1602
* <void *>np.PyArray_DATA(self._output_array))
*
* cdef void *plan = self._plan # <<<<<<<<<<<<<<
@@ -12693,7 +12838,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
__pyx_t_5 = __pyx_v_self->_plan;
__pyx_v_plan = __pyx_t_5;
- /* "pyfftw/pyfftw.pyx":1583
+ /* "pyfftw/pyfftw.pyx":1603
*
* cdef void *plan = self._plan
* cdef fftw_generic_execute fftw_execute = self._fftw_execute # <<<<<<<<<<<<<<
@@ -12703,7 +12848,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
__pyx_t_6 = __pyx_v_self->_fftw_execute;
__pyx_v_fftw_execute = __pyx_t_6;
- /* "pyfftw/pyfftw.pyx":1584
+ /* "pyfftw/pyfftw.pyx":1604
* cdef void *plan = self._plan
* cdef fftw_generic_execute fftw_execute = self._fftw_execute
* with nogil: # <<<<<<<<<<<<<<
@@ -12717,7 +12862,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
#endif
/*try:*/ {
- /* "pyfftw/pyfftw.pyx":1585
+ /* "pyfftw/pyfftw.pyx":1605
* cdef fftw_generic_execute fftw_execute = self._fftw_execute
* with nogil:
* fftw_execute(plan, input_pointer, output_pointer) # <<<<<<<<<<<<<<
@@ -12727,7 +12872,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
__pyx_v_fftw_execute(__pyx_v_plan, __pyx_v_input_pointer, __pyx_v_output_pointer);
}
- /* "pyfftw/pyfftw.pyx":1584
+ /* "pyfftw/pyfftw.pyx":1604
* cdef void *plan = self._plan
* cdef fftw_generic_execute fftw_execute = self._fftw_execute
* with nogil: # <<<<<<<<<<<<<<
@@ -12745,7 +12890,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
}
}
- /* "pyfftw/pyfftw.pyx":1569
+ /* "pyfftw/pyfftw.pyx":1589
* return self._output_array
*
* cpdef execute(self): # <<<<<<<<<<<<<<
@@ -12771,7 +12916,7 @@ static PyObject *__pyx_f_6pyfftw_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyfftw_
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_45execute(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_44execute[] = "execute()\n\n Execute the planned operation, taking the correct kind of FFT of\n the input array (i.e. :attr:`FFTW.input_array`), \n and putting the result in the output array (i.e.\n :attr:`FFTW.output_array`).\n ";
+static char __pyx_doc_6pyfftw_6pyfftw_4FFTW_44execute[] = "execute()\n\n Execute the planned operation, taking the correct kind of FFT of\n the input array (i.e. :attr:`FFTW.input_array`),\n and putting the result in the output array (i.e.\n :attr:`FFTW.output_array`).\n ";
static PyObject *__pyx_pw_6pyfftw_6pyfftw_4FFTW_45execute(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
@@ -12792,7 +12937,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_44execute(struct __pyx_obj_6pyff
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("execute", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __pyx_f_6pyfftw_6pyfftw_4FFTW_execute(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1569; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_6pyfftw_6pyfftw_4FFTW_execute(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -12809,7 +12954,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_4FFTW_44execute(struct __pyx_obj_6pyff
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":1587
+/* "pyfftw/pyfftw.pyx":1607
* fftw_execute(plan, input_pointer, output_pointer)
*
* cdef void count_char(char c, void *counter_ptr): # <<<<<<<<<<<<<<
@@ -12823,7 +12968,7 @@ static void __pyx_f_6pyfftw_6pyfftw_count_char(CYTHON_UNUSED char __pyx_v_c, voi
long __pyx_t_2;
__Pyx_RefNannySetupContext("count_char", 0);
- /* "pyfftw/pyfftw.pyx":1591
+ /* "pyfftw/pyfftw.pyx":1611
* On every call, increment the derefenced counter_ptr.
* '''
* (<int *>counter_ptr)[0] += 1 # <<<<<<<<<<<<<<
@@ -12834,7 +12979,7 @@ static void __pyx_f_6pyfftw_6pyfftw_count_char(CYTHON_UNUSED char __pyx_v_c, voi
__pyx_t_2 = 0;
(__pyx_t_1[__pyx_t_2]) = ((__pyx_t_1[__pyx_t_2]) + 1);
- /* "pyfftw/pyfftw.pyx":1587
+ /* "pyfftw/pyfftw.pyx":1607
* fftw_execute(plan, input_pointer, output_pointer)
*
* cdef void count_char(char c, void *counter_ptr): # <<<<<<<<<<<<<<
@@ -12846,7 +12991,7 @@ static void __pyx_f_6pyfftw_6pyfftw_count_char(CYTHON_UNUSED char __pyx_v_c, voi
__Pyx_RefNannyFinishContext();
}
-/* "pyfftw/pyfftw.pyx":1594
+/* "pyfftw/pyfftw.pyx":1614
*
*
* cdef void write_char_to_string(char c, void *string_location_ptr): # <<<<<<<<<<<<<<
@@ -12861,7 +13006,7 @@ static void __pyx_f_6pyfftw_6pyfftw_write_char_to_string(char __pyx_v_c, void *_
long __pyx_t_2;
__Pyx_RefNannySetupContext("write_char_to_string", 0);
- /* "pyfftw/pyfftw.pyx":1608
+ /* "pyfftw/pyfftw.pyx":1628
* unallocated piece of memory, a segfault will likely occur.
* '''
* cdef char *write_location = <char *>((<intptr_t *>string_location_ptr)[0]) # <<<<<<<<<<<<<<
@@ -12870,7 +13015,7 @@ static void __pyx_f_6pyfftw_6pyfftw_write_char_to_string(char __pyx_v_c, void *_
*/
__pyx_v_write_location = ((char *)(((intptr_t *)__pyx_v_string_location_ptr)[0]));
- /* "pyfftw/pyfftw.pyx":1609
+ /* "pyfftw/pyfftw.pyx":1629
* '''
* cdef char *write_location = <char *>((<intptr_t *>string_location_ptr)[0])
* write_location[0] = c # <<<<<<<<<<<<<<
@@ -12879,7 +13024,7 @@ static void __pyx_f_6pyfftw_6pyfftw_write_char_to_string(char __pyx_v_c, void *_
*/
(__pyx_v_write_location[0]) = __pyx_v_c;
- /* "pyfftw/pyfftw.pyx":1611
+ /* "pyfftw/pyfftw.pyx":1631
* write_location[0] = c
*
* (<intptr_t *>string_location_ptr)[0] += 1 # <<<<<<<<<<<<<<
@@ -12890,7 +13035,7 @@ static void __pyx_f_6pyfftw_6pyfftw_write_char_to_string(char __pyx_v_c, void *_
__pyx_t_2 = 0;
(__pyx_t_1[__pyx_t_2]) = ((__pyx_t_1[__pyx_t_2]) + 1);
- /* "pyfftw/pyfftw.pyx":1594
+ /* "pyfftw/pyfftw.pyx":1614
*
*
* cdef void write_char_to_string(char c, void *string_location_ptr): # <<<<<<<<<<<<<<
@@ -12902,7 +13047,7 @@ static void __pyx_f_6pyfftw_6pyfftw_write_char_to_string(char __pyx_v_c, void *_
__Pyx_RefNannyFinishContext();
}
-/* "pyfftw/pyfftw.pyx":1614
+/* "pyfftw/pyfftw.pyx":1634
*
*
* def export_wisdom(): # <<<<<<<<<<<<<<
@@ -12912,7 +13057,7 @@ static void __pyx_f_6pyfftw_6pyfftw_write_char_to_string(char __pyx_v_c, void *_
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_21export_wisdom(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_20export_wisdom[] = "export_wisdom()\n\n Return the FFTW wisdom as a tuple of strings.\n\n The first string in the tuple is the string for the double\n precision wisdom. The second string in the tuple is the string \n for the single precision wisdom. The third string in the tuple \n is the string for the long double precision wisdom.\n\n The tuple that is returned from this function can be used as the\n argument to :func:`~pyfftw [...]
+static char __pyx_doc_6pyfftw_6pyfftw_20export_wisdom[] = "export_wisdom()\n\n Return the FFTW wisdom as a tuple of strings.\n\n The first string in the tuple is the string for the double\n precision wisdom. The second string in the tuple is the string\n for the single precision wisdom. The third string in the tuple\n is the string for the long double precision wisdom.\n\n The tuple that is returned from this function can be used as the\n argument to :func:`~pyfftw.i [...]
static PyMethodDef __pyx_mdef_6pyfftw_6pyfftw_21export_wisdom = {"export_wisdom", (PyCFunction)__pyx_pw_6pyfftw_6pyfftw_21export_wisdom, METH_NOARGS, __pyx_doc_6pyfftw_6pyfftw_20export_wisdom};
static PyObject *__pyx_pw_6pyfftw_6pyfftw_21export_wisdom(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
@@ -12957,7 +13102,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("export_wisdom", 0);
- /* "pyfftw/pyfftw.pyx":1632
+ /* "pyfftw/pyfftw.pyx":1652
* cdef bytes py_wisdoml
*
* cdef int counter = 0 # <<<<<<<<<<<<<<
@@ -12966,7 +13111,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_counter = 0;
- /* "pyfftw/pyfftw.pyx":1633
+ /* "pyfftw/pyfftw.pyx":1653
*
* cdef int counter = 0
* cdef int counterf = 0 # <<<<<<<<<<<<<<
@@ -12975,7 +13120,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_counterf = 0;
- /* "pyfftw/pyfftw.pyx":1634
+ /* "pyfftw/pyfftw.pyx":1654
* cdef int counter = 0
* cdef int counterf = 0
* cdef int counterl = 0 # <<<<<<<<<<<<<<
@@ -12984,7 +13129,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_counterl = 0;
- /* "pyfftw/pyfftw.pyx":1636
+ /* "pyfftw/pyfftw.pyx":1656
* cdef int counterl = 0
*
* fftw_export_wisdom(&count_char, <void *>&counter) # <<<<<<<<<<<<<<
@@ -12993,7 +13138,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
fftw_export_wisdom((&__pyx_f_6pyfftw_6pyfftw_count_char), ((void *)(&__pyx_v_counter)));
- /* "pyfftw/pyfftw.pyx":1637
+ /* "pyfftw/pyfftw.pyx":1657
*
* fftw_export_wisdom(&count_char, <void *>&counter)
* fftwf_export_wisdom(&count_char, <void *>&counterf) # <<<<<<<<<<<<<<
@@ -13002,7 +13147,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
fftwf_export_wisdom((&__pyx_f_6pyfftw_6pyfftw_count_char), ((void *)(&__pyx_v_counterf)));
- /* "pyfftw/pyfftw.pyx":1638
+ /* "pyfftw/pyfftw.pyx":1658
* fftw_export_wisdom(&count_char, <void *>&counter)
* fftwf_export_wisdom(&count_char, <void *>&counterf)
* fftwl_export_wisdom(&count_char, <void *>&counterl) # <<<<<<<<<<<<<<
@@ -13011,7 +13156,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
fftwl_export_wisdom((&__pyx_f_6pyfftw_6pyfftw_count_char), ((void *)(&__pyx_v_counterl)));
- /* "pyfftw/pyfftw.pyx":1640
+ /* "pyfftw/pyfftw.pyx":1660
* fftwl_export_wisdom(&count_char, <void *>&counterl)
*
* cdef char* c_wisdom = <char *>malloc(sizeof(char)*(counter + 1)) # <<<<<<<<<<<<<<
@@ -13020,7 +13165,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_c_wisdom = ((char *)malloc(((sizeof(char)) * (__pyx_v_counter + 1))));
- /* "pyfftw/pyfftw.pyx":1641
+ /* "pyfftw/pyfftw.pyx":1661
*
* cdef char* c_wisdom = <char *>malloc(sizeof(char)*(counter + 1))
* cdef char* c_wisdomf = <char *>malloc(sizeof(char)*(counterf + 1)) # <<<<<<<<<<<<<<
@@ -13029,7 +13174,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_c_wisdomf = ((char *)malloc(((sizeof(char)) * (__pyx_v_counterf + 1))));
- /* "pyfftw/pyfftw.pyx":1642
+ /* "pyfftw/pyfftw.pyx":1662
* cdef char* c_wisdom = <char *>malloc(sizeof(char)*(counter + 1))
* cdef char* c_wisdomf = <char *>malloc(sizeof(char)*(counterf + 1))
* cdef char* c_wisdoml = <char *>malloc(sizeof(char)*(counterl + 1)) # <<<<<<<<<<<<<<
@@ -13038,7 +13183,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_c_wisdoml = ((char *)malloc(((sizeof(char)) * (__pyx_v_counterl + 1))));
- /* "pyfftw/pyfftw.pyx":1644
+ /* "pyfftw/pyfftw.pyx":1664
* cdef char* c_wisdoml = <char *>malloc(sizeof(char)*(counterl + 1))
*
* if c_wisdom == NULL or c_wisdomf == NULL or c_wisdoml == NULL: # <<<<<<<<<<<<<<
@@ -13062,16 +13207,16 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
- /* "pyfftw/pyfftw.pyx":1645
+ /* "pyfftw/pyfftw.pyx":1665
*
* if c_wisdom == NULL or c_wisdomf == NULL or c_wisdoml == NULL:
* raise MemoryError # <<<<<<<<<<<<<<
*
* # Set the pointers to the string pointers
*/
- PyErr_NoMemory(); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1645; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyErr_NoMemory(); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1644
+ /* "pyfftw/pyfftw.pyx":1664
* cdef char* c_wisdoml = <char *>malloc(sizeof(char)*(counterl + 1))
*
* if c_wisdom == NULL or c_wisdomf == NULL or c_wisdoml == NULL: # <<<<<<<<<<<<<<
@@ -13080,7 +13225,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
}
- /* "pyfftw/pyfftw.pyx":1648
+ /* "pyfftw/pyfftw.pyx":1668
*
* # Set the pointers to the string pointers
* cdef intptr_t c_wisdom_ptr = <intptr_t>c_wisdom # <<<<<<<<<<<<<<
@@ -13089,7 +13234,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_c_wisdom_ptr = ((intptr_t)__pyx_v_c_wisdom);
- /* "pyfftw/pyfftw.pyx":1649
+ /* "pyfftw/pyfftw.pyx":1669
* # Set the pointers to the string pointers
* cdef intptr_t c_wisdom_ptr = <intptr_t>c_wisdom
* cdef intptr_t c_wisdomf_ptr = <intptr_t>c_wisdomf # <<<<<<<<<<<<<<
@@ -13098,7 +13243,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_c_wisdomf_ptr = ((intptr_t)__pyx_v_c_wisdomf);
- /* "pyfftw/pyfftw.pyx":1650
+ /* "pyfftw/pyfftw.pyx":1670
* cdef intptr_t c_wisdom_ptr = <intptr_t>c_wisdom
* cdef intptr_t c_wisdomf_ptr = <intptr_t>c_wisdomf
* cdef intptr_t c_wisdoml_ptr = <intptr_t>c_wisdoml # <<<<<<<<<<<<<<
@@ -13107,7 +13252,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_c_wisdoml_ptr = ((intptr_t)__pyx_v_c_wisdoml);
- /* "pyfftw/pyfftw.pyx":1652
+ /* "pyfftw/pyfftw.pyx":1672
* cdef intptr_t c_wisdoml_ptr = <intptr_t>c_wisdoml
*
* fftw_export_wisdom(&write_char_to_string, <void *>&c_wisdom_ptr) # <<<<<<<<<<<<<<
@@ -13116,7 +13261,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
fftw_export_wisdom((&__pyx_f_6pyfftw_6pyfftw_write_char_to_string), ((void *)(&__pyx_v_c_wisdom_ptr)));
- /* "pyfftw/pyfftw.pyx":1653
+ /* "pyfftw/pyfftw.pyx":1673
*
* fftw_export_wisdom(&write_char_to_string, <void *>&c_wisdom_ptr)
* fftwf_export_wisdom(&write_char_to_string, <void *>&c_wisdomf_ptr) # <<<<<<<<<<<<<<
@@ -13125,7 +13270,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
fftwf_export_wisdom((&__pyx_f_6pyfftw_6pyfftw_write_char_to_string), ((void *)(&__pyx_v_c_wisdomf_ptr)));
- /* "pyfftw/pyfftw.pyx":1654
+ /* "pyfftw/pyfftw.pyx":1674
* fftw_export_wisdom(&write_char_to_string, <void *>&c_wisdom_ptr)
* fftwf_export_wisdom(&write_char_to_string, <void *>&c_wisdomf_ptr)
* fftwl_export_wisdom(&write_char_to_string, <void *>&c_wisdoml_ptr) # <<<<<<<<<<<<<<
@@ -13134,7 +13279,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
fftwl_export_wisdom((&__pyx_f_6pyfftw_6pyfftw_write_char_to_string), ((void *)(&__pyx_v_c_wisdoml_ptr)));
- /* "pyfftw/pyfftw.pyx":1657
+ /* "pyfftw/pyfftw.pyx":1677
*
* # Write the last byte as the null byte
* c_wisdom[counter] = 0 # <<<<<<<<<<<<<<
@@ -13143,7 +13288,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
(__pyx_v_c_wisdom[__pyx_v_counter]) = 0;
- /* "pyfftw/pyfftw.pyx":1658
+ /* "pyfftw/pyfftw.pyx":1678
* # Write the last byte as the null byte
* c_wisdom[counter] = 0
* c_wisdomf[counterf] = 0 # <<<<<<<<<<<<<<
@@ -13152,7 +13297,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
(__pyx_v_c_wisdomf[__pyx_v_counterf]) = 0;
- /* "pyfftw/pyfftw.pyx":1659
+ /* "pyfftw/pyfftw.pyx":1679
* c_wisdom[counter] = 0
* c_wisdomf[counterf] = 0
* c_wisdoml[counterl] = 0 # <<<<<<<<<<<<<<
@@ -13161,7 +13306,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
(__pyx_v_c_wisdoml[__pyx_v_counterl]) = 0;
- /* "pyfftw/pyfftw.pyx":1661
+ /* "pyfftw/pyfftw.pyx":1681
* c_wisdoml[counterl] = 0
*
* try: # <<<<<<<<<<<<<<
@@ -13170,44 +13315,44 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
/*try:*/ {
- /* "pyfftw/pyfftw.pyx":1662
+ /* "pyfftw/pyfftw.pyx":1682
*
* try:
* py_wisdom = c_wisdom # <<<<<<<<<<<<<<
* py_wisdomf = c_wisdomf
* py_wisdoml = c_wisdoml
*/
- __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_c_wisdom); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1662; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
+ __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_c_wisdom); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1682; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_py_wisdom = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
- /* "pyfftw/pyfftw.pyx":1663
+ /* "pyfftw/pyfftw.pyx":1683
* try:
* py_wisdom = c_wisdom
* py_wisdomf = c_wisdomf # <<<<<<<<<<<<<<
* py_wisdoml = c_wisdoml
*
*/
- __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_c_wisdomf); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1663; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
+ __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_c_wisdomf); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1683; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_py_wisdomf = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
- /* "pyfftw/pyfftw.pyx":1664
+ /* "pyfftw/pyfftw.pyx":1684
* py_wisdom = c_wisdom
* py_wisdomf = c_wisdomf
* py_wisdoml = c_wisdoml # <<<<<<<<<<<<<<
*
* finally:
*/
- __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_c_wisdoml); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1664; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
+ __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_c_wisdoml); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1684; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_py_wisdoml = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
}
- /* "pyfftw/pyfftw.pyx":1667
+ /* "pyfftw/pyfftw.pyx":1687
*
* finally:
* free(c_wisdom) # <<<<<<<<<<<<<<
@@ -13218,7 +13363,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
/*normal exit:*/{
free(__pyx_v_c_wisdom);
- /* "pyfftw/pyfftw.pyx":1668
+ /* "pyfftw/pyfftw.pyx":1688
* finally:
* free(c_wisdom)
* free(c_wisdomf) # <<<<<<<<<<<<<<
@@ -13227,7 +13372,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
free(__pyx_v_c_wisdomf);
- /* "pyfftw/pyfftw.pyx":1669
+ /* "pyfftw/pyfftw.pyx":1689
* free(c_wisdom)
* free(c_wisdomf)
* free(c_wisdoml) # <<<<<<<<<<<<<<
@@ -13252,7 +13397,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
__pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
{
- /* "pyfftw/pyfftw.pyx":1667
+ /* "pyfftw/pyfftw.pyx":1687
*
* finally:
* free(c_wisdom) # <<<<<<<<<<<<<<
@@ -13261,7 +13406,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
free(__pyx_v_c_wisdom);
- /* "pyfftw/pyfftw.pyx":1668
+ /* "pyfftw/pyfftw.pyx":1688
* finally:
* free(c_wisdom)
* free(c_wisdomf) # <<<<<<<<<<<<<<
@@ -13270,7 +13415,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
*/
free(__pyx_v_c_wisdomf);
- /* "pyfftw/pyfftw.pyx":1669
+ /* "pyfftw/pyfftw.pyx":1689
* free(c_wisdom)
* free(c_wisdomf)
* free(c_wisdoml) # <<<<<<<<<<<<<<
@@ -13296,7 +13441,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
__pyx_L9:;
}
- /* "pyfftw/pyfftw.pyx":1671
+ /* "pyfftw/pyfftw.pyx":1691
* free(c_wisdoml)
*
* return (py_wisdom, py_wisdomf, py_wisdoml) # <<<<<<<<<<<<<<
@@ -13304,7 +13449,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
* def import_wisdom(wisdom):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1671; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1691; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_py_wisdom);
__Pyx_GIVEREF(__pyx_v_py_wisdom);
@@ -13319,7 +13464,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
__pyx_t_3 = 0;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":1614
+ /* "pyfftw/pyfftw.pyx":1634
*
*
* def export_wisdom(): # <<<<<<<<<<<<<<
@@ -13341,7 +13486,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":1673
+/* "pyfftw/pyfftw.pyx":1693
* return (py_wisdom, py_wisdomf, py_wisdoml)
*
* def import_wisdom(wisdom): # <<<<<<<<<<<<<<
@@ -13351,7 +13496,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_20export_wisdom(CYTHON_UNUSED PyObject
/* Python wrapper */
static PyObject *__pyx_pw_6pyfftw_6pyfftw_23import_wisdom(PyObject *__pyx_self, PyObject *__pyx_v_wisdom); /*proto*/
-static char __pyx_doc_6pyfftw_6pyfftw_22import_wisdom[] = "import_wisdom(wisdom)\n\n Function that imports wisdom from the passed tuple\n of strings.\n\n The first string in the tuple is the string for the double\n precision wisdom. The second string in the tuple is the string \n for the single precision wisdom. The third string in the tuple \n is the string for the long double precision wisdom.\n\n The tuple that is returned from :func:`~pyfftw.export_wisdom`\n c [...]
+static char __pyx_doc_6pyfftw_6pyfftw_22import_wisdom[] = "import_wisdom(wisdom)\n\n Function that imports wisdom from the passed tuple\n of strings.\n\n The first string in the tuple is the string for the double\n precision wisdom. The second string in the tuple is the string\n for the single precision wisdom. The third string in the tuple\n is the string for the long double precision wisdom.\n\n The tuple that is returned from :func:`~pyfftw.export_wisdom`\n can [...]
static PyMethodDef __pyx_mdef_6pyfftw_6pyfftw_23import_wisdom = {"import_wisdom", (PyCFunction)__pyx_pw_6pyfftw_6pyfftw_23import_wisdom, METH_O, __pyx_doc_6pyfftw_6pyfftw_22import_wisdom};
static PyObject *__pyx_pw_6pyfftw_6pyfftw_23import_wisdom(PyObject *__pyx_self, PyObject *__pyx_v_wisdom) {
PyObject *__pyx_r = 0;
@@ -13383,46 +13528,46 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_22import_wisdom(CYTHON_UNUSED PyObject
int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("import_wisdom", 0);
- /* "pyfftw/pyfftw.pyx":1692
+ /* "pyfftw/pyfftw.pyx":1712
* '''
*
* cdef char* c_wisdom = wisdom[0] # <<<<<<<<<<<<<<
* cdef char* c_wisdomf = wisdom[1]
* cdef char* c_wisdoml = wisdom[2]
*/
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_wisdom, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1692; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_wisdom, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1712; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1692; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1712; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_v_c_wisdom = __pyx_t_2;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1693
+ /* "pyfftw/pyfftw.pyx":1713
*
* cdef char* c_wisdom = wisdom[0]
* cdef char* c_wisdomf = wisdom[1] # <<<<<<<<<<<<<<
* cdef char* c_wisdoml = wisdom[2]
*
*/
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_wisdom, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1693; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_wisdom, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1713; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1693; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1713; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_v_c_wisdomf = __pyx_t_2;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1694
+ /* "pyfftw/pyfftw.pyx":1714
* cdef char* c_wisdom = wisdom[0]
* cdef char* c_wisdomf = wisdom[1]
* cdef char* c_wisdoml = wisdom[2] # <<<<<<<<<<<<<<
*
* cdef bint success = fftw_import_wisdom_from_string(c_wisdom)
*/
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_wisdom, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1694; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_wisdom, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1714; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1714; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_v_c_wisdoml = __pyx_t_2;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "pyfftw/pyfftw.pyx":1696
+ /* "pyfftw/pyfftw.pyx":1716
* cdef char* c_wisdoml = wisdom[2]
*
* cdef bint success = fftw_import_wisdom_from_string(c_wisdom) # <<<<<<<<<<<<<<
@@ -13431,7 +13576,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_22import_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_success = fftw_import_wisdom_from_string(__pyx_v_c_wisdom);
- /* "pyfftw/pyfftw.pyx":1697
+ /* "pyfftw/pyfftw.pyx":1717
*
* cdef bint success = fftw_import_wisdom_from_string(c_wisdom)
* cdef bint successf = fftwf_import_wisdom_from_string(c_wisdomf) # <<<<<<<<<<<<<<
@@ -13440,7 +13585,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_22import_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_successf = fftwf_import_wisdom_from_string(__pyx_v_c_wisdomf);
- /* "pyfftw/pyfftw.pyx":1698
+ /* "pyfftw/pyfftw.pyx":1718
* cdef bint success = fftw_import_wisdom_from_string(c_wisdom)
* cdef bint successf = fftwf_import_wisdom_from_string(c_wisdomf)
* cdef bint successl = fftwl_import_wisdom_from_string(c_wisdoml) # <<<<<<<<<<<<<<
@@ -13449,7 +13594,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_22import_wisdom(CYTHON_UNUSED PyObject
*/
__pyx_v_successl = fftwl_import_wisdom_from_string(__pyx_v_c_wisdoml);
- /* "pyfftw/pyfftw.pyx":1700
+ /* "pyfftw/pyfftw.pyx":1720
* cdef bint successl = fftwl_import_wisdom_from_string(c_wisdoml)
*
* return (success, successf, successl) # <<<<<<<<<<<<<<
@@ -13457,13 +13602,13 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_22import_wisdom(CYTHON_UNUSED PyObject
* #def export_wisdom_to_files(
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_success); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1700; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_success); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1720; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_successf); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1700; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_successf); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1720; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_successl); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1700; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_successl); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1720; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1700; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1720; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
@@ -13478,7 +13623,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_22import_wisdom(CYTHON_UNUSED PyObject
__pyx_t_5 = 0;
goto __pyx_L0;
- /* "pyfftw/pyfftw.pyx":1673
+ /* "pyfftw/pyfftw.pyx":1693
* return (py_wisdom, py_wisdomf, py_wisdoml)
*
* def import_wisdom(wisdom): # <<<<<<<<<<<<<<
@@ -13500,7 +13645,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_22import_wisdom(CYTHON_UNUSED PyObject
return __pyx_r;
}
-/* "pyfftw/pyfftw.pyx":1789
+/* "pyfftw/pyfftw.pyx":1809
* # return (success, successf, successl)
*
* def forget_wisdom(): # <<<<<<<<<<<<<<
@@ -13528,7 +13673,7 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_24forget_wisdom(CYTHON_UNUSED PyObject
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("forget_wisdom", 0);
- /* "pyfftw/pyfftw.pyx":1794
+ /* "pyfftw/pyfftw.pyx":1814
* Forget all the accumulated wisdom.
* '''
* fftw_forget_wisdom() # <<<<<<<<<<<<<<
@@ -13537,25 +13682,22 @@ static PyObject *__pyx_pf_6pyfftw_6pyfftw_24forget_wisdom(CYTHON_UNUSED PyObject
*/
fftw_forget_wisdom();
- /* "pyfftw/pyfftw.pyx":1795
+ /* "pyfftw/pyfftw.pyx":1815
* '''
* fftw_forget_wisdom()
* fftwf_forget_wisdom() # <<<<<<<<<<<<<<
* fftwl_forget_wisdom()
- *
*/
fftwf_forget_wisdom();
- /* "pyfftw/pyfftw.pyx":1796
+ /* "pyfftw/pyfftw.pyx":1816
* fftw_forget_wisdom()
* fftwf_forget_wisdom()
* fftwl_forget_wisdom() # <<<<<<<<<<<<<<
- *
- *
*/
fftwl_forget_wisdom();
- /* "pyfftw/pyfftw.pyx":1789
+ /* "pyfftw/pyfftw.pyx":1809
* # return (success, successf, successl)
*
* def forget_wisdom(): # <<<<<<<<<<<<<<
@@ -13742,7 +13884,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P
*
* if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -13798,7 +13940,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P
*
* info.buf = PyArray_DATA(self)
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -14107,7 +14249,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P
* if t == NPY_BYTE: f = "b"
* elif t == NPY_UBYTE: f = "B"
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -14940,7 +15082,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
*
* if ((child.byteorder == c'>' and little_endian) or
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -15008,7 +15150,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
* # One could encode it in the format string and have Cython
* # complain instead, BUT: < and > in format strings also imply
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -15117,7 +15259,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
*
* # Until ticket #99 is fixed, use integers to avoid warnings
*/
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -15899,7 +16041,7 @@ static PyTypeObject __pyx_type_6pyfftw_6pyfftw_FFTW = {
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
- "\n FFTW is a class for computing the complex N-Dimensional DFT or\n inverse DFT of an array using the FFTW library. The interface is \n designed to be somewhat pythonic, with the correct transform being \n inferred from the dtypes of the passed arrays.\n\n On instantiation, the dtypes and relative shapes of the input array and\n output arrays are compared to the set of valid (and implemented)\n :ref:`FFTW schemes <scheme_table>`. If a match is found, the plan tha [...]
+ "\n FFTW is a class for computing the complex N-Dimensional DFT or\n inverse DFT of an array using the FFTW library. The interface is\n designed to be somewhat pythonic, with the correct transform being\n inferred from the dtypes of the passed arrays.\n\n On instantiation, the dtypes and relative shapes of the input array and\n output arrays are compared to the set of valid (and implemented)\n :ref:`FFTW schemes <scheme_table>`. If a match is found, the plan that\ [...]
__pyx_tp_traverse_6pyfftw_6pyfftw_FFTW, /*tp_traverse*/
__pyx_tp_clear_6pyfftw_6pyfftw_FFTW, /*tp_clear*/
0, /*tp_richcompare*/
@@ -15992,6 +16134,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{&__pyx_kp_s_Invalid_input_dtype_The_new_inpu, __pyx_k_Invalid_input_dtype_The_new_inpu, sizeof(__pyx_k_Invalid_input_dtype_The_new_inpu), 0, 0, 1, 0},
{&__pyx_kp_s_Invalid_input_shape_The_new_inpu, __pyx_k_Invalid_input_shape_The_new_inpu, sizeof(__pyx_k_Invalid_input_shape_The_new_inpu), 0, 0, 1, 0},
{&__pyx_kp_s_Invalid_input_striding_The_strid, __pyx_k_Invalid_input_striding_The_strid, sizeof(__pyx_k_Invalid_input_striding_The_strid), 0, 0, 1, 0},
+ {&__pyx_kp_s_Invalid_options_ortho_and_normal, __pyx_k_Invalid_options_ortho_and_normal, sizeof(__pyx_k_Invalid_options_ortho_and_normal), 0, 0, 1, 0},
{&__pyx_kp_s_Invalid_output_alignment_The_ori, __pyx_k_Invalid_output_alignment_The_ori, sizeof(__pyx_k_Invalid_output_alignment_The_ori), 0, 0, 1, 0},
{&__pyx_kp_s_Invalid_output_alignment_The_out, __pyx_k_Invalid_output_alignment_The_out, sizeof(__pyx_k_Invalid_output_alignment_The_out), 0, 0, 1, 0},
{&__pyx_kp_s_Invalid_output_array_The_new_out, __pyx_k_Invalid_output_array_The_new_out, sizeof(__pyx_k_Invalid_output_array_The_new_out), 0, 0, 1, 0},
@@ -16103,6 +16246,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1},
{&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
{&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1},
+ {&__pyx_n_s_ortho, __pyx_k_ortho, sizeof(__pyx_k_ortho), 0, 0, 1, 1},
{&__pyx_n_s_output_alignment, __pyx_k_output_alignment, sizeof(__pyx_k_output_alignment), 0, 0, 1, 1},
{&__pyx_n_s_output_array, __pyx_k_output_array, sizeof(__pyx_k_output_array), 0, 0, 1, 1},
{&__pyx_n_s_output_dtype, __pyx_k_output_dtype, sizeof(__pyx_k_output_dtype), 0, 0, 1, 1},
@@ -16123,6 +16267,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1},
{&__pyx_n_s_simd_aligned, __pyx_k_simd_aligned, sizeof(__pyx_k_simd_aligned), 0, 0, 1, 1},
{&__pyx_n_s_simd_alignment, __pyx_k_simd_alignment, sizeof(__pyx_k_simd_alignment), 0, 0, 1, 1},
+ {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1},
{&__pyx_n_s_strides, __pyx_k_strides, sizeof(__pyx_k_strides), 0, 0, 1, 1},
{&__pyx_n_s_success, __pyx_k_success, sizeof(__pyx_k_success), 0, 0, 1, 1},
{&__pyx_n_s_successf, __pyx_k_successf, sizeof(__pyx_k_successf), 0, 0, 1, 1},
@@ -16144,15 +16289,15 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{0, 0, 0, 0, 0, 0, 0}
};
static int __Pyx_InitCachedBuiltins(void) {
- __pyx_builtin_property = __Pyx_GetBuiltinName(__pyx_n_s_property); if (!__pyx_builtin_property) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_builtin_property = __Pyx_GetBuiltinName(__pyx_n_s_property); if (!__pyx_builtin_property) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_builtin_DeprecationWarning = __Pyx_GetBuiltinName(__pyx_n_s_DeprecationWarning); if (!__pyx_builtin_DeprecationWarning) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 111; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 951; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1026; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1108; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 851; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 952; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1028; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
return 0;
__pyx_L1_error:;
return -1;
@@ -16216,280 +16361,291 @@ static int __Pyx_InitCachedConstants(void) {
__Pyx_GOTREF(__pyx_tuple__5);
__Pyx_GIVEREF(__pyx_tuple__5);
- /* "pyfftw/pyfftw.pyx":811
+ /* "pyfftw/pyfftw.pyx":812
* axes = property(_get_axes)
*
* def __cinit__(self, input_array, output_array, axes=(-1,), # <<<<<<<<<<<<<<
* direction='FFTW_FORWARD', flags=('FFTW_MEASURE',),
* unsigned int threads=1, planning_timelimit=None,
*/
- __pyx_tuple__6 = PyTuple_Pack(1, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 811; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 812; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__6);
__Pyx_GIVEREF(__pyx_tuple__6);
- /* "pyfftw/pyfftw.pyx":812
+ /* "pyfftw/pyfftw.pyx":813
*
* def __cinit__(self, input_array, output_array, axes=(-1,),
* direction='FFTW_FORWARD', flags=('FFTW_MEASURE',), # <<<<<<<<<<<<<<
* unsigned int threads=1, planning_timelimit=None,
* *args, **kwargs):
*/
- __pyx_tuple__7 = PyTuple_Pack(1, __pyx_n_s_FFTW_MEASURE); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 812; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_n_s_FFTW_MEASURE); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__7);
__Pyx_GIVEREF(__pyx_tuple__7);
- /* "pyfftw/pyfftw.pyx":833
+ /* "pyfftw/pyfftw.pyx":834
* _planning_timelimit = planning_timelimit
* except TypeError:
* raise TypeError('Invalid planning timelimit: ' # <<<<<<<<<<<<<<
* 'The planning timelimit needs to be a float.')
*
*/
- __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_Invalid_planning_timelimit_The_p); if (unlikely(!__pyx_tuple__8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_Invalid_planning_timelimit_The_p); if (unlikely(!__pyx_tuple__8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__8);
__Pyx_GIVEREF(__pyx_tuple__8);
- /* "pyfftw/pyfftw.pyx":837
+ /* "pyfftw/pyfftw.pyx":838
*
* if not isinstance(input_array, np.ndarray):
* raise ValueError('Invalid input array: ' # <<<<<<<<<<<<<<
* 'The input array needs to be an instance '
* 'of numpy.ndarray')
*/
- __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_array_The_input_ar); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_array_The_input_ar); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__9);
__Pyx_GIVEREF(__pyx_tuple__9);
- /* "pyfftw/pyfftw.pyx":842
+ /* "pyfftw/pyfftw.pyx":843
*
* if not isinstance(output_array, np.ndarray):
* raise ValueError('Invalid output array: ' # <<<<<<<<<<<<<<
* 'The output array needs to be an instance '
* 'of numpy.ndarray')
*/
- __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Invalid_output_array_The_output); if (unlikely(!__pyx_tuple__10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Invalid_output_array_The_output); if (unlikely(!__pyx_tuple__10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__10);
__Pyx_GIVEREF(__pyx_tuple__10);
- /* "pyfftw/pyfftw.pyx":851
+ /* "pyfftw/pyfftw.pyx":852
* scheme = fftw_schemes[(input_dtype, output_dtype)]
* except KeyError:
* raise ValueError('Invalid scheme: ' # <<<<<<<<<<<<<<
* 'The output array and input array dtypes '
* 'do not correspond to a valid fftw scheme.')
*/
- __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_Invalid_scheme_The_output_array); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 851; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_Invalid_scheme_The_output_array); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__11);
__Pyx_GIVEREF(__pyx_tuple__11);
- /* "pyfftw/pyfftw.pyx":927
+ /* "pyfftw/pyfftw.pyx":928
*
* if not direction in scheme_directions[scheme]:
* raise ValueError('Invalid direction: ' # <<<<<<<<<<<<<<
* 'The direction is not valid for the scheme. '
* 'Try setting it explicitly if it is not already.')
*/
- __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_Invalid_direction_The_direction); if (unlikely(!__pyx_tuple__12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 927; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_Invalid_direction_The_direction); if (unlikely(!__pyx_tuple__12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 928; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__12);
__Pyx_GIVEREF(__pyx_tuple__12);
- /* "pyfftw/pyfftw.pyx":951
+ /* "pyfftw/pyfftw.pyx":952
*
* if self._axes[n] >= array_dimension or self._axes[n] < 0:
* raise IndexError('Invalid axes: ' # <<<<<<<<<<<<<<
* 'The axes list cannot contain invalid axes.')
*
*/
- __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_Invalid_axes_The_axes_list_canno); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 951; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_Invalid_axes_The_axes_list_canno); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 952; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__13);
__Pyx_GIVEREF(__pyx_tuple__13);
- /* "pyfftw/pyfftw.pyx":969
+ /* "pyfftw/pyfftw.pyx":970
* for n in range(unique_axes_length):
* if self._input_shape[self._axes[n]] == 0:
* raise ValueError('Zero length array: ' # <<<<<<<<<<<<<<
* 'The input array should have no zero length'
* 'axes over which the FFT is to be taken')
*/
- __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_Zero_length_array_The_input_arra); if (unlikely(!__pyx_tuple__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 969; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_Zero_length_array_The_input_arra); if (unlikely(!__pyx_tuple__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__14);
__Pyx_GIVEREF(__pyx_tuple__14);
- /* "pyfftw/pyfftw.pyx":986
+ /* "pyfftw/pyfftw.pyx":988
* if functions['validator'] == -1:
* if not (output_array.shape == input_array.shape):
* raise ValueError('Invalid shapes: ' # <<<<<<<<<<<<<<
* 'The output array should be the same shape as the '
* 'input array for the given array dtypes.')
*/
- __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_Invalid_shapes_The_output_array); if (unlikely(!__pyx_tuple__15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_Invalid_shapes_The_output_array); if (unlikely(!__pyx_tuple__15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 988; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__15);
__Pyx_GIVEREF(__pyx_tuple__15);
- /* "pyfftw/pyfftw.pyx":993
+ /* "pyfftw/pyfftw.pyx":995
* if not _validator(input_array, output_array,
* self._axes, self._not_axes, unique_axes_length):
* raise ValueError('Invalid shapes: ' # <<<<<<<<<<<<<<
* 'The input array and output array are invalid '
* 'complementary shapes for their dtypes.')
*/
- __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Invalid_shapes_The_input_array_a); if (unlikely(!__pyx_tuple__16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Invalid_shapes_The_input_array_a); if (unlikely(!__pyx_tuple__16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__16);
__Pyx_GIVEREF(__pyx_tuple__16);
- /* "pyfftw/pyfftw.pyx":1101
+ /* "pyfftw/pyfftw.pyx":1103
* cdef unsigned c_flags = self._flags
*
* with plan_lock, nogil: # <<<<<<<<<<<<<<
* plan = fftw_planner(rank, dims, howmany_rank, howmany_dims,
* _in, _out, sign, c_flags)
*/
- __pyx_tuple__18 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1101; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__18 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1103; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__18);
__Pyx_GIVEREF(__pyx_tuple__18);
- /* "pyfftw/pyfftw.pyx":1108
+ /* "pyfftw/pyfftw.pyx":1110
* if self._plan == NULL:
* if 'FFTW_WISDOM_ONLY' in flags:
* raise RuntimeError('No FFTW wisdom is known for this plan.') # <<<<<<<<<<<<<<
* else:
* raise RuntimeError('The data has an uncaught error that led '+
*/
- __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_No_FFTW_wisdom_is_known_for_this); if (unlikely(!__pyx_tuple__19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1108; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_No_FFTW_wisdom_is_known_for_this); if (unlikely(!__pyx_tuple__19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__19);
__Pyx_GIVEREF(__pyx_tuple__19);
- /* "pyfftw/pyfftw.pyx":1113
+ /* "pyfftw/pyfftw.pyx":1115
* 'to the planner returning NULL. This is a bug.')
*
* def __init__(self, input_array, output_array, axes=(-1,), # <<<<<<<<<<<<<<
* direction='FFTW_FORWARD', flags=('FFTW_MEASURE',),
* int threads=1, planning_timelimit=None):
*/
- __pyx_tuple__20 = PyTuple_Pack(1, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__20 = PyTuple_Pack(1, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1115; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__20);
__Pyx_GIVEREF(__pyx_tuple__20);
- /* "pyfftw/pyfftw.pyx":1114
+ /* "pyfftw/pyfftw.pyx":1116
*
* def __init__(self, input_array, output_array, axes=(-1,),
* direction='FFTW_FORWARD', flags=('FFTW_MEASURE',), # <<<<<<<<<<<<<<
* int threads=1, planning_timelimit=None):
* '''
*/
- __pyx_tuple__21 = PyTuple_Pack(1, __pyx_n_s_FFTW_MEASURE); if (unlikely(!__pyx_tuple__21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1114; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__21 = PyTuple_Pack(1, __pyx_n_s_FFTW_MEASURE); if (unlikely(!__pyx_tuple__21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1116; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__21);
__Pyx_GIVEREF(__pyx_tuple__21);
- /* "pyfftw/pyfftw.pyx":1423
+ /* "pyfftw/pyfftw.pyx":1412
+ *
+ * if ortho and normalise_idft:
+ * raise ValueError('Invalid options: ortho and normalise_idft cannot' # <<<<<<<<<<<<<<
+ * ' both be True.')
+ *
+ */
+ __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_Invalid_options_ortho_and_normal); if (unlikely(!__pyx_tuple__22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__22);
+ __Pyx_GIVEREF(__pyx_tuple__22);
+
+ /* "pyfftw/pyfftw.pyx":1441
*
* if not input_array.shape == self._input_shape:
* raise ValueError('Invalid input shape: ' # <<<<<<<<<<<<<<
* 'The new input array should be the same shape '
* 'as the input array used to instantiate the '
*/
- __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_shape_The_new_inpu); if (unlikely(!__pyx_tuple__22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1423; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__22);
- __Pyx_GIVEREF(__pyx_tuple__22);
+ __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_shape_The_new_inpu); if (unlikely(!__pyx_tuple__23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__23);
+ __Pyx_GIVEREF(__pyx_tuple__23);
- /* "pyfftw/pyfftw.pyx":1428
+ /* "pyfftw/pyfftw.pyx":1446
* 'object.')
*
* self._input_array[:] = input_array # <<<<<<<<<<<<<<
*
* if output_array is not None:
*/
- __pyx_slice__23 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1428; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__23);
- __Pyx_GIVEREF(__pyx_slice__23);
+ __pyx_slice__24 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_slice__24);
+ __Pyx_GIVEREF(__pyx_slice__24);
- /* "pyfftw/pyfftw.pyx":1470
+ /* "pyfftw/pyfftw.pyx":1490
* '''
* if not isinstance(new_input_array, np.ndarray):
* raise ValueError('Invalid input array: ' # <<<<<<<<<<<<<<
* 'The new input array needs to be an instance '
* 'of numpy.ndarray')
*/
- __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_array_The_new_inpu); if (unlikely(!__pyx_tuple__24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1470; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__24);
- __Pyx_GIVEREF(__pyx_tuple__24);
+ __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_array_The_new_inpu); if (unlikely(!__pyx_tuple__25)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__25);
+ __Pyx_GIVEREF(__pyx_tuple__25);
- /* "pyfftw/pyfftw.pyx":1475
+ /* "pyfftw/pyfftw.pyx":1495
*
* if not isinstance(new_output_array, np.ndarray):
* raise ValueError('Invalid output array ' # <<<<<<<<<<<<<<
* 'The new output array needs to be an instance '
* 'of numpy.ndarray')
*/
- __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_Invalid_output_array_The_new_out); if (unlikely(!__pyx_tuple__25)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__25);
- __Pyx_GIVEREF(__pyx_tuple__25);
+ __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_Invalid_output_array_The_new_out); if (unlikely(!__pyx_tuple__26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1495; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__26);
+ __Pyx_GIVEREF(__pyx_tuple__26);
- /* "pyfftw/pyfftw.pyx":1494
+ /* "pyfftw/pyfftw.pyx":1514
*
* if not new_input_array.dtype == self._input_dtype:
* raise ValueError('Invalid input dtype: ' # <<<<<<<<<<<<<<
* 'The new input array is not of the same '
* 'dtype as was originally planned for.')
*/
- __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_dtype_The_new_inpu); if (unlikely(!__pyx_tuple__26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1494; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__26);
- __Pyx_GIVEREF(__pyx_tuple__26);
+ __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_dtype_The_new_inpu); if (unlikely(!__pyx_tuple__27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1514; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__27);
+ __Pyx_GIVEREF(__pyx_tuple__27);
- /* "pyfftw/pyfftw.pyx":1499
+ /* "pyfftw/pyfftw.pyx":1519
*
* if not new_output_array.dtype == self._output_dtype:
* raise ValueError('Invalid output dtype: ' # <<<<<<<<<<<<<<
* 'The new output array is not of the same '
* 'dtype as was originally planned for.')
*/
- __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_Invalid_output_dtype_The_new_out); if (unlikely(!__pyx_tuple__27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__27);
- __Pyx_GIVEREF(__pyx_tuple__27);
+ __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_Invalid_output_dtype_The_new_out); if (unlikely(!__pyx_tuple__28)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__28);
+ __Pyx_GIVEREF(__pyx_tuple__28);
- /* "pyfftw/pyfftw.pyx":1510
+ /* "pyfftw/pyfftw.pyx":1530
*
* if not new_input_shape == self._input_shape:
* raise ValueError('Invalid input shape: ' # <<<<<<<<<<<<<<
* 'The new input array should be the same shape as '
* 'the input array used to instantiate the object.')
*/
- __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_shape_The_new_inpu); if (unlikely(!__pyx_tuple__28)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1510; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__28);
- __Pyx_GIVEREF(__pyx_tuple__28);
+ __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_shape_The_new_inpu); if (unlikely(!__pyx_tuple__29)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1530; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__29);
+ __Pyx_GIVEREF(__pyx_tuple__29);
- /* "pyfftw/pyfftw.pyx":1515
+ /* "pyfftw/pyfftw.pyx":1535
*
* if not new_output_shape == self._output_shape:
* raise ValueError('Invalid output shape: ' # <<<<<<<<<<<<<<
* 'The new output array should be the same shape as '
* 'the output array used to instantiate the object.')
*/
- __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_Invalid_output_shape_The_new_out); if (unlikely(!__pyx_tuple__29)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1515; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__29);
- __Pyx_GIVEREF(__pyx_tuple__29);
+ __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_Invalid_output_shape_The_new_out); if (unlikely(!__pyx_tuple__30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1535; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__30);
+ __Pyx_GIVEREF(__pyx_tuple__30);
- /* "pyfftw/pyfftw.pyx":1520
+ /* "pyfftw/pyfftw.pyx":1540
*
* if not new_input_strides == self._input_strides:
* raise ValueError('Invalid input striding: ' # <<<<<<<<<<<<<<
* 'The strides should be identical for the new '
* 'input array as for the old.')
*/
- __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_striding_The_strid); if (unlikely(!__pyx_tuple__30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__30);
- __Pyx_GIVEREF(__pyx_tuple__30);
+ __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input_striding_The_strid); if (unlikely(!__pyx_tuple__31)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__31);
+ __Pyx_GIVEREF(__pyx_tuple__31);
- /* "pyfftw/pyfftw.pyx":1525
+ /* "pyfftw/pyfftw.pyx":1545
*
* if not new_output_strides == self._output_strides:
* raise ValueError('Invalid output striding: ' # <<<<<<<<<<<<<<
* 'The strides should be identical for the new '
* 'output array as for the old.')
*/
- __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_Invalid_output_striding_The_stri); if (unlikely(!__pyx_tuple__31)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1525; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__31);
- __Pyx_GIVEREF(__pyx_tuple__31);
+ __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_Invalid_output_striding_The_stri); if (unlikely(!__pyx_tuple__32)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1545; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__32);
+ __Pyx_GIVEREF(__pyx_tuple__32);
/* "../../../../../usr/lib/python2.7/dist-packages/Cython/Includes/numpy/__init__.pxd":218
* if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
@@ -16498,9 +16654,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
*/
- __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__32)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__32);
- __Pyx_GIVEREF(__pyx_tuple__32);
+ __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__33)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__33);
+ __Pyx_GIVEREF(__pyx_tuple__33);
/* "../../../../../usr/lib/python2.7/dist-packages/Cython/Includes/numpy/__init__.pxd":222
* if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
@@ -16509,9 +16665,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* info.buf = PyArray_DATA(self)
*/
- __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__33)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__33);
- __Pyx_GIVEREF(__pyx_tuple__33);
+ __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__34)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__34);
+ __Pyx_GIVEREF(__pyx_tuple__34);
/* "../../../../../usr/lib/python2.7/dist-packages/Cython/Includes/numpy/__init__.pxd":259
* if ((descr.byteorder == c'>' and little_endian) or
@@ -16520,9 +16676,9 @@ static int __Pyx_InitCachedConstants(void) {
* if t == NPY_BYTE: f = "b"
* elif t == NPY_UBYTE: f = "B"
*/
- __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__34)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__34);
- __Pyx_GIVEREF(__pyx_tuple__34);
+ __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__35)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__35);
+ __Pyx_GIVEREF(__pyx_tuple__35);
/* "../../../../../usr/lib/python2.7/dist-packages/Cython/Includes/numpy/__init__.pxd":799
*
@@ -16531,9 +16687,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* if ((child.byteorder == c'>' and little_endian) or
*/
- __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__35)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__35);
- __Pyx_GIVEREF(__pyx_tuple__35);
+ __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__36)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__36);
+ __Pyx_GIVEREF(__pyx_tuple__36);
/* "../../../../../usr/lib/python2.7/dist-packages/Cython/Includes/numpy/__init__.pxd":803
* if ((child.byteorder == c'>' and little_endian) or
@@ -16542,9 +16698,9 @@ static int __Pyx_InitCachedConstants(void) {
* # One could encode it in the format string and have Cython
* # complain instead, BUT: < and > in format strings also imply
*/
- __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__36)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__36);
- __Pyx_GIVEREF(__pyx_tuple__36);
+ __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__37)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__37);
+ __Pyx_GIVEREF(__pyx_tuple__37);
/* "../../../../../usr/lib/python2.7/dist-packages/Cython/Includes/numpy/__init__.pxd":823
* t = child.type_num
@@ -16553,9 +16709,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* # Until ticket #99 is fixed, use integers to avoid warnings
*/
- __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__37)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__37);
- __Pyx_GIVEREF(__pyx_tuple__37);
+ __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__38)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__38);
+ __Pyx_GIVEREF(__pyx_tuple__38);
/* "pyfftw/utils.pxi":51
* #: A tuple of simd alignments that make sense for this cpu
@@ -16564,9 +16720,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* elif _simd_alignment == 32:
*/
- __pyx_tuple__38 = PyTuple_Pack(1, __pyx_int_16); if (unlikely(!__pyx_tuple__38)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__38);
- __Pyx_GIVEREF(__pyx_tuple__38);
+ __pyx_tuple__39 = PyTuple_Pack(1, __pyx_int_16); if (unlikely(!__pyx_tuple__39)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__39);
+ __Pyx_GIVEREF(__pyx_tuple__39);
/* "pyfftw/utils.pxi":54
*
@@ -16575,9 +16731,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* else:
*/
- __pyx_tuple__39 = PyTuple_Pack(2, __pyx_int_16, __pyx_int_32); if (unlikely(!__pyx_tuple__39)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__39);
- __Pyx_GIVEREF(__pyx_tuple__39);
+ __pyx_tuple__40 = PyTuple_Pack(2, __pyx_int_16, __pyx_int_32); if (unlikely(!__pyx_tuple__40)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__40);
+ __Pyx_GIVEREF(__pyx_tuple__40);
/* "pyfftw/pyfftw.pyx":408
* # Shape lookup functions
@@ -16586,10 +16742,10 @@ static int __Pyx_InitCachedConstants(void) {
* return input_array.shape
*
*/
- __pyx_tuple__40 = PyTuple_Pack(2, __pyx_n_s_input_array, __pyx_n_s_output_array); if (unlikely(!__pyx_tuple__40)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 408; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__40);
- __Pyx_GIVEREF(__pyx_tuple__40);
- __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__40, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_whg_Projects_github_pyFFTW, __pyx_n_s_lookup_shape_r2c_arrays, 408, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 408; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__41 = PyTuple_Pack(2, __pyx_n_s_input_array, __pyx_n_s_output_array); if (unlikely(!__pyx_tuple__41)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 408; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__41);
+ __Pyx_GIVEREF(__pyx_tuple__41);
+ __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_whg_Projects_github_pyFFTW, __pyx_n_s_lookup_shape_r2c_arrays, 408, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 408; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
/* "pyfftw/pyfftw.pyx":411
* return input_array.shape
@@ -16598,10 +16754,10 @@ static int __Pyx_InitCachedConstants(void) {
* return output_array.shape
*
*/
- __pyx_tuple__42 = PyTuple_Pack(2, __pyx_n_s_input_array, __pyx_n_s_output_array); if (unlikely(!__pyx_tuple__42)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__42);
- __Pyx_GIVEREF(__pyx_tuple__42);
- __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__42, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_whg_Projects_github_pyFFTW, __pyx_n_s_lookup_shape_c2r_arrays, 411, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__43 = PyTuple_Pack(2, __pyx_n_s_input_array, __pyx_n_s_output_array); if (unlikely(!__pyx_tuple__43)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__43);
+ __Pyx_GIVEREF(__pyx_tuple__43);
+ __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_whg_Projects_github_pyFFTW, __pyx_n_s_lookup_shape_c2r_arrays, 411, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
/* "pyfftw/pyfftw.pyx":446
* cdef object fftw_schemes
@@ -16610,15 +16766,15 @@ static int __Pyx_InitCachedConstants(void) {
* (np.dtype('complex64'), np.dtype('complex64')): ('c2c', '32'),
* (np.dtype('float64'), np.dtype('complex128')): ('r2c', '64'),
*/
- __pyx_tuple__44 = PyTuple_Pack(1, __pyx_n_s_complex128); if (unlikely(!__pyx_tuple__44)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__44);
- __Pyx_GIVEREF(__pyx_tuple__44);
__pyx_tuple__45 = PyTuple_Pack(1, __pyx_n_s_complex128); if (unlikely(!__pyx_tuple__45)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__45);
__Pyx_GIVEREF(__pyx_tuple__45);
- __pyx_tuple__46 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__46)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__46 = PyTuple_Pack(1, __pyx_n_s_complex128); if (unlikely(!__pyx_tuple__46)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__46);
__Pyx_GIVEREF(__pyx_tuple__46);
+ __pyx_tuple__47 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__47)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__47);
+ __Pyx_GIVEREF(__pyx_tuple__47);
/* "pyfftw/pyfftw.pyx":447
* fftw_schemes = {
@@ -16627,15 +16783,15 @@ static int __Pyx_InitCachedConstants(void) {
* (np.dtype('float64'), np.dtype('complex128')): ('r2c', '64'),
* (np.dtype('float32'), np.dtype('complex64')): ('r2c', '32'),
*/
- __pyx_tuple__47 = PyTuple_Pack(1, __pyx_n_s_complex64); if (unlikely(!__pyx_tuple__47)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__47);
- __Pyx_GIVEREF(__pyx_tuple__47);
__pyx_tuple__48 = PyTuple_Pack(1, __pyx_n_s_complex64); if (unlikely(!__pyx_tuple__48)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__48);
__Pyx_GIVEREF(__pyx_tuple__48);
- __pyx_tuple__49 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__49)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__49 = PyTuple_Pack(1, __pyx_n_s_complex64); if (unlikely(!__pyx_tuple__49)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__49);
__Pyx_GIVEREF(__pyx_tuple__49);
+ __pyx_tuple__50 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__50)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__50);
+ __Pyx_GIVEREF(__pyx_tuple__50);
/* "pyfftw/pyfftw.pyx":448
* (np.dtype('complex128'), np.dtype('complex128')): ('c2c', '64'),
@@ -16644,15 +16800,15 @@ static int __Pyx_InitCachedConstants(void) {
* (np.dtype('float32'), np.dtype('complex64')): ('r2c', '32'),
* (np.dtype('complex128'), np.dtype('float64')): ('c2r', '64'),
*/
- __pyx_tuple__50 = PyTuple_Pack(1, __pyx_n_s_float64); if (unlikely(!__pyx_tuple__50)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__50);
- __Pyx_GIVEREF(__pyx_tuple__50);
- __pyx_tuple__51 = PyTuple_Pack(1, __pyx_n_s_complex128); if (unlikely(!__pyx_tuple__51)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__51 = PyTuple_Pack(1, __pyx_n_s_float64); if (unlikely(!__pyx_tuple__51)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__51);
__Pyx_GIVEREF(__pyx_tuple__51);
- __pyx_tuple__52 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__52)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__52 = PyTuple_Pack(1, __pyx_n_s_complex128); if (unlikely(!__pyx_tuple__52)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__52);
__Pyx_GIVEREF(__pyx_tuple__52);
+ __pyx_tuple__53 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__53)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__53);
+ __Pyx_GIVEREF(__pyx_tuple__53);
/* "pyfftw/pyfftw.pyx":449
* (np.dtype('complex64'), np.dtype('complex64')): ('c2c', '32'),
@@ -16661,15 +16817,15 @@ static int __Pyx_InitCachedConstants(void) {
* (np.dtype('complex128'), np.dtype('float64')): ('c2r', '64'),
* (np.dtype('complex64'), np.dtype('float32')): ('c2r', '32')}
*/
- __pyx_tuple__53 = PyTuple_Pack(1, __pyx_n_s_float32); if (unlikely(!__pyx_tuple__53)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__53);
- __Pyx_GIVEREF(__pyx_tuple__53);
- __pyx_tuple__54 = PyTuple_Pack(1, __pyx_n_s_complex64); if (unlikely(!__pyx_tuple__54)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__54 = PyTuple_Pack(1, __pyx_n_s_float32); if (unlikely(!__pyx_tuple__54)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__54);
__Pyx_GIVEREF(__pyx_tuple__54);
- __pyx_tuple__55 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__55)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__55 = PyTuple_Pack(1, __pyx_n_s_complex64); if (unlikely(!__pyx_tuple__55)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__55);
__Pyx_GIVEREF(__pyx_tuple__55);
+ __pyx_tuple__56 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__56)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__56);
+ __Pyx_GIVEREF(__pyx_tuple__56);
/* "pyfftw/pyfftw.pyx":450
* (np.dtype('float64'), np.dtype('complex128')): ('r2c', '64'),
@@ -16678,15 +16834,15 @@ static int __Pyx_InitCachedConstants(void) {
* (np.dtype('complex64'), np.dtype('float32')): ('c2r', '32')}
*
*/
- __pyx_tuple__56 = PyTuple_Pack(1, __pyx_n_s_complex128); if (unlikely(!__pyx_tuple__56)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__56);
- __Pyx_GIVEREF(__pyx_tuple__56);
- __pyx_tuple__57 = PyTuple_Pack(1, __pyx_n_s_float64); if (unlikely(!__pyx_tuple__57)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__57 = PyTuple_Pack(1, __pyx_n_s_complex128); if (unlikely(!__pyx_tuple__57)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__57);
__Pyx_GIVEREF(__pyx_tuple__57);
- __pyx_tuple__58 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__58)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__58 = PyTuple_Pack(1, __pyx_n_s_float64); if (unlikely(!__pyx_tuple__58)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__58);
__Pyx_GIVEREF(__pyx_tuple__58);
+ __pyx_tuple__59 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__59)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__59);
+ __Pyx_GIVEREF(__pyx_tuple__59);
/* "pyfftw/pyfftw.pyx":451
* (np.dtype('float32'), np.dtype('complex64')): ('r2c', '32'),
@@ -16695,15 +16851,15 @@ static int __Pyx_InitCachedConstants(void) {
*
* if np.dtype('longdouble') != np.dtype('float64'):
*/
- __pyx_tuple__59 = PyTuple_Pack(1, __pyx_n_s_complex64); if (unlikely(!__pyx_tuple__59)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__59);
- __Pyx_GIVEREF(__pyx_tuple__59);
- __pyx_tuple__60 = PyTuple_Pack(1, __pyx_n_s_float32); if (unlikely(!__pyx_tuple__60)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__60 = PyTuple_Pack(1, __pyx_n_s_complex64); if (unlikely(!__pyx_tuple__60)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__60);
__Pyx_GIVEREF(__pyx_tuple__60);
- __pyx_tuple__61 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__61)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__61 = PyTuple_Pack(1, __pyx_n_s_float32); if (unlikely(!__pyx_tuple__61)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__61);
__Pyx_GIVEREF(__pyx_tuple__61);
+ __pyx_tuple__62 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__62)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__62);
+ __Pyx_GIVEREF(__pyx_tuple__62);
/* "pyfftw/pyfftw.pyx":453
* (np.dtype('complex64'), np.dtype('float32')): ('c2r', '32')}
@@ -16712,12 +16868,12 @@ static int __Pyx_InitCachedConstants(void) {
* fftw_schemes.update({
* (np.dtype('clongdouble'), np.dtype('clongdouble')): ('c2c', 'ld'),
*/
- __pyx_tuple__62 = PyTuple_Pack(1, __pyx_n_s_longdouble); if (unlikely(!__pyx_tuple__62)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 453; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__62);
- __Pyx_GIVEREF(__pyx_tuple__62);
- __pyx_tuple__63 = PyTuple_Pack(1, __pyx_n_s_float64); if (unlikely(!__pyx_tuple__63)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 453; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__63 = PyTuple_Pack(1, __pyx_n_s_longdouble); if (unlikely(!__pyx_tuple__63)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 453; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__63);
__Pyx_GIVEREF(__pyx_tuple__63);
+ __pyx_tuple__64 = PyTuple_Pack(1, __pyx_n_s_float64); if (unlikely(!__pyx_tuple__64)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 453; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__64);
+ __Pyx_GIVEREF(__pyx_tuple__64);
/* "pyfftw/pyfftw.pyx":455
* if np.dtype('longdouble') != np.dtype('float64'):
@@ -16726,15 +16882,15 @@ static int __Pyx_InitCachedConstants(void) {
* (np.dtype('longdouble'), np.dtype('clongdouble')): ('r2c', 'ld'),
* (np.dtype('clongdouble'), np.dtype('longdouble')): ('c2r', 'ld')})
*/
- __pyx_tuple__64 = PyTuple_Pack(1, __pyx_n_s_clongdouble); if (unlikely(!__pyx_tuple__64)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__64);
- __Pyx_GIVEREF(__pyx_tuple__64);
__pyx_tuple__65 = PyTuple_Pack(1, __pyx_n_s_clongdouble); if (unlikely(!__pyx_tuple__65)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__65);
__Pyx_GIVEREF(__pyx_tuple__65);
- __pyx_tuple__66 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__66)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__66 = PyTuple_Pack(1, __pyx_n_s_clongdouble); if (unlikely(!__pyx_tuple__66)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__66);
__Pyx_GIVEREF(__pyx_tuple__66);
+ __pyx_tuple__67 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__67)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__67);
+ __Pyx_GIVEREF(__pyx_tuple__67);
/* "pyfftw/pyfftw.pyx":456
* fftw_schemes.update({
@@ -16743,15 +16899,15 @@ static int __Pyx_InitCachedConstants(void) {
* (np.dtype('clongdouble'), np.dtype('longdouble')): ('c2r', 'ld')})
*
*/
- __pyx_tuple__67 = PyTuple_Pack(1, __pyx_n_s_longdouble); if (unlikely(!__pyx_tuple__67)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__67);
- __Pyx_GIVEREF(__pyx_tuple__67);
- __pyx_tuple__68 = PyTuple_Pack(1, __pyx_n_s_clongdouble); if (unlikely(!__pyx_tuple__68)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__68 = PyTuple_Pack(1, __pyx_n_s_longdouble); if (unlikely(!__pyx_tuple__68)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__68);
__Pyx_GIVEREF(__pyx_tuple__68);
- __pyx_tuple__69 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__69)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__69 = PyTuple_Pack(1, __pyx_n_s_clongdouble); if (unlikely(!__pyx_tuple__69)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__69);
__Pyx_GIVEREF(__pyx_tuple__69);
+ __pyx_tuple__70 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__70)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__70);
+ __Pyx_GIVEREF(__pyx_tuple__70);
/* "pyfftw/pyfftw.pyx":457
* (np.dtype('clongdouble'), np.dtype('clongdouble')): ('c2c', 'ld'),
@@ -16760,15 +16916,15 @@ static int __Pyx_InitCachedConstants(void) {
*
*
*/
- __pyx_tuple__70 = PyTuple_Pack(1, __pyx_n_s_clongdouble); if (unlikely(!__pyx_tuple__70)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__70);
- __Pyx_GIVEREF(__pyx_tuple__70);
- __pyx_tuple__71 = PyTuple_Pack(1, __pyx_n_s_longdouble); if (unlikely(!__pyx_tuple__71)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__71 = PyTuple_Pack(1, __pyx_n_s_clongdouble); if (unlikely(!__pyx_tuple__71)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__71);
__Pyx_GIVEREF(__pyx_tuple__71);
- __pyx_tuple__72 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__72)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__72 = PyTuple_Pack(1, __pyx_n_s_longdouble); if (unlikely(!__pyx_tuple__72)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_tuple__72);
__Pyx_GIVEREF(__pyx_tuple__72);
+ __pyx_tuple__73 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__73)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__73);
+ __Pyx_GIVEREF(__pyx_tuple__73);
/* "pyfftw/pyfftw.pyx":462
* cdef object scheme_directions
@@ -16777,9 +16933,9 @@ static int __Pyx_InitCachedConstants(void) {
* ('c2c', '32'): ['FFTW_FORWARD', 'FFTW_BACKWARD'],
* ('c2c', 'ld'): ['FFTW_FORWARD', 'FFTW_BACKWARD'],
*/
- __pyx_tuple__73 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__73)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__73);
- __Pyx_GIVEREF(__pyx_tuple__73);
+ __pyx_tuple__74 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__74)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__74);
+ __Pyx_GIVEREF(__pyx_tuple__74);
/* "pyfftw/pyfftw.pyx":463
* scheme_directions = {
@@ -16788,9 +16944,9 @@ static int __Pyx_InitCachedConstants(void) {
* ('c2c', 'ld'): ['FFTW_FORWARD', 'FFTW_BACKWARD'],
* ('r2c', '64'): ['FFTW_FORWARD'],
*/
- __pyx_tuple__74 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__74)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__74);
- __Pyx_GIVEREF(__pyx_tuple__74);
+ __pyx_tuple__75 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__75)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__75);
+ __Pyx_GIVEREF(__pyx_tuple__75);
/* "pyfftw/pyfftw.pyx":464
* ('c2c', '64'): ['FFTW_FORWARD', 'FFTW_BACKWARD'],
@@ -16799,9 +16955,9 @@ static int __Pyx_InitCachedConstants(void) {
* ('r2c', '64'): ['FFTW_FORWARD'],
* ('r2c', '32'): ['FFTW_FORWARD'],
*/
- __pyx_tuple__75 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__75)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__75);
- __Pyx_GIVEREF(__pyx_tuple__75);
+ __pyx_tuple__76 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__76)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__76);
+ __Pyx_GIVEREF(__pyx_tuple__76);
/* "pyfftw/pyfftw.pyx":465
* ('c2c', '32'): ['FFTW_FORWARD', 'FFTW_BACKWARD'],
@@ -16810,9 +16966,9 @@ static int __Pyx_InitCachedConstants(void) {
* ('r2c', '32'): ['FFTW_FORWARD'],
* ('r2c', 'ld'): ['FFTW_FORWARD'],
*/
- __pyx_tuple__76 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__76)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__76);
- __Pyx_GIVEREF(__pyx_tuple__76);
+ __pyx_tuple__77 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__77)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__77);
+ __Pyx_GIVEREF(__pyx_tuple__77);
/* "pyfftw/pyfftw.pyx":466
* ('c2c', 'ld'): ['FFTW_FORWARD', 'FFTW_BACKWARD'],
@@ -16821,9 +16977,9 @@ static int __Pyx_InitCachedConstants(void) {
* ('r2c', 'ld'): ['FFTW_FORWARD'],
* ('c2r', '64'): ['FFTW_BACKWARD'],
*/
- __pyx_tuple__77 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__77)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__77);
- __Pyx_GIVEREF(__pyx_tuple__77);
+ __pyx_tuple__78 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__78)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__78);
+ __Pyx_GIVEREF(__pyx_tuple__78);
/* "pyfftw/pyfftw.pyx":467
* ('r2c', '64'): ['FFTW_FORWARD'],
@@ -16832,9 +16988,9 @@ static int __Pyx_InitCachedConstants(void) {
* ('c2r', '64'): ['FFTW_BACKWARD'],
* ('c2r', '32'): ['FFTW_BACKWARD'],
*/
- __pyx_tuple__78 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__78)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__78);
- __Pyx_GIVEREF(__pyx_tuple__78);
+ __pyx_tuple__79 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__79)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__79);
+ __Pyx_GIVEREF(__pyx_tuple__79);
/* "pyfftw/pyfftw.pyx":468
* ('r2c', '32'): ['FFTW_FORWARD'],
@@ -16843,9 +16999,9 @@ static int __Pyx_InitCachedConstants(void) {
* ('c2r', '32'): ['FFTW_BACKWARD'],
* ('c2r', 'ld'): ['FFTW_BACKWARD']}
*/
- __pyx_tuple__79 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__79)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 468; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__79);
- __Pyx_GIVEREF(__pyx_tuple__79);
+ __pyx_tuple__80 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__80)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 468; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__80);
+ __Pyx_GIVEREF(__pyx_tuple__80);
/* "pyfftw/pyfftw.pyx":469
* ('r2c', 'ld'): ['FFTW_FORWARD'],
@@ -16854,9 +17010,9 @@ static int __Pyx_InitCachedConstants(void) {
* ('c2r', 'ld'): ['FFTW_BACKWARD']}
*
*/
- __pyx_tuple__80 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__80)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 469; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__80);
- __Pyx_GIVEREF(__pyx_tuple__80);
+ __pyx_tuple__81 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__81)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 469; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__81);
+ __Pyx_GIVEREF(__pyx_tuple__81);
/* "pyfftw/pyfftw.pyx":470
* ('c2r', '64'): ['FFTW_BACKWARD'],
@@ -16865,9 +17021,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* # In the following, -1 denotes using the default. A segfault has been
*/
- __pyx_tuple__81 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__81)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 470; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__81);
- __Pyx_GIVEREF(__pyx_tuple__81);
+ __pyx_tuple__82 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__82)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 470; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__82);
+ __Pyx_GIVEREF(__pyx_tuple__82);
/* "pyfftw/pyfftw.pyx":478
* cdef object scheme_functions
@@ -16876,9 +17032,9 @@ static int __Pyx_InitCachedConstants(void) {
* 'validator': -1, 'fft_shape_lookup': -1},
* ('c2c', '32'): {'planner':1, 'executor':1, 'generic_precision':1,
*/
- __pyx_tuple__82 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__82)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__82);
- __Pyx_GIVEREF(__pyx_tuple__82);
+ __pyx_tuple__83 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__83)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__83);
+ __Pyx_GIVEREF(__pyx_tuple__83);
/* "pyfftw/pyfftw.pyx":480
* ('c2c', '64'): {'planner': 0, 'executor':0, 'generic_precision':0,
@@ -16887,9 +17043,9 @@ static int __Pyx_InitCachedConstants(void) {
* 'validator': -1, 'fft_shape_lookup': -1},
* ('c2c', 'ld'): {'planner':2, 'executor':2, 'generic_precision':2,
*/
- __pyx_tuple__83 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__83)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__83);
- __Pyx_GIVEREF(__pyx_tuple__83);
+ __pyx_tuple__84 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__84)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__84);
+ __Pyx_GIVEREF(__pyx_tuple__84);
/* "pyfftw/pyfftw.pyx":482
* ('c2c', '32'): {'planner':1, 'executor':1, 'generic_precision':1,
@@ -16898,9 +17054,9 @@ static int __Pyx_InitCachedConstants(void) {
* 'validator': -1, 'fft_shape_lookup': -1},
* ('r2c', '64'): {'planner':3, 'executor':3, 'generic_precision':0,
*/
- __pyx_tuple__84 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__84)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__84);
- __Pyx_GIVEREF(__pyx_tuple__84);
+ __pyx_tuple__85 = PyTuple_Pack(2, __pyx_n_s_c2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__85)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__85);
+ __Pyx_GIVEREF(__pyx_tuple__85);
/* "pyfftw/pyfftw.pyx":484
* ('c2c', 'ld'): {'planner':2, 'executor':2, 'generic_precision':2,
@@ -16909,9 +17065,9 @@ static int __Pyx_InitCachedConstants(void) {
* 'validator': 0,
* 'fft_shape_lookup': _lookup_shape_r2c_arrays},
*/
- __pyx_tuple__85 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__85)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__85);
- __Pyx_GIVEREF(__pyx_tuple__85);
+ __pyx_tuple__86 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__86)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__86);
+ __Pyx_GIVEREF(__pyx_tuple__86);
/* "pyfftw/pyfftw.pyx":487
* 'validator': 0,
@@ -16920,9 +17076,9 @@ static int __Pyx_InitCachedConstants(void) {
* 'validator': 0,
* 'fft_shape_lookup': _lookup_shape_r2c_arrays},
*/
- __pyx_tuple__86 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__86)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__86);
- __Pyx_GIVEREF(__pyx_tuple__86);
+ __pyx_tuple__87 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__87)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__87);
+ __Pyx_GIVEREF(__pyx_tuple__87);
/* "pyfftw/pyfftw.pyx":490
* 'validator': 0,
@@ -16931,9 +17087,9 @@ static int __Pyx_InitCachedConstants(void) {
* 'validator': 0,
* 'fft_shape_lookup': _lookup_shape_r2c_arrays},
*/
- __pyx_tuple__87 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__87)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 490; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__87);
- __Pyx_GIVEREF(__pyx_tuple__87);
+ __pyx_tuple__88 = PyTuple_Pack(2, __pyx_n_s_r2c, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__88)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 490; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__88);
+ __Pyx_GIVEREF(__pyx_tuple__88);
/* "pyfftw/pyfftw.pyx":493
* 'validator': 0,
@@ -16942,9 +17098,9 @@ static int __Pyx_InitCachedConstants(void) {
* 'validator': 1,
* 'fft_shape_lookup': _lookup_shape_c2r_arrays},
*/
- __pyx_tuple__88 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__88)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 493; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__88);
- __Pyx_GIVEREF(__pyx_tuple__88);
+ __pyx_tuple__89 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_64); if (unlikely(!__pyx_tuple__89)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 493; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__89);
+ __Pyx_GIVEREF(__pyx_tuple__89);
/* "pyfftw/pyfftw.pyx":496
* 'validator': 1,
@@ -16953,9 +17109,9 @@ static int __Pyx_InitCachedConstants(void) {
* 'validator': 1,
* 'fft_shape_lookup': _lookup_shape_c2r_arrays},
*/
- __pyx_tuple__89 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__89)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 496; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__89);
- __Pyx_GIVEREF(__pyx_tuple__89);
+ __pyx_tuple__90 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_kp_s_32); if (unlikely(!__pyx_tuple__90)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 496; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__90);
+ __Pyx_GIVEREF(__pyx_tuple__90);
/* "pyfftw/pyfftw.pyx":499
* 'validator': 1,
@@ -16964,42 +17120,42 @@ static int __Pyx_InitCachedConstants(void) {
* 'validator': 1,
* 'fft_shape_lookup': _lookup_shape_c2r_arrays}}
*/
- __pyx_tuple__90 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__90)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__90);
- __Pyx_GIVEREF(__pyx_tuple__90);
+ __pyx_tuple__91 = PyTuple_Pack(2, __pyx_n_s_c2r, __pyx_n_s_ld); if (unlikely(!__pyx_tuple__91)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__91);
+ __Pyx_GIVEREF(__pyx_tuple__91);
- /* "pyfftw/pyfftw.pyx":1614
+ /* "pyfftw/pyfftw.pyx":1634
*
*
* def export_wisdom(): # <<<<<<<<<<<<<<
* '''export_wisdom()
*
*/
- __pyx_tuple__91 = PyTuple_Pack(12, __pyx_n_s_py_wisdom, __pyx_n_s_py_wisdomf, __pyx_n_s_py_wisdoml, __pyx_n_s_counter, __pyx_n_s_counterf, __pyx_n_s_counterl, __pyx_n_s_c_wisdom, __pyx_n_s_c_wisdomf, __pyx_n_s_c_wisdoml, __pyx_n_s_c_wisdom_ptr, __pyx_n_s_c_wisdomf_ptr, __pyx_n_s_c_wisdoml_ptr); if (unlikely(!__pyx_tuple__91)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1614; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__91);
- __Pyx_GIVEREF(__pyx_tuple__91);
- __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(0, 0, 12, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__91, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_whg_Projects_github_pyFFTW, __pyx_n_s_export_wisdom, 1614, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1614; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__92 = PyTuple_Pack(12, __pyx_n_s_py_wisdom, __pyx_n_s_py_wisdomf, __pyx_n_s_py_wisdoml, __pyx_n_s_counter, __pyx_n_s_counterf, __pyx_n_s_counterl, __pyx_n_s_c_wisdom, __pyx_n_s_c_wisdomf, __pyx_n_s_c_wisdoml, __pyx_n_s_c_wisdom_ptr, __pyx_n_s_c_wisdomf_ptr, __pyx_n_s_c_wisdoml_ptr); if (unlikely(!__pyx_tuple__92)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1634; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__92);
+ __Pyx_GIVEREF(__pyx_tuple__92);
+ __pyx_codeobj__93 = (PyObject*)__Pyx_PyCode_New(0, 0, 12, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__92, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_whg_Projects_github_pyFFTW, __pyx_n_s_export_wisdom, 1634, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__93)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1634; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1673
+ /* "pyfftw/pyfftw.pyx":1693
* return (py_wisdom, py_wisdomf, py_wisdoml)
*
* def import_wisdom(wisdom): # <<<<<<<<<<<<<<
* '''import_wisdom(wisdom)
*
*/
- __pyx_tuple__93 = PyTuple_Pack(7, __pyx_n_s_wisdom, __pyx_n_s_c_wisdom, __pyx_n_s_c_wisdomf, __pyx_n_s_c_wisdoml, __pyx_n_s_success, __pyx_n_s_successf, __pyx_n_s_successl); if (unlikely(!__pyx_tuple__93)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__93);
- __Pyx_GIVEREF(__pyx_tuple__93);
- __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__93, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_whg_Projects_github_pyFFTW, __pyx_n_s_import_wisdom, 1673, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__94 = PyTuple_Pack(7, __pyx_n_s_wisdom, __pyx_n_s_c_wisdom, __pyx_n_s_c_wisdomf, __pyx_n_s_c_wisdoml, __pyx_n_s_success, __pyx_n_s_successf, __pyx_n_s_successl); if (unlikely(!__pyx_tuple__94)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1693; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_tuple__94);
+ __Pyx_GIVEREF(__pyx_tuple__94);
+ __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__94, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_whg_Projects_github_pyFFTW, __pyx_n_s_import_wisdom, 1693, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1693; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- /* "pyfftw/pyfftw.pyx":1789
+ /* "pyfftw/pyfftw.pyx":1809
* # return (success, successf, successl)
*
* def forget_wisdom(): # <<<<<<<<<<<<<<
* '''forget_wisdom()
*
*/
- __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_whg_Projects_github_pyFFTW, __pyx_n_s_forget_wisdom, 1789, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_codeobj__96 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_whg_Projects_github_pyFFTW, __pyx_n_s_forget_wisdom, 1809, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__96)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_RefNannyFinishContext();
return 0;
__pyx_L1_error:;
@@ -17260,7 +17416,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
*
* elif _simd_alignment == 32:
*/
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_valid_simd_alignments, __pyx_tuple__38) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_valid_simd_alignments, __pyx_tuple__39) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
/* "pyfftw/utils.pxi":50
*
@@ -17287,7 +17443,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
*
* else:
*/
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_valid_simd_alignments, __pyx_tuple__39) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_valid_simd_alignments, __pyx_tuple__40) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
/* "pyfftw/utils.pxi":53
* _valid_simd_alignments = (16,)
@@ -17558,9 +17714,9 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
*/
__pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
@@ -17570,7 +17726,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
__pyx_t_3 = 0;
__pyx_t_2 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_tuple__46) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_tuple__47) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "pyfftw/pyfftw.pyx":447
@@ -17580,9 +17736,9 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
* (np.dtype('float64'), np.dtype('complex128')): ('r2c', '64'),
* (np.dtype('float32'), np.dtype('complex64')): ('r2c', '32'),
*/
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
@@ -17592,7 +17748,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
__pyx_t_4 = 0;
__pyx_t_2 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_tuple__49) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_tuple__50) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":448
@@ -17602,9 +17758,9 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
* (np.dtype('float32'), np.dtype('complex64')): ('r2c', '32'),
* (np.dtype('complex128'), np.dtype('float64')): ('c2r', '64'),
*/
- __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
@@ -17614,7 +17770,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
__pyx_t_3 = 0;
__pyx_t_2 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_tuple__52) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_tuple__53) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "pyfftw/pyfftw.pyx":449
@@ -17624,9 +17780,9 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
* (np.dtype('complex128'), np.dtype('float64')): ('c2r', '64'),
* (np.dtype('complex64'), np.dtype('float32')): ('c2r', '32')}
*/
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
@@ -17636,7 +17792,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
__pyx_t_4 = 0;
__pyx_t_2 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_tuple__55) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_tuple__56) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":450
@@ -17646,9 +17802,9 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
* (np.dtype('complex64'), np.dtype('float32')): ('c2r', '32')}
*
*/
- __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
@@ -17658,7 +17814,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
__pyx_t_3 = 0;
__pyx_t_2 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_tuple__58) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_tuple__59) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "pyfftw/pyfftw.pyx":451
@@ -17668,9 +17824,9 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
*
* if np.dtype('longdouble') != np.dtype('float64'):
*/
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
@@ -17680,7 +17836,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
__pyx_t_4 = 0;
__pyx_t_2 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_tuple__61) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_tuple__62) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XGOTREF(__pyx_v_6pyfftw_6pyfftw_fftw_schemes);
__Pyx_DECREF_SET(__pyx_v_6pyfftw_6pyfftw_fftw_schemes, __pyx_t_1);
@@ -17694,9 +17850,9 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
* fftw_schemes.update({
* (np.dtype('clongdouble'), np.dtype('clongdouble')): ('c2c', 'ld'),
*/
- __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 453; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 453; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 453; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 453; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 453; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -17724,9 +17880,9 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
*/
__pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_7);
@@ -17736,7 +17892,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6);
__pyx_t_4 = 0;
__pyx_t_6 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_t_7, __pyx_tuple__66) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_t_7, __pyx_tuple__67) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "pyfftw/pyfftw.pyx":456
@@ -17746,9 +17902,9 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
* (np.dtype('clongdouble'), np.dtype('longdouble')): ('c2r', 'ld')})
*
*/
- __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__69, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
@@ -17758,7 +17914,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_6);
__pyx_t_7 = 0;
__pyx_t_6 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_tuple__69) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_tuple__70) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "pyfftw/pyfftw.pyx":457
@@ -17768,9 +17924,9 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
*
*
*/
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_7);
@@ -17780,7 +17936,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6);
__pyx_t_4 = 0;
__pyx_t_6 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_t_7, __pyx_tuple__72) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_t_7, __pyx_tuple__73) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -17836,7 +17992,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_INCREF(__pyx_n_s_FFTW_BACKWARD);
__Pyx_GIVEREF(__pyx_n_s_FFTW_BACKWARD);
PyList_SET_ITEM(__pyx_t_3, 1, __pyx_n_s_FFTW_BACKWARD);
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__73, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__74, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":463
@@ -17854,7 +18010,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_INCREF(__pyx_n_s_FFTW_BACKWARD);
__Pyx_GIVEREF(__pyx_n_s_FFTW_BACKWARD);
PyList_SET_ITEM(__pyx_t_3, 1, __pyx_n_s_FFTW_BACKWARD);
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__74, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__75, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":464
@@ -17872,7 +18028,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_INCREF(__pyx_n_s_FFTW_BACKWARD);
__Pyx_GIVEREF(__pyx_n_s_FFTW_BACKWARD);
PyList_SET_ITEM(__pyx_t_3, 1, __pyx_n_s_FFTW_BACKWARD);
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__75, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__76, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":465
@@ -17887,7 +18043,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_INCREF(__pyx_n_s_FFTW_FORWARD);
__Pyx_GIVEREF(__pyx_n_s_FFTW_FORWARD);
PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_FFTW_FORWARD);
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__76, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__77, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":466
@@ -17902,7 +18058,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_INCREF(__pyx_n_s_FFTW_FORWARD);
__Pyx_GIVEREF(__pyx_n_s_FFTW_FORWARD);
PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_FFTW_FORWARD);
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__77, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__78, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":467
@@ -17917,7 +18073,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_INCREF(__pyx_n_s_FFTW_FORWARD);
__Pyx_GIVEREF(__pyx_n_s_FFTW_FORWARD);
PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_FFTW_FORWARD);
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__78, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__79, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":468
@@ -17932,7 +18088,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_INCREF(__pyx_n_s_FFTW_BACKWARD);
__Pyx_GIVEREF(__pyx_n_s_FFTW_BACKWARD);
PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_FFTW_BACKWARD);
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__79, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__80, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":469
@@ -17947,7 +18103,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_INCREF(__pyx_n_s_FFTW_BACKWARD);
__Pyx_GIVEREF(__pyx_n_s_FFTW_BACKWARD);
PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_FFTW_BACKWARD);
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__80, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__81, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":470
@@ -17962,7 +18118,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_INCREF(__pyx_n_s_FFTW_BACKWARD);
__Pyx_GIVEREF(__pyx_n_s_FFTW_BACKWARD);
PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_FFTW_BACKWARD);
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__81, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__82, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XGOTREF(__pyx_v_6pyfftw_6pyfftw_scheme_directions);
__Pyx_DECREF_SET(__pyx_v_6pyfftw_6pyfftw_scheme_directions, __pyx_t_2);
@@ -17985,7 +18141,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_generic_precision, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_validator, __pyx_int_neg_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_fft_shape_lookup, __pyx_int_neg_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__82, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__83, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":480
@@ -18002,7 +18158,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_generic_precision, __pyx_int_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_validator, __pyx_int_neg_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_fft_shape_lookup, __pyx_int_neg_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__83, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__84, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":482
@@ -18019,7 +18175,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_generic_precision, __pyx_int_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_validator, __pyx_int_neg_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_fft_shape_lookup, __pyx_int_neg_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__84, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__85, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":484
@@ -18047,7 +18203,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_GOTREF(__pyx_t_6);
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_fft_shape_lookup, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__85, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__86, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":487
@@ -18075,7 +18231,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_GOTREF(__pyx_t_6);
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_fft_shape_lookup, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__86, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__87, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":490
@@ -18103,7 +18259,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_GOTREF(__pyx_t_6);
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_fft_shape_lookup, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 490; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__87, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__88, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":493
@@ -18131,7 +18287,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_GOTREF(__pyx_t_6);
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_fft_shape_lookup, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 493; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__88, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__89, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":496
@@ -18159,7 +18315,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_GOTREF(__pyx_t_6);
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_fft_shape_lookup, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 496; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__89, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__90, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "pyfftw/pyfftw.pyx":499
@@ -18187,7 +18343,7 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
__Pyx_GOTREF(__pyx_t_6);
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_fft_shape_lookup, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__90, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_tuple__91, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XGOTREF(__pyx_v_6pyfftw_6pyfftw_scheme_functions);
__Pyx_DECREF_SET(__pyx_v_6pyfftw_6pyfftw_scheme_functions, __pyx_t_2);
@@ -18284,355 +18440,355 @@ PyMODINIT_FUNC PyInit_pyfftw(void)
*/
Py_AtExit(__pyx_f_6pyfftw_6pyfftw__cleanup);
- /* "pyfftw/pyfftw.pyx":675
+ /* "pyfftw/pyfftw.pyx":676
* return self._N
*
* N = property(_get_N) # <<<<<<<<<<<<<<
*
* def _get_simd_aligned(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_N); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_N); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_N, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_N, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":684
+ /* "pyfftw/pyfftw.pyx":685
* return self._simd_allowed
*
* simd_aligned = property(_get_simd_aligned) # <<<<<<<<<<<<<<
*
* def _get_input_alignment(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_simd_aligned); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_simd_aligned); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_simd_aligned, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_simd_aligned, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":698
+ /* "pyfftw/pyfftw.pyx":699
* return self._input_array_alignment
*
* input_alignment = property(_get_input_alignment) # <<<<<<<<<<<<<<
*
* def _get_output_alignment(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_input_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_input_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 699; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 699; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 699; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_alignment, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_alignment, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 699; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":710
+ /* "pyfftw/pyfftw.pyx":711
* return self._output_array_alignment
*
* output_alignment = property(_get_output_alignment) # <<<<<<<<<<<<<<
*
* def _get_flags_used(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_output_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_output_alignment); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_alignment, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_alignment, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":720
+ /* "pyfftw/pyfftw.pyx":721
* return tuple(self._flags_used)
*
* flags = property(_get_flags_used) # <<<<<<<<<<<<<<
*
* def _get_input_array(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_flags_used); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_flags_used); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_flags, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_flags, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":729
+ /* "pyfftw/pyfftw.pyx":730
* return self._input_array
*
* input_array = property(_get_input_array) # <<<<<<<<<<<<<<
*
* def _get_output_array(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_input_array); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 729; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_input_array); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 730; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 729; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 730; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 729; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 730; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_array, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 729; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_array, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 730; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":738
+ /* "pyfftw/pyfftw.pyx":739
* return self._output_array
*
* output_array = property(_get_output_array) # <<<<<<<<<<<<<<
*
* def _get_input_strides(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_output_array); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_output_array); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 739; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 739; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 739; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_array, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_array, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 739; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":746
+ /* "pyfftw/pyfftw.pyx":747
* return self._input_strides
*
* input_strides = property(_get_input_strides) # <<<<<<<<<<<<<<
*
* def _get_output_strides(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_input_strides); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 746; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_input_strides); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 746; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 746; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_strides, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 746; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_strides, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":754
+ /* "pyfftw/pyfftw.pyx":755
* return self._output_strides
*
* output_strides = property(_get_output_strides) # <<<<<<<<<<<<<<
*
* def _get_input_shape(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_output_strides); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_output_strides); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_strides, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_strides, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":762
+ /* "pyfftw/pyfftw.pyx":763
* return self._input_shape
*
* input_shape = property(_get_input_shape) # <<<<<<<<<<<<<<
*
* def _get_output_shape(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_input_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 762; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_input_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 762; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 762; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_shape, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 762; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_shape, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":770
+ /* "pyfftw/pyfftw.pyx":771
* return self._output_shape
*
* output_shape = property(_get_output_shape) # <<<<<<<<<<<<<<
*
* def _get_input_dtype(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_output_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 770; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_output_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 770; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 770; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_shape, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 770; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_shape, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":778
+ /* "pyfftw/pyfftw.pyx":779
* return self._input_dtype
*
* input_dtype = property(_get_input_dtype) # <<<<<<<<<<<<<<
*
* def _get_output_dtype(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_input_dtype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_input_dtype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 779; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 779; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 779; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_dtype, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_dtype, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 779; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":786
+ /* "pyfftw/pyfftw.pyx":787
* return self._output_dtype
*
* output_dtype = property(_get_output_dtype) # <<<<<<<<<<<<<<
*
* def _get_direction(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_output_dtype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_output_dtype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_dtype, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_dtype, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":795
+ /* "pyfftw/pyfftw.pyx":796
* return directions_lookup[self._direction]
*
* direction = property(_get_direction) # <<<<<<<<<<<<<<
*
* def _get_axes(self):
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_direction); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_direction); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_direction, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_direction, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":809
+ /* "pyfftw/pyfftw.pyx":810
* return tuple(axes)
*
* axes = property(_get_axes) # <<<<<<<<<<<<<<
*
* def __cinit__(self, input_array, output_array, axes=(-1,),
*/
- __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_axes); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW, __pyx_n_s_get_axes); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_axes, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyfftw_6pyfftw_FFTW->tp_dict, __pyx_n_s_axes, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
PyType_Modified(__pyx_ptype_6pyfftw_6pyfftw_FFTW);
- /* "pyfftw/pyfftw.pyx":1614
+ /* "pyfftw/pyfftw.pyx":1634
*
*
* def export_wisdom(): # <<<<<<<<<<<<<<
* '''export_wisdom()
*
*/
- __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6pyfftw_6pyfftw_21export_wisdom, NULL, __pyx_n_s_pyfftw_pyfftw); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1614; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6pyfftw_6pyfftw_21export_wisdom, NULL, __pyx_n_s_pyfftw_pyfftw); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1634; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_export_wisdom, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1614; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_export_wisdom, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1634; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "pyfftw/pyfftw.pyx":1673
+ /* "pyfftw/pyfftw.pyx":1693
* return (py_wisdom, py_wisdomf, py_wisdoml)
*
* def import_wisdom(wisdom): # <<<<<<<<<<<<<<
* '''import_wisdom(wisdom)
*
*/
- __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6pyfftw_6pyfftw_23import_wisdom, NULL, __pyx_n_s_pyfftw_pyfftw); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6pyfftw_6pyfftw_23import_wisdom, NULL, __pyx_n_s_pyfftw_pyfftw); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1693; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_wisdom, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_wisdom, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1693; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "pyfftw/pyfftw.pyx":1789
+ /* "pyfftw/pyfftw.pyx":1809
* # return (success, successf, successl)
*
* def forget_wisdom(): # <<<<<<<<<<<<<<
* '''forget_wisdom()
*
*/
- __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6pyfftw_6pyfftw_25forget_wisdom, NULL, __pyx_n_s_pyfftw_pyfftw); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6pyfftw_6pyfftw_25forget_wisdom, NULL, __pyx_n_s_pyfftw_pyfftw); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_forget_wisdom, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_forget_wisdom, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "pyfftw/pyfftw.pyx":1
diff --git a/pyfftw/pyfftw.pxd b/pyfftw/pyfftw.pxd
index 0e80a76..03afd4f 100644
--- a/pyfftw/pyfftw.pxd
+++ b/pyfftw/pyfftw.pxd
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -41,13 +41,13 @@ ctypedef struct _fftw_iodim:
int _os
cdef extern from 'pyfftw_complex.h':
-
+
ctypedef float cfloat[2]
ctypedef double cdouble[2]
ctypedef long double clongdouble[2]
cdef extern from 'fftw3.h':
-
+
# Double precision plans
ctypedef struct fftw_plan_struct:
pass
@@ -73,14 +73,14 @@ cdef extern from 'fftw3.h':
# we ignore the distinction in order to simplify the code.
ctypedef struct fftw_iodim:
pass
-
+
# Double precision complex planner
fftw_plan fftw_plan_guru_dft(
int rank, fftw_iodim *dims,
int howmany_rank, fftw_iodim *howmany_dims,
cdouble *_in, cdouble *_out,
int sign, unsigned flags) nogil
-
+
# Single precision complex planner
fftwf_plan fftwf_plan_guru_dft(
int rank, fftw_iodim *dims,
@@ -94,14 +94,14 @@ cdef extern from 'fftw3.h':
int howmany_rank, fftw_iodim *howmany_dims,
clongdouble *_in, clongdouble *_out,
int sign, unsigned flags) nogil
-
+
# Double precision real to complex planner
fftw_plan fftw_plan_guru_dft_r2c(
int rank, fftw_iodim *dims,
int howmany_rank, fftw_iodim *howmany_dims,
double *_in, cdouble *_out,
unsigned flags) nogil
-
+
# Single precision real to complex planner
fftwf_plan fftwf_plan_guru_dft_r2c(
int rank, fftw_iodim *dims,
@@ -122,7 +122,7 @@ cdef extern from 'fftw3.h':
int howmany_rank, fftw_iodim *howmany_dims,
cdouble *_in, double *_out,
unsigned flags) nogil
-
+
# Single precision complex to real planner
fftwf_plan fftwf_plan_guru_dft_c2r(
int rank, fftw_iodim *dims,
@@ -140,36 +140,36 @@ cdef extern from 'fftw3.h':
# Double precision complex new array execute
void fftw_execute_dft(fftw_plan,
cdouble *_in, cdouble *_out) nogil
-
- # Single precision complex new array execute
+
+ # Single precision complex new array execute
void fftwf_execute_dft(fftwf_plan,
cfloat *_in, cfloat *_out) nogil
- # Long double precision complex new array execute
+ # Long double precision complex new array execute
void fftwl_execute_dft(fftwl_plan,
clongdouble *_in, clongdouble *_out) nogil
-
+
# Double precision real to complex new array execute
void fftw_execute_dft_r2c(fftw_plan,
double *_in, cdouble *_out) nogil
-
- # Single precision real to complex new array execute
+
+ # Single precision real to complex new array execute
void fftwf_execute_dft_r2c(fftwf_plan,
float *_in, cfloat *_out) nogil
- # Long double precision real to complex new array execute
+ # Long double precision real to complex new array execute
void fftwl_execute_dft_r2c(fftwl_plan,
long double *_in, clongdouble *_out) nogil
# Double precision complex to real new array execute
void fftw_execute_dft_c2r(fftw_plan,
cdouble *_in, double *_out) nogil
-
- # Single precision complex to real new array execute
+
+ # Single precision complex to real new array execute
void fftwf_execute_dft_c2r(fftwf_plan,
cfloat *_in, float *_out) nogil
- # Long double precision complex to real new array execute
+ # Long double precision complex to real new array execute
void fftwl_execute_dft_c2r(fftwl_plan,
clongdouble *_in, long double *_out) nogil
@@ -237,7 +237,7 @@ cdef extern from 'fftw3.h':
# Define function pointers that can act as a placeholder
# for whichever dtype is used (the problem being that fftw
-# has different function names and signatures for all the
+# has different function names and signatures for all the
# different precisions and dft types).
ctypedef void * (*fftw_generic_plan_guru)(
int rank, fftw_iodim *dims,
@@ -255,8 +255,8 @@ ctypedef void (*fftw_generic_plan_with_nthreads)(int n)
ctypedef void (*fftw_generic_set_timelimit)(double seconds)
-ctypedef bint (*validator)(np.ndarray input_array,
- np.ndarray output_array, int64_t *axes, int64_t *not_axes,
+ctypedef bint (*validator)(np.ndarray input_array,
+ np.ndarray output_array, int64_t *axes, int64_t *not_axes,
int64_t axes_length)
# Direction enum
diff --git a/pyfftw/pyfftw.pyx b/pyfftw/pyfftw.pyx
index 1fd38bd..f8fb729 100644
--- a/pyfftw/pyfftw.pyx
+++ b/pyfftw/pyfftw.pyx
@@ -1,5 +1,5 @@
# Copyright 2015 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -44,7 +44,7 @@ import threading
include 'utils.pxi'
cdef extern from *:
- int Py_AtExit(void (*callback)())
+ int Py_AtExit(void (*callback)())
cdef object directions
directions = {'FFTW_FORWARD': FFTW_FORWARD,
@@ -74,7 +74,7 @@ cdef object plan_lock = threading.Lock()
# All of these have the same signature as the fftw_generic functions
# defined in the .pxd file. The arguments and return values are
# cast as required in order to call the actual fftw functions.
-#
+#
# The wrapper function names are simply the fftw names prefixed
# with a single underscore.
@@ -195,55 +195,55 @@ cdef void* _fftwl_plan_guru_dft_c2r(
# Complex double precision
cdef void _fftw_execute_dft(void *_plan, void *_in, void *_out) nogil:
- fftw_execute_dft(<fftw_plan>_plan,
+ fftw_execute_dft(<fftw_plan>_plan,
<cdouble *>_in, <cdouble *>_out)
# Complex single precision
cdef void _fftwf_execute_dft(void *_plan, void *_in, void *_out) nogil:
- fftwf_execute_dft(<fftwf_plan>_plan,
+ fftwf_execute_dft(<fftwf_plan>_plan,
<cfloat *>_in, <cfloat *>_out)
# Complex long double precision
cdef void _fftwl_execute_dft(void *_plan, void *_in, void *_out) nogil:
- fftwl_execute_dft(<fftwl_plan>_plan,
+ fftwl_execute_dft(<fftwl_plan>_plan,
<clongdouble *>_in, <clongdouble *>_out)
# real to complex double precision
cdef void _fftw_execute_dft_r2c(void *_plan, void *_in, void *_out) nogil:
- fftw_execute_dft_r2c(<fftw_plan>_plan,
+ fftw_execute_dft_r2c(<fftw_plan>_plan,
<double *>_in, <cdouble *>_out)
# real to complex single precision
cdef void _fftwf_execute_dft_r2c(void *_plan, void *_in, void *_out) nogil:
- fftwf_execute_dft_r2c(<fftwf_plan>_plan,
+ fftwf_execute_dft_r2c(<fftwf_plan>_plan,
<float *>_in, <cfloat *>_out)
# real to complex long double precision
cdef void _fftwl_execute_dft_r2c(void *_plan, void *_in, void *_out) nogil:
- fftwl_execute_dft_r2c(<fftwl_plan>_plan,
+ fftwl_execute_dft_r2c(<fftwl_plan>_plan,
<long double *>_in, <clongdouble *>_out)
# complex to real double precision
cdef void _fftw_execute_dft_c2r(void *_plan, void *_in, void *_out) nogil:
- fftw_execute_dft_c2r(<fftw_plan>_plan,
+ fftw_execute_dft_c2r(<fftw_plan>_plan,
<cdouble *>_in, <double *>_out)
# complex to real single precision
cdef void _fftwf_execute_dft_c2r(void *_plan, void *_in, void *_out) nogil:
- fftwf_execute_dft_c2r(<fftwf_plan>_plan,
+ fftwf_execute_dft_c2r(<fftwf_plan>_plan,
<cfloat *>_in, <float *>_out)
# complex to real long double precision
cdef void _fftwl_execute_dft_c2r(void *_plan, void *_in, void *_out) nogil:
- fftwl_execute_dft_c2r(<fftwl_plan>_plan,
+ fftwl_execute_dft_c2r(<fftwl_plan>_plan,
<clongdouble *>_in, <long double *>_out)
# Destroyers
@@ -340,8 +340,8 @@ cdef validator * _build_validators_list():
# Validator functions
# ===================
-cdef bint _validate_r2c_arrays(np.ndarray input_array,
- np.ndarray output_array, int64_t *axes, int64_t *not_axes,
+cdef bint _validate_r2c_arrays(np.ndarray input_array,
+ np.ndarray output_array, int64_t *axes, int64_t *not_axes,
int64_t axes_length):
''' Validates the input and output array to check for
a valid real to complex transform.
@@ -357,8 +357,8 @@ cdef bint _validate_r2c_arrays(np.ndarray input_array,
for n in range(axes_length - 1):
if not out_shape[axes[n]] == in_shape[axes[n]]:
return False
-
- # The critical axis is the last of those over which the
+
+ # The critical axis is the last of those over which the
# FFT is taken.
if not (out_shape[axes[axes_length-1]]
== in_shape[axes[axes_length-1]]//2 + 1):
@@ -371,8 +371,8 @@ cdef bint _validate_r2c_arrays(np.ndarray input_array,
return True
-cdef bint _validate_c2r_arrays(np.ndarray input_array,
- np.ndarray output_array, int64_t *axes, int64_t *not_axes,
+cdef bint _validate_c2r_arrays(np.ndarray input_array,
+ np.ndarray output_array, int64_t *axes, int64_t *not_axes,
int64_t axes_length):
''' Validates the input and output array to check for
a valid complex to real transform.
@@ -389,10 +389,10 @@ cdef bint _validate_c2r_arrays(np.ndarray input_array,
for n in range(axes_length - 1):
if not in_shape[axes[n]] == out_shape[axes[n]]:
return False
-
- # The critical axis is the last of those over which the
+
+ # The critical axis is the last of those over which the
# FFT is taken.
- if not (in_shape[axes[axes_length-1]]
+ if not (in_shape[axes[axes_length-1]]
== out_shape[axes[axes_length-1]]//2 + 1):
return False
@@ -415,11 +415,11 @@ def _lookup_shape_c2r_arrays(input_array, output_array):
# which are a tuple of the string representation of numpy
# dtypes to a scheme name.
#
-# scheme_functions is a dictionary of functions, either
-# an index to the array of functions in the case of
+# scheme_functions is a dictionary of functions, either
+# an index to the array of functions in the case of
# 'planner', 'executor' and 'generic_precision' or a callable
# in the case of 'validator' (generic_precision is a catchall for
-# functions that only change based on the precision changing -
+# functions that only change based on the precision changing -
# i.e the prefix fftw, fftwl and fftwf is the only bit that changes).
#
# The array indices refer to the relevant functions for each scheme,
@@ -431,12 +431,12 @@ def _lookup_shape_c2r_arrays(input_array, output_array):
# and checks that the arrays are a valid pair. If it is set to None,
# then the default check is applied, which confirms that the arrays
# have the same shape.
-#
+#
# The 'fft_shape_lookup' function is a callable for returning the
-# FFT shape - that is, an array that describes the length of the
+# FFT shape - that is, an array that describes the length of the
# fft along each axis. It has the following signature:
-# fft_shape = fft_shape_lookup(in_array, out_array)
-# (note that this does not correspond to the lengths of the FFT that is
+# fft_shape = fft_shape_lookup(in_array, out_array)
+# (note that this does not correspond to the lengths of the FFT that is
# actually taken, it's the lengths of the FFT that *could* be taken
# along each axis. It's necessary because the real FFT has a length
# that is different to the length of the input array).
@@ -470,8 +470,8 @@ scheme_directions = {
('c2r', 'ld'): ['FFTW_BACKWARD']}
# In the following, -1 denotes using the default. A segfault has been
-# reported on some systems when this is set to None. It seems
-# sufficiently trivial to use -1 in place of None, especially given
+# reported on some systems when this is set to None. It seems
+# sufficiently trivial to use -1 in place of None, especially given
# that scheme_functions is an internal cdef object.
cdef object scheme_functions
scheme_functions = {
@@ -482,27 +482,27 @@ scheme_functions = {
('c2c', 'ld'): {'planner':2, 'executor':2, 'generic_precision':2,
'validator': -1, 'fft_shape_lookup': -1},
('r2c', '64'): {'planner':3, 'executor':3, 'generic_precision':0,
- 'validator': 0,
+ 'validator': 0,
'fft_shape_lookup': _lookup_shape_r2c_arrays},
('r2c', '32'): {'planner':4, 'executor':4, 'generic_precision':1,
- 'validator': 0,
+ 'validator': 0,
'fft_shape_lookup': _lookup_shape_r2c_arrays},
('r2c', 'ld'): {'planner':5, 'executor':5, 'generic_precision':2,
- 'validator': 0,
+ 'validator': 0,
'fft_shape_lookup': _lookup_shape_r2c_arrays},
- ('c2r', '64'): {'planner':6, 'executor':6, 'generic_precision':0,
- 'validator': 1,
+ ('c2r', '64'): {'planner':6, 'executor':6, 'generic_precision':0,
+ 'validator': 1,
'fft_shape_lookup': _lookup_shape_c2r_arrays},
- ('c2r', '32'): {'planner':7, 'executor':7, 'generic_precision':1,
- 'validator': 1,
+ ('c2r', '32'): {'planner':7, 'executor':7, 'generic_precision':1,
+ 'validator': 1,
'fft_shape_lookup': _lookup_shape_c2r_arrays},
('c2r', 'ld'): {'planner':8, 'executor':8, 'generic_precision':2,
- 'validator': 1,
+ 'validator': 1,
'fft_shape_lookup': _lookup_shape_c2r_arrays}}
# Initialize the module
-# Define the functions
+# Define the functions
_build_planner_list()
_build_destroyer_list()
_build_executor_list()
@@ -526,11 +526,11 @@ cdef void _cleanup():
Py_AtExit(_cleanup)
# Helper functions
-cdef void make_axes_unique(int64_t *axes, int64_t axes_length,
- int64_t **unique_axes, int64_t **not_axes, int64_t dimensions,
+cdef void make_axes_unique(int64_t *axes, int64_t axes_length,
+ int64_t **unique_axes, int64_t **not_axes, int64_t dimensions,
int64_t *unique_axes_length):
''' Takes an array of axes and makes that array unique, returning
- the unique array in unique_axes. It also creates and fills another
+ the unique array in unique_axes. It also creates and fills another
array, not_axes, with those axes that are not included in unique_axes.
unique_axes_length is updated with the length of unique_axes.
@@ -597,8 +597,8 @@ cdef void make_axes_unique(int64_t *axes, int64_t axes_length,
cdef class FFTW:
'''
FFTW is a class for computing the complex N-Dimensional DFT or
- inverse DFT of an array using the FFTW library. The interface is
- designed to be somewhat pythonic, with the correct transform being
+ inverse DFT of an array using the FFTW library. The interface is
+ designed to be somewhat pythonic, with the correct transform being
inferred from the dtypes of the passed arrays.
On instantiation, the dtypes and relative shapes of the input array and
@@ -607,10 +607,10 @@ cdef class FFTW:
corresponds to that scheme is created, operating on the arrays that are
passed in. If no scheme can be created, then ``ValueError`` is raised.
- The actual FFT or iFFT is performed by calling the
+ The actual FFT or iFFT is performed by calling the
:meth:`~pyfftw.FFTW.execute` method.
-
- The arrays can be updated by calling the
+
+ The arrays can be updated by calling the
:meth:`~pyfftw.FFTW.update_arrays` method.
The created instance of the class is itself callable, and can perform
@@ -618,9 +618,9 @@ cdef class FFTW:
the result of the FFT. Unlike calling the :meth:`~pyfftw.FFTW.execute`
method, calling the class instance will also optionally normalise the
output as necessary. Additionally, calling with an input array update
- will also coerce that array to be the correct dtype.
-
- See the documentation on the :meth:`~pyfftw.FFTW.__call__` method
+ will also coerce that array to be the correct dtype.
+
+ See the documentation on the :meth:`~pyfftw.FFTW.__call__` method
for more information.
'''
# Each of these function pointers simply
@@ -641,7 +641,7 @@ cdef class FFTW:
cdef bint _simd_allowed
cdef int _input_array_alignment
- cdef int _output_array_alignment
+ cdef int _output_array_alignment
cdef object _input_item_strides
cdef object _input_strides
@@ -654,6 +654,7 @@ cdef class FFTW:
cdef object _flags_used
cdef double _normalisation_scaling
+ cdef double _sqrt_normalisation_scaling
cdef int _rank
cdef _fftw_iodim *_dims
@@ -667,7 +668,7 @@ cdef class FFTW:
def _get_N(self):
'''
The product of the lengths of the DFT over all DFT axes.
- 1/N is the normalisation constant. For any input array A,
+ 1/N is the normalisation constant. For any input array A,
and for any set of axes, 1/N * ifft(fft(A)) = A
'''
return self._N
@@ -690,7 +691,7 @@ cdef class FFTW:
Input array updates with arrays that are not aligned on this
byte boundary will result in a ValueError being raised, or
- a copy being made if the :meth:`~pyfftw.FFTW.__call__`
+ a copy being made if the :meth:`~pyfftw.FFTW.__call__`
interface is used.
'''
return self._input_array_alignment
@@ -712,7 +713,7 @@ cdef class FFTW:
def _get_flags_used(self):
'''
Return which flags were used to construct the FFTW object.
-
+
This includes flags that were added during initialisation.
'''
return tuple(self._flags_used)
@@ -721,7 +722,7 @@ cdef class FFTW:
def _get_input_array(self):
'''
- Return the input array that is associated with the FFTW
+ Return the input array that is associated with the FFTW
instance.
'''
return self._input_array
@@ -730,7 +731,7 @@ cdef class FFTW:
def _get_output_array(self):
'''
- Return the output array that is associated with the FFTW
+ Return the output array that is associated with the FFTW
instance.
'''
return self._output_array
@@ -742,7 +743,7 @@ cdef class FFTW:
Return the strides of the input array for which the FFT is planned.
'''
return self._input_strides
-
+
input_strides = property(_get_input_strides)
def _get_output_strides(self):
@@ -750,7 +751,7 @@ cdef class FFTW:
Return the strides of the output array for which the FFT is planned.
'''
return self._output_strides
-
+
output_strides = property(_get_output_strides)
def _get_input_shape(self):
@@ -758,7 +759,7 @@ cdef class FFTW:
Return the shape of the input array for which the FFT is planned.
'''
return self._input_shape
-
+
input_shape = property(_get_input_shape)
def _get_output_shape(self):
@@ -766,7 +767,7 @@ cdef class FFTW:
Return the shape of the output array for which the FFT is planned.
'''
return self._output_shape
-
+
output_shape = property(_get_output_shape)
def _get_input_dtype(self):
@@ -774,7 +775,7 @@ cdef class FFTW:
Return the dtype of the input array for which the FFT is planned.
'''
return self._input_dtype
-
+
input_dtype = property(_get_input_dtype)
def _get_output_dtype(self):
@@ -782,16 +783,16 @@ cdef class FFTW:
Return the shape of the output array for which the FFT is planned.
'''
return self._output_dtype
-
+
output_dtype = property(_get_output_dtype)
def _get_direction(self):
'''
- Return the planned FFT direction. Either `'FFTW_FORWARD'` or
+ Return the planned FFT direction. Either `'FFTW_FORWARD'` or
`'FFTW_BACKWARD'`.
'''
return directions_lookup[self._direction]
-
+
direction = property(_get_direction)
def _get_axes(self):
@@ -805,14 +806,14 @@ cdef class FFTW:
axes.append(self._axes[i])
return tuple(axes)
-
+
axes = property(_get_axes)
def __cinit__(self, input_array, output_array, axes=(-1,),
- direction='FFTW_FORWARD', flags=('FFTW_MEASURE',),
+ direction='FFTW_FORWARD', flags=('FFTW_MEASURE',),
unsigned int threads=1, planning_timelimit=None,
*args, **kwargs):
-
+
# Initialise the pointers that need to be freed
self._plan = NULL
self._dims = NULL
@@ -854,9 +855,9 @@ cdef class FFTW:
self._input_dtype = input_dtype
self._output_dtype = output_dtype
-
+
functions = scheme_functions[scheme]
-
+
self._fftw_planner = planners[functions['planner']]
self._fftw_execute = executors[functions['executor']]
self._fftw_destroy = destroyers[functions['generic_precision']]
@@ -888,9 +889,9 @@ cdef class FFTW:
self._output_array_alignment = -1
for each_alignment in _valid_simd_alignments:
- if (<intptr_t>np.PyArray_DATA(input_array) %
+ if (<intptr_t>np.PyArray_DATA(input_array) %
each_alignment == 0 and
- <intptr_t>np.PyArray_DATA(output_array) %
+ <intptr_t>np.PyArray_DATA(output_array) %
each_alignment == 0):
self._simd_allowed = True
@@ -931,7 +932,7 @@ cdef class FFTW:
self._direction = directions[direction]
self._input_shape = input_array.shape
self._output_shape = output_array.shape
-
+
self._input_array = input_array
self._output_array = output_array
@@ -954,7 +955,7 @@ cdef class FFTW:
cdef int64_t unique_axes_length
cdef int64_t *unique_axes
cdef int64_t *not_axes
-
+
make_axes_unique(self._axes, len(axes), &unique_axes,
¬_axes, array_dimension, &unique_axes_length)
@@ -977,6 +978,7 @@ cdef class FFTW:
self._N = total_N
self._normalisation_scaling = 1/float(self.N)
+ self._sqrt_normalisation_scaling = np.sqrt(self._normalisation_scaling)
# Now we can validate the array shapes
cdef validator _validator
@@ -988,7 +990,7 @@ cdef class FFTW:
'input array for the given array dtypes.')
else:
_validator = validators[functions['validator']]
- if not _validator(input_array, output_array,
+ if not _validator(input_array, output_array,
self._axes, self._not_axes, unique_axes_length):
raise ValueError('Invalid shapes: '
'The input array and output array are invalid '
@@ -996,7 +998,7 @@ cdef class FFTW:
self._rank = unique_axes_length
self._howmany_rank = self._input_array.ndim - unique_axes_length
-
+
self._flags = 0
self._flags_used = []
for each_flag in flags:
@@ -1004,17 +1006,17 @@ cdef class FFTW:
self._flags |= flag_dict[each_flag]
self._flags_used.append(each_flag)
except KeyError:
- raise ValueError('Invalid flag: ' + '\'' +
+ raise ValueError('Invalid flag: ' + '\'' +
each_flag + '\' is not a valid planner flag.')
-
+
if ('FFTW_DESTROY_INPUT' not in flags) and (
(scheme[0] != 'c2r') or not self._rank > 1):
# The default in all possible cases is to preserve the input
# This is not possible for r2c arrays with rank > 1
self._flags |= FFTW_PRESERVE_INPUT
- # Set up the arrays of structs for holding the stride shape
+ # Set up the arrays of structs for holding the stride shape
# information
self._dims = <_fftw_iodim *>malloc(
self._rank * sizeof(_fftw_iodim))
@@ -1025,17 +1027,17 @@ cdef class FFTW:
# Not much else to do than raise an exception
raise MemoryError
- # Find the strides for all the axes of both arrays in terms of the
+ # Find the strides for all the axes of both arrays in terms of the
# number of items (as opposed to the number of bytes).
- self._input_strides = input_array.strides
- self._input_item_strides = tuple([stride/input_array.itemsize
+ self._input_strides = input_array.strides
+ self._input_item_strides = tuple([stride/input_array.itemsize
for stride in input_array.strides])
self._output_strides = output_array.strides
- self._output_item_strides = tuple([stride/output_array.itemsize
+ self._output_item_strides = tuple([stride/output_array.itemsize
for stride in output_array.strides])
# Make sure that the arrays are not too big for fftw
- # This is hard to test, so we cross our fingers and hope for the
+ # This is hard to test, so we cross our fingers and hope for the
# best (any suggestions, please get in touch).
cdef int i
for i in range(0, len(self._input_shape)):
@@ -1085,7 +1087,7 @@ cdef class FFTW:
# Finally, construct the plan, after acquiring the global planner lock
# (so that only one python thread can plan at a time, as the FFTW
# planning functions are not thread-safe)
-
+
# no self-lookups allowed in nogil block, so must grab all these first
cdef void *plan
cdef fftw_generic_plan_guru fftw_planner = self._fftw_planner
@@ -1102,7 +1104,7 @@ cdef class FFTW:
plan = fftw_planner(rank, dims, howmany_rank, howmany_dims,
_in, _out, sign, c_flags)
self._plan = plan
-
+
if self._plan == NULL:
if 'FFTW_WISDOM_ONLY' in flags:
raise RuntimeError('No FFTW wisdom is known for this plan.')
@@ -1110,63 +1112,63 @@ cdef class FFTW:
raise RuntimeError('The data has an uncaught error that led '+
'to the planner returning NULL. This is a bug.')
- def __init__(self, input_array, output_array, axes=(-1,),
- direction='FFTW_FORWARD', flags=('FFTW_MEASURE',),
+ def __init__(self, input_array, output_array, axes=(-1,),
+ direction='FFTW_FORWARD', flags=('FFTW_MEASURE',),
int threads=1, planning_timelimit=None):
'''
**Arguments**:
* ``input_array`` and ``output_array`` should be numpy arrays.
- The contents of these arrays will be destroyed by the planning
- process during initialisation. Information on supported
+ The contents of these arrays will be destroyed by the planning
+ process during initialisation. Information on supported
dtypes for the arrays is :ref:`given below <scheme_table>`.
-
+
* ``axes`` describes along which axes the DFT should be taken.
- This should be a valid list of axes. Repeated axes are
- only transformed once. Invalid axes will raise an ``IndexError``
+ This should be a valid list of axes. Repeated axes are
+ only transformed once. Invalid axes will raise an ``IndexError``
exception. This argument is equivalent to the same
argument in :func:`numpy.fft.fftn`, except for the fact that
the behaviour of repeated axes is different (``numpy.fft``
will happily take the fft of the same axis if it is repeated
in the ``axes`` argument). Rudimentary testing has suggested
- this is down to the underlying FFTW library and so unlikely
+ this is down to the underlying FFTW library and so unlikely
to be fixed in these wrappers.
- * ``direction`` should be a string and one of ``'FFTW_FORWARD'``
+ * ``direction`` should be a string and one of ``'FFTW_FORWARD'``
or ``'FFTW_BACKWARD'``, which dictate whether to take the
- DFT (forwards) or the inverse DFT (backwards) respectively
- (specifically, it dictates the sign of the exponent in the
+ DFT (forwards) or the inverse DFT (backwards) respectively
+ (specifically, it dictates the sign of the exponent in the
DFT formulation).
Note that only the Complex schemes allow a free choice
- for ``direction``. The direction *must* agree with the
- the :ref:`table below <scheme_table>` if a Real scheme
+ for ``direction``. The direction *must* agree with the
+ the :ref:`table below <scheme_table>` if a Real scheme
is used, otherwise a ``ValueError`` is raised.
.. _FFTW_flags:
- * ``flags`` is a list of strings and is a subset of the
+ * ``flags`` is a list of strings and is a subset of the
flags that FFTW allows for the planners:
- * ``'FFTW_ESTIMATE'``, ``'FFTW_MEASURE'``, ``'FFTW_PATIENT'`` and
- ``'FFTW_EXHAUSTIVE'`` are supported. These describe the
- increasing amount of effort spent during the planning
- stage to create the fastest possible transform.
+ * ``'FFTW_ESTIMATE'``, ``'FFTW_MEASURE'``, ``'FFTW_PATIENT'`` and
+ ``'FFTW_EXHAUSTIVE'`` are supported. These describe the
+ increasing amount of effort spent during the planning
+ stage to create the fastest possible transform.
Usually ``'FFTW_MEASURE'`` is a good compromise. If no flag
is passed, the default ``'FFTW_MEASURE'`` is used.
- * ``'FFTW_UNALIGNED'`` is supported.
- This tells FFTW not to assume anything about the
- alignment of the data and disabling any SIMD capability
+ * ``'FFTW_UNALIGNED'`` is supported.
+ This tells FFTW not to assume anything about the
+ alignment of the data and disabling any SIMD capability
(see below).
* ``'FFTW_DESTROY_INPUT'`` is supported.
This tells FFTW that the input array can be destroyed during
the transform, sometimes allowing a faster algorithm to be
used. The default behaviour is, if possible, to preserve the
- input. In the case of the 1D Backwards Real transform, this
+ input. In the case of the 1D Backwards Real transform, this
may result in a performance hit. In the case of a backwards
real transform for greater than one dimension, it is not
possible to preserve the input, making this flag implicit
- in that case. A little more on this is given
+ in that case. A little more on this is given
:ref:`below<scheme_table>`.
* ``'FFTW_WISDOM_ONLY'`` is supported.
This tells FFTW to raise an error if no plan for this transform
@@ -1175,18 +1177,18 @@ cdef class FFTW:
cached wisdom can be used. This flag should be combined with the
various planning-effort flags (``'FFTW_ESTIMATE'``,
``'FFTW_MEASURE'``, etc.); if so, then an error will be raised if
- wisdom derived from that level of planning effort (or higher) is
+ wisdom derived from that level of planning effort (or higher) is
not present. If no planning-effort flag is used, the default of
``'FFTW_ESTIMATE'`` is assumed.
Note that wisdom is specific to all the parameters, including the
data alignment. That is, if wisdom was generated with input/output
arrays with one specific alignment, using ``'FFTW_WISDOM_ONLY'``
- to create a plan for arrays with any different alignment will
+ to create a plan for arrays with any different alignment will
cause the ``'FFTW_WISDOM_ONLY'`` planning to fail. Thus it is
important to specifically control the data alignment to make the
best use of ``'FFTW_WISDOM_ONLY'``.
- The `FFTW planner flags documentation
+ The `FFTW planner flags documentation
<http://www.fftw.org/fftw3_doc/Planner-Flags.html#Planner-Flags>`_
has more information about the various flags and their impact.
Note that only the flags documented here are supported.
@@ -1194,7 +1196,7 @@ cdef class FFTW:
* ``threads`` tells the wrapper how many threads to use
when invoking FFTW, with a default of 1.
- * ``planning_timelimit`` is a floating point number that
+ * ``planning_timelimit`` is a floating point number that
indicates to the underlying FFTW planner the maximum number of
seconds it should spend planning the FFT. This is a rough
estimate and corresponds to calling of ``fftw_set_timelimit()``
@@ -1243,7 +1245,7 @@ cdef class FFTW:
of the transform is 1, the default is to preserve the input array.
This is different from the default in the underlying library, and
some speed gain may be achieved by allowing the input array to
- be destroyed by passing the ``'FFTW_DESTROY_INPUT'``
+ be destroyed by passing the ``'FFTW_DESTROY_INPUT'``
:ref:`flag <FFTW_flags>`.
``clongdouble`` typically maps directly to ``complex256``
@@ -1253,21 +1255,21 @@ cdef class FFTW:
The relative shapes of the arrays should be as follows:
* For a Complex transform, ``output_array.shape == input_array.shape``
- * For a Real transform in the Forwards direction, both the following
+ * For a Real transform in the Forwards direction, both the following
should be true:
* ``output_array.shape[axes][-1] == input_array.shape[axes][-1]//2 + 1``
* All the other axes should be equal in length.
- * For a Real transform in the Backwards direction, both the following
+ * For a Real transform in the Backwards direction, both the following
should be true:
* ``input_array.shape[axes][-1] == output_array.shape[axes][-1]//2 + 1``
* All the other axes should be equal in length.
- In the above expressions for the Real transform, the ``axes``
+ In the above expressions for the Real transform, the ``axes``
arguments denotes the unique set of axes on which we are taking
- the FFT, in the order passed. It is the last of these axes that
+ the FFT, in the order passed. It is the last of these axes that
is subject to the special case shown.
The shapes for the real transforms corresponds to those
@@ -1280,11 +1282,11 @@ cdef class FFTW:
or the output. The user should not have to worry about this
and any valid numpy array should work just fine.
- What is calculated is exactly what FFTW calculates.
- Notably, this is an unnormalized transform so should
- be scaled as necessary (fft followed by ifft will scale
+ What is calculated is exactly what FFTW calculates.
+ Notably, this is an unnormalized transform so should
+ be scaled as necessary (fft followed by ifft will scale
the input by N, the product of the dimensions along which
- the DFT is taken). For further information, see the
+ the DFT is taken). For further information, see the
`FFTW documentation
<http://www.fftw.org/fftw3_doc/What-FFTW-Really-Computes.html>`_.
@@ -1336,56 +1338,68 @@ cdef class FFTW:
if not self._howmany_dims == NULL:
free(self._howmany_dims)
- def __call__(self, input_array=None, output_array=None,
- normalise_idft=True):
- '''__call__(input_array=None, output_array=None, normalise_idft=True)
+ def __call__(self, input_array=None, output_array=None,
+ normalise_idft=True, ortho=False):
+ '''__call__(input_array=None, output_array=None, normalise_idft=True,
+ ortho=False)
Calling the class instance (optionally) updates the arrays, then
- calls :meth:`~pyfftw.FFTW.execute`, before optionally normalising
+ calls :meth:`~pyfftw.FFTW.execute`, before optionally normalising
the output and returning the output array.
It has some built-in helpers to make life simpler for the calling
functions (as distinct from manually updating the arrays and
calling :meth:`~pyfftw.FFTW.execute`).
- If ``normalise_idft`` is ``True`` (the default), then the output from
+ If ``normalise_idft`` is ``True`` (the default), then the output from
an inverse DFT (i.e. when the direction flag is ``'FFTW_BACKWARD'``) is
scaled by 1/N, where N is the product of the lengths of input array on
which the FFT is taken. If the direction is ``'FFTW_FORWARD'``, this
flag makes no difference to the output array.
-
+
+ If ``ortho`` is ``True``, then the output of both forward
+ and inverse DFT operations is scaled by 1/sqrt(N), where N is the
+ product of the lengths of input array on which the FFT is taken. This
+ ensures that the DFT is a unitary operation, meaning that it satisfies
+ Parseval's theorem (the sum of the squared values of the transform
+ output is equal to the sum of the squared values of the input). In
+ other words, the energy of the signal is preserved.
+
+ If either ``normalise_idft`` or ``ortho`` are ``True``, then
+ ifft(fft(A)) = A.
+
When ``input_array`` is something other than None, then the passed in
array is coerced to be the same dtype as the input array used when the
class was instantiated, the byte-alignment of the passed in array is
- made consistent with the expected byte-alignment and the striding is
- made consistent with the expected striding. All this may, but not
+ made consistent with the expected byte-alignment and the striding is
+ made consistent with the expected striding. All this may, but not
necessarily, require a copy to be made.
- As noted in the :ref:`scheme table<scheme_table>`, if the FFTW
+ As noted in the :ref:`scheme table<scheme_table>`, if the FFTW
instance describes a backwards real transform of more than one
dimension, the contents of the input array will be destroyed. It is
up to the calling function to make a copy if it is necessary to
maintain the input array.
- ``output_array`` is always used as-is if possible. If the dtype, the
+ ``output_array`` is always used as-is if possible. If the dtype, the
alignment or the striding is incorrect for the FFTW object, then a
``ValueError`` is raised.
-
- The coerced input array and the output array (as appropriate) are
+
+ The coerced input array and the output array (as appropriate) are
then passed as arguments to
:meth:`~pyfftw.FFTW.update_arrays`, after which
:meth:`~pyfftw.FFTW.execute` is called, and then normalisation
is applied to the output array if that is desired.
-
+
Note that it is possible to pass some data structure that can be
converted to an array, such as a list, so long as it fits the data
requirements of the class instance, such as array shape.
- Other than the dtype and the alignment of the passed in arrays, the
+ Other than the dtype and the alignment of the passed in arrays, the
rest of the requirements on the arrays mandated by
:meth:`~pyfftw.FFTW.update_arrays` are enforced.
- A ``None`` argument to either keyword means that that array is not
+ A ``None`` argument to either keyword means that that array is not
updated.
The result of the FFT is returned. This is the same array that is used
@@ -1394,6 +1408,10 @@ cdef class FFTW:
copy the returned array.
'''
+ if ortho and normalise_idft:
+ raise ValueError('Invalid options: ortho and normalise_idft cannot'
+ ' both be True.')
+
if input_array is not None or output_array is not None:
if input_array is None:
@@ -1408,7 +1426,7 @@ cdef class FFTW:
copy_needed = True
elif (not input_array.strides == self._input_strides):
copy_needed = True
- elif not (<intptr_t>np.PyArray_DATA(input_array)
+ elif not (<intptr_t>np.PyArray_DATA(input_array)
% self.input_alignment == 0):
copy_needed = True
else:
@@ -1424,9 +1442,9 @@ cdef class FFTW:
'The new input array should be the same shape '
'as the input array used to instantiate the '
'object.')
-
+
self._input_array[:] = input_array
-
+
if output_array is not None:
# No point wasting time if no update is necessary
# (which the copy above may have avoided)
@@ -1438,12 +1456,14 @@ cdef class FFTW:
self.execute()
- if self._direction == FFTW_BACKWARD and normalise_idft:
+ if ortho == True:
+ self._output_array *= self._sqrt_normalisation_scaling
+ elif self._direction == FFTW_BACKWARD and normalise_idft:
self._output_array *= self._normalisation_scaling
return self._output_array
- cpdef update_arrays(self,
+ cpdef update_arrays(self,
new_input_array, new_output_array):
'''update_arrays(new_input_array, new_output_array)
@@ -1455,7 +1475,7 @@ cdef class FFTW:
(e.g. by being aligned on a 16-byte boundary), then the new array must
also be aligned so as to allow SIMD instructions (assuming, of
course, that the ``FFTW_UNALIGNED`` flag was not enabled).
-
+
The byte alignment requirement extends to requiring natural
alignment in the non-SIMD cases as well, but this is much less
stringent as it simply means avoiding arrays shifted by, say,
@@ -1463,7 +1483,7 @@ cdef class FFTW:
achieve!).
If all these conditions are not met, a ``ValueError`` will
- be raised and the data will *not* be updated (though the
+ be raised and the data will *not* be updated (though the
object will still be in a sane state).
'''
if not isinstance(new_input_array, np.ndarray):
@@ -1476,14 +1496,14 @@ cdef class FFTW:
'The new output array needs to be an instance '
'of numpy.ndarray')
- if not (<intptr_t>np.PyArray_DATA(new_input_array) %
+ if not (<intptr_t>np.PyArray_DATA(new_input_array) %
self.input_alignment == 0):
raise ValueError('Invalid input alignment: '
'The original arrays were %d-byte aligned. It is '
'necessary that the update input array is similarly '
'aligned.' % self.input_alignment)
- if not (<intptr_t>np.PyArray_DATA(new_output_array) %
+ if not (<intptr_t>np.PyArray_DATA(new_output_array) %
self.output_alignment == 0):
raise ValueError('Invalid output alignment: '
'The original arrays were %d-byte aligned. It is '
@@ -1515,12 +1535,12 @@ cdef class FFTW:
raise ValueError('Invalid output shape: '
'The new output array should be the same shape as '
'the output array used to instantiate the object.')
-
+
if not new_input_strides == self._input_strides:
raise ValueError('Invalid input striding: '
'The strides should be identical for the new '
'input array as for the old.')
-
+
if not new_output_strides == self._output_strides:
raise ValueError('Invalid output striding: '
'The strides should be identical for the new '
@@ -1528,7 +1548,7 @@ cdef class FFTW:
self._update_arrays(new_input_array, new_output_array)
- cdef _update_arrays(self,
+ cdef _update_arrays(self,
np.ndarray new_input_array, np.ndarray new_output_array):
''' A C interface to the update_arrays method that does not
perform any checks on strides being correct and so on.
@@ -1539,14 +1559,14 @@ cdef class FFTW:
def get_input_array(self):
'''get_input_array()
- Return the input array that is associated with the FFTW
+ Return the input array that is associated with the FFTW
instance.
- *Deprecated since 0.10. Consider using the* :attr:`FFTW.input_array`
+ *Deprecated since 0.10. Consider using the* :attr:`FFTW.input_array`
*property instead.*
'''
warnings.warn('get_input_array is deprecated. '
- 'Consider using the input_array property instead.',
+ 'Consider using the input_array property instead.',
DeprecationWarning)
return self._input_array
@@ -1557,20 +1577,20 @@ cdef class FFTW:
Return the output array that is associated with the FFTW
instance.
- *Deprecated since 0.10. Consider using the* :attr:`FFTW.output_array`
+ *Deprecated since 0.10. Consider using the* :attr:`FFTW.output_array`
*property instead.*
'''
warnings.warn('get_output_array is deprecated. '
- 'Consider using the output_array property instead.',
+ 'Consider using the output_array property instead.',
DeprecationWarning)
-
+
return self._output_array
cpdef execute(self):
'''execute()
Execute the planned operation, taking the correct kind of FFT of
- the input array (i.e. :attr:`FFTW.input_array`),
+ the input array (i.e. :attr:`FFTW.input_array`),
and putting the result in the output array (i.e.
:attr:`FFTW.output_array`).
'''
@@ -1578,7 +1598,7 @@ cdef class FFTW:
<void *>np.PyArray_DATA(self._input_array))
cdef void *output_pointer = (
<void *>np.PyArray_DATA(self._output_array))
-
+
cdef void *plan = self._plan
cdef fftw_generic_execute fftw_execute = self._fftw_execute
with nogil:
@@ -1595,11 +1615,11 @@ cdef void write_char_to_string(char c, void *string_location_ptr):
'''
Write the passed character c to the memory location
pointed to by the contents of string_location_ptr (i.e. a pointer
- to a pointer), then increment the contents of string_location_ptr
+ to a pointer), then increment the contents of string_location_ptr
(i.e. move to the next byte in memory).
In other words, for every character that is passed, we write that
- to a string that is referenced by the dereferenced value of
+ to a string that is referenced by the dereferenced value of
string_location_ptr.
If the derefenced value of string_location points to an
@@ -1617,8 +1637,8 @@ def export_wisdom():
Return the FFTW wisdom as a tuple of strings.
The first string in the tuple is the string for the double
- precision wisdom. The second string in the tuple is the string
- for the single precision wisdom. The third string in the tuple
+ precision wisdom. The second string in the tuple is the string
+ for the single precision wisdom. The third string in the tuple
is the string for the long double precision wisdom.
The tuple that is returned from this function can be used as the
@@ -1677,15 +1697,15 @@ def import_wisdom(wisdom):
of strings.
The first string in the tuple is the string for the double
- precision wisdom. The second string in the tuple is the string
- for the single precision wisdom. The third string in the tuple
+ precision wisdom. The second string in the tuple is the string
+ for the single precision wisdom. The third string in the tuple
is the string for the long double precision wisdom.
The tuple that is returned from :func:`~pyfftw.export_wisdom`
can be used as the argument to this function.
This function returns a tuple of boolean values indicating
- the success of loading each of the wisdom types (double, float
+ the success of loading each of the wisdom types (double, float
and long double, in that order).
'''
@@ -1701,22 +1721,22 @@ def import_wisdom(wisdom):
#def export_wisdom_to_files(
# double_wisdom_file=None,
-# single_wisdom_file=None,
+# single_wisdom_file=None,
# long_double_wisdom_file=None):
# '''export_wisdom_to_file(double_wisdom_file=None, single_wisdom_file=None, long_double_wisdom_file=None)
#
# Export the wisdom to the passed files.
#
-# The double precision wisdom is written to double_wisdom_file.
+# The double precision wisdom is written to double_wisdom_file.
# The single precision wisdom is written to single_wisdom_file.
-# The long double precision wisdom is written to
+# The long double precision wisdom is written to
# long_double_wisdom_file.
#
# If any of the arguments are None, then nothing is done for that
# file.
#
# This function returns a tuple of boolean values indicating
-# the success of storing each of the wisdom types (double, float
+# the success of storing each of the wisdom types (double, float
# and long double, in that order).
# '''
# cdef bint success = True
@@ -1745,22 +1765,22 @@ def import_wisdom(wisdom):
#
#def import_wisdom_to_files(
# double_wisdom_file=None,
-# single_wisdom_file=None,
+# single_wisdom_file=None,
# long_double_wisdom_file=None):
# '''import_wisdom_to_file(double_wisdom_file=None, single_wisdom_file=None, long_double_wisdom_file=None)
#
# import the wisdom to the passed files.
#
-# The double precision wisdom is imported from double_wisdom_file.
+# The double precision wisdom is imported from double_wisdom_file.
# The single precision wisdom is imported from single_wisdom_file.
-# The long double precision wisdom is imported from
+# The long double precision wisdom is imported from
# long_double_wisdom_file.
#
# If any of the arguments are None, then nothing is done for that
# file.
#
# This function returns a tuple of boolean values indicating
-# the success of loading each of the wisdom types (double, float
+# the success of loading each of the wisdom types (double, float
# and long double, in that order).
# '''
# cdef bint success = True
@@ -1794,5 +1814,3 @@ def forget_wisdom():
fftw_forget_wisdom()
fftwf_forget_wisdom()
fftwl_forget_wisdom()
-
-
diff --git a/pyfftw/pyfftw.rst b/pyfftw/pyfftw.rst
new file mode 100644
index 0000000..0efd392
--- /dev/null
+++ b/pyfftw/pyfftw.rst
@@ -0,0 +1,94 @@
+``pyfftw`` - The core
+=====================
+
+.. automodule:: pyfftw
+
+FFTW Class
+----------
+
+.. autoclass:: pyfftw.FFTW(input_array, output_array, axes=(-1,), direction='FFTW_FORWARD', flags=('FFTW_MEASURE',), threads=1, planning_timelimit=None)
+
+ .. autoattribute:: pyfftw.FFTW.N
+
+ .. autoattribute:: pyfftw.FFTW.simd_aligned
+
+ .. autoattribute:: pyfftw.FFTW.input_alignment
+
+ .. autoattribute:: pyfftw.FFTW.output_alignment
+
+ .. autoattribute:: pyfftw.FFTW.flags
+
+ .. autoattribute:: pyfftw.FFTW.input_array
+
+ .. autoattribute:: pyfftw.FFTW.output_array
+
+ .. autoattribute:: pyfftw.FFTW.input_shape
+
+ .. autoattribute:: pyfftw.FFTW.output_shape
+
+ .. autoattribute:: pyfftw.FFTW.input_strides
+
+ .. autoattribute:: pyfftw.FFTW.output_strides
+
+ .. autoattribute:: pyfftw.FFTW.input_dtype
+
+ .. autoattribute:: pyfftw.FFTW.output_dtype
+
+ .. autoattribute:: pyfftw.FFTW.direction
+
+ .. autoattribute:: pyfftw.FFTW.axes
+
+ .. automethod:: pyfftw.FFTW.__call__
+
+ .. automethod:: pyfftw.FFTW.update_arrays
+
+ .. automethod:: pyfftw.FFTW.execute
+
+ .. automethod:: pyfftw.FFTW.get_input_array
+
+ .. automethod:: pyfftw.FFTW.get_output_array
+
+.. _wisdom_functions:
+
+Wisdom Functions
+----------------
+
+Functions for dealing with FFTW's ability to export and restore plans,
+referred to as *wisdom*. For further information, refer to the `FFTW
+wisdom documentation <http://www.fftw.org/fftw3_doc/Words-of-Wisdom_002dSaving-Plans.html#Words-of-Wisdom_002dSaving-Plans>`_.
+
+.. autofunction:: pyfftw.export_wisdom
+
+.. autofunction:: pyfftw.import_wisdom
+
+.. autofunction:: pyfftw.forget_wisdom
+
+.. _utility_functions:
+
+Utility Functions
+-----------------
+
+.. data:: pyfftw.simd_alignment
+
+ An integer giving the optimum SIMD alignment in bytes, found by
+ inspecting the CPU (e.g. if AVX is supported, its value will be 32).
+
+ This can be used as ``n`` in the arguments for :func:`byte_align`,
+ :func:`empty_aligned`, :func:`zeros_aligned`, and :func:`ones_aligned` to
+ create optimally aligned arrays for the running platform.
+
+.. autofunction:: pyfftw.byte_align
+
+.. autofunction:: pyfftw.empty_aligned
+
+.. autofunction:: pyfftw.zeros_aligned
+
+.. autofunction:: pyfftw.ones_aligned
+
+.. autofunction:: pyfftw.is_byte_aligned
+
+.. autofunction:: pyfftw.n_byte_align
+
+.. autofunction:: pyfftw.n_byte_align_empty
+
+.. autofunction:: pyfftw.is_n_byte_aligned
diff --git a/pyfftw/utils.pxi b/pyfftw/utils.pxi
index f72c7aa..0f5a60f 100644
--- a/pyfftw/utils.pxi
+++ b/pyfftw/utils.pxi
@@ -106,7 +106,7 @@ cpdef byte_align(array, n=None, dtype=None):
``dtype`` is an optional argument that forces the resultant array to be
of that dtype.
'''
-
+
if not isinstance(array, np.ndarray):
raise TypeError('Invalid array: byte_align requires a subclass '
'of ndarray')
@@ -117,11 +117,11 @@ cpdef byte_align(array, n=None, dtype=None):
if dtype is not None:
if not array.dtype == dtype:
update_dtype = True
-
+
else:
dtype = array.dtype
update_dtype = False
-
+
# See if we're already n byte aligned. If so, do nothing.
offset = <intptr_t>np.PyArray_DATA(array) %n
@@ -132,7 +132,7 @@ cpdef byte_align(array, n=None, dtype=None):
_array_aligned[:] = array
array = _array_aligned.view(type=array.__class__)
-
+
return array
diff --git a/pyfftw/version.py b/pyfftw/version.py
index 37dae81..6d479f3 100644
--- a/pyfftw/version.py
+++ b/pyfftw/version.py
@@ -1,10 +1,10 @@
# THIS FILE IS GENERATED FROM SETUP.PY
-short_version = '0.10.1'
-version = '0.10.1'
-full_version = '0.10.1'
-git_revision = '43edd862150b910c58744f804ecd5e3543d31ed4'
-release = True
+short_version = '0.10.3'
+version = '0.10.3'
+full_version = '0.10.3.dev0+e827cb5'
+git_revision = 'e827cb573cdbc6ce0f54a7223bd76990b7b0c641'
+release = False
if not release:
version = full_version
diff --git a/requirements.txt b/requirements.txt
index 0c4c1b0..2a4deab 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,3 @@
+cython
numpy>=1.6
scipy>=0.12.0
diff --git a/setup.py b/setup.py
index 562540c..8825f4b 100644
--- a/setup.py
+++ b/setup.py
@@ -1,5 +1,5 @@
# Copyright 2015 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -47,10 +47,37 @@ from distutils.ccompiler import get_default_compiler
import os
import sys
+if os.environ.get('TRAVIS_TAG') != '':
+ git_tag = os.environ.get('TRAVIS_TAG')
+elif os.environ.get('APPVEYOR_REPO_TAG') == 'True':
+ git_tag = os.environ.get('APPVEYOR_REPO_TAG_NAME')
+else:
+ git_tag = None
+
MAJOR = 0
MINOR = 10
-MICRO = 1
-ISRELEASED = True
+MICRO = 3
+
+if git_tag is not None:
+ # Check the tag is properly formed and in agreement with the
+ # expected versio number before declaring a release.
+ import re
+ version_re = re.compile(r'v[0-9]+\.[0-9]+\.[0-9]+')
+ if version_re.match(git_tag) is not None:
+ tag_major, tag_minor, tag_micro = [
+ int(each) for each in git_tag[1:].split('.')]
+
+ assert tag_major == MAJOR
+ assert tag_minor == MINOR
+ assert tag_micro == MICRO
+
+ ISRELEASED = True
+ else:
+ raise ValueError("Malformed version tag for release")
+
+else:
+ ISRELEASED = False
+
VERSION = '%d.%d.%d' % (MAJOR, MINOR, MICRO)
def get_package_data():
@@ -68,7 +95,7 @@ def get_include_dirs():
import numpy
from pkg_resources import get_build_platform
- include_dirs = [os.path.join(os.getcwd(), 'include'),
+ include_dirs = [os.path.join(os.getcwd(), 'include'),
os.path.join(os.getcwd(), 'pyfftw'),
numpy.get_include()]
@@ -93,7 +120,7 @@ def get_libraries():
libraries = ['libfftw3-3', 'libfftw3f-3', 'libfftw3l-3']
else:
- libraries = ['fftw3', 'fftw3f', 'fftw3l', 'fftw3_threads',
+ libraries = ['fftw3', 'fftw3f', 'fftw3l', 'fftw3_threads',
'fftw3f_threads', 'fftw3l_threads']
return libraries
@@ -101,13 +128,16 @@ def get_libraries():
def get_extensions():
from distutils.extension import Extension
+ # will use static linking if STATIC_FFTW_DIR defined
+ static_fftw_path = os.environ.get('STATIC_FFTW_DIR', None)
+ link_static_fftw = static_fftw_path is not None
+
common_extension_args = {
'include_dirs': get_include_dirs(),
- 'library_dirs': get_library_dirs(),
- 'libraries': get_libraries()}
+ 'library_dirs': get_library_dirs()}
try:
- from Cython.Build import cythonize
+ from Cython.Build import cythonize
sources = [os.path.join(os.getcwd(), 'pyfftw', 'pyfftw.pyx')]
have_cython = True
@@ -116,13 +146,34 @@ def get_extensions():
sources = [os.path.join(os.getcwd(), 'pyfftw', 'pyfftw.c')]
if not os.path.exists(sources[0]):
raise ImportError(
- str(e) + '. ' +
+ str(e) + '. ' +
'Cython is required to build the initial .c file.')
-
+
have_cython = False
+ libraries = get_libraries()
+ if link_static_fftw:
+ from pkg_resources import get_build_platform
+ if get_build_platform() in ('win32', 'win-amd64'):
+ lib_pre = ''
+ lib_ext = '.lib'
+ else:
+ lib_pre = 'lib'
+ lib_ext = '.a'
+ extra_link_args = []
+ for lib in libraries:
+ extra_link_args.append(
+ os.path.join(static_fftw_path, lib_pre + lib + lib_ext))
+
+ common_extension_args['extra_link_args'] = extra_link_args
+ common_extension_args['libraries'] = []
+ else:
+ # otherwise we use dynamic libraries
+ common_extension_args['extra_link_args'] = []
+ common_extension_args['libraries'] = libraries
+
ext_modules = [
- Extension('pyfftw.pyfftw', sources=sources,
+ Extension('pyfftw.pyfftw', sources=sources,
**common_extension_args)]
if have_cython:
@@ -138,18 +189,18 @@ the possible transforms that FFTW can perform.
Both the complex DFT and the real DFT are supported, as well as arbitrary
axes of abitrary shaped and strided arrays, which makes it almost
-feature equivalent to standard and real FFT functions of ``numpy.fft``
+feature equivalent to standard and real FFT functions of ``numpy.fft``
(indeed, it supports the ``clongdouble`` dtype which ``numpy.fft`` does not).
Operating FFTW in multithreaded mode is supported.
-A comprehensive unittest suite can be found with the source on the github
+A comprehensive unittest suite can be found with the source on the github
repository.
To build for windows from source, download the fftw dlls for your system
and the header file from here (they're in a zip file):
http://www.fftw.org/install/windows.html and place them in the pyfftw
-directory. The files are libfftw3-3.dll, libfftw3l-3.dll, libfftw3f-3.dll
+directory. The files are libfftw3-3.dll, libfftw3l-3.dll, libfftw3f-3.dll
and libfftw3.h.
Under linux, to build from source, the FFTW library must be installed already.
@@ -157,7 +208,7 @@ This should probably work for OSX, though I've not tried it.
Numpy is a dependency for both.
-The documentation can be found
+The documentation can be found
`here <http://hgomersall.github.com/pyFFTW/>`_, and the source
is on `github <https://github.com/hgomersall/pyFFTW>`_.
'''
@@ -174,7 +225,7 @@ class custom_build_ext(build_ext):
if compiler == 'msvc':
# Add msvc specific hacks
-
+
if (sys.version_info.major, sys.version_info.minor) < (3, 3):
# The check above is a nasty hack. We're using the python
# version as a proxy for the MSVC version. 2008 doesn't
@@ -225,7 +276,7 @@ class CreateChangelogCommand(Command):
pass
def run(self):
- import subprocess
+ import subprocess
github_token_file = 'github_changelog_generator_token'
with open(github_token_file) as f:
@@ -244,12 +295,12 @@ class TestCommand(Command):
def run(self):
import subprocess
- errno = subprocess.call([sys.executable, '-m',
+ errno = subprocess.call([sys.executable, '-m',
'unittest', 'discover'])
raise SystemExit(errno)
class QuickTestCommand(Command):
- '''Runs a set of test cases that covers a limited set of the
+ '''Runs a set of test cases that covers a limited set of the
functionality. It is intended that this class be used as a sanity check
that everything is loaded and basically working as expected. It is not
meant to replace the comprehensive test suite.
@@ -283,14 +334,14 @@ class QuickTestCommand(Command):
'test.test_pyfftw_multithreaded',
'test.test_pyfftw_numpy_interface.InterfacesNumpyFFTTestModule',
'test.test_pyfftw_numpy_interface.InterfacesNumpyFFTTestFFT2',
- 'test.test_pyfftw_numpy_interface.InterfacesNumpyFFTTestIFFT2',
+ 'test.test_pyfftw_numpy_interface.InterfacesNumpyFFTTestIFFT2',
'test.test_pyfftw_builders.BuildersTestFFTWWrapper',
'test.test_pyfftw_builders.BuildersTestFFT2',
'test.test_pyfftw_builders.BuildersTestIRFFT2',
]
import subprocess
- errno = subprocess.call([sys.executable, '-m',
+ errno = subprocess.call([sys.executable, '-m',
'unittest'] + quick_test_cases)
raise SystemExit(errno)
@@ -327,11 +378,12 @@ def get_version_info():
FULLVERSION = VERSION
if os.path.exists('.git'):
GIT_REVISION = git_version()
- elif os.path.exists('pyfftw/version.py'):
+ elif os.path.exists(os.path.join('pyfftw', 'version.py')):
# must be a source distribution, use existing version file
# load it as a separate module in order not to load __init__.py
import imp
- version = imp.load_source('pyfftw.version', 'pyfftw/version.py')
+ version = imp.load_source(
+ 'pyfftw.version', os.path.join('pyfftw', 'version.py'))
GIT_REVISION = version.git_revision
else:
GIT_REVISION = "Unknown"
@@ -342,7 +394,11 @@ def get_version_info():
return FULLVERSION, GIT_REVISION
# borrowed from scipy via pyNFFT
-def write_version_py(filename='pyfftw/version.py'):
+def write_version_py(filename=None):
+
+ if filename is None:
+ filename = os.path.join('pyfftw', 'version.py')
+
cnt = """
# THIS FILE IS GENERATED FROM SETUP.PY
short_version = '%(version)s'
@@ -373,8 +429,11 @@ def setup_package():
# Get current version
FULLVERSION, GIT_REVISION = get_version_info()
- # Refresh version file
- write_version_py()
+ # Refresh version file if we're not a source release
+ if ISRELEASED and os.path.exists(os.path.join('pyfftw', 'version.py')):
+ pass
+ else:
+ write_version_py()
# Figure out whether to add ``*_requires = ['numpy']``.
build_requires = []
diff --git a/sphinx/api.rst b/sphinx/api.rst
new file mode 100644
index 0000000..58f6a66
--- /dev/null
+++ b/sphinx/api.rst
@@ -0,0 +1,9 @@
+API Reference
+*************
+
+.. toctree::
+
+ /pyfftw/pyfftw
+ /pyfftw/builders/builders
+ /pyfftw/builders/_utils
+ /pyfftw/interfaces/interfaces
diff --git a/sphinx/tutorial.rst b/sphinx/tutorial.rst
new file mode 100644
index 0000000..7e4b42c
--- /dev/null
+++ b/sphinx/tutorial.rst
@@ -0,0 +1,474 @@
+Overview and A Short Tutorial
+=============================
+
+Before we begin, we assume that you are already familiar with the
+`discrete Fourier transform
+<http://en.wikipedia.org/wiki/Discrete_Fourier_transform>`_,
+and why you want a faster library to perform your FFTs for you.
+
+`FFTW <http://www.fftw.org/>`_ is a very fast FFT C library. The way it
+is designed to work is by planning *in advance* the fastest way to
+perform a particular transform. It does this by trying lots of
+different techniques and measuring the fastest way, so called
+*planning*.
+
+One consequence of this is that the user needs to specify in advance
+exactly what transform is needed, including things like the data type,
+the array shapes and strides and the precision. This is quite
+different to how one uses, for example, the :mod:`numpy.fft` module.
+
+The purpose of this library is to provide a simple and pythonic way
+to interact with FFTW, benefiting from the substantial speed-ups it
+offers. In addition to the method of using FFTW as described above,
+a convenient series of functions are included through :mod:`pyfftw.interfaces`
+that make using :mod:`pyfftw` almost equivalent to :mod:`numpy.fft`.
+
+This tutorial is split into three parts. A quick introduction to the
+:mod:`pyfftw.interfaces` module is :ref:`given <interfaces_tutorial>`, the
+most simple and direct way to use :mod:`pyfftw`. Secondly an
+:ref:`overview <FFTW_tutorial>` is given of :class:`pyfftw.FFTW`, the core
+of the library. Finally, the :mod:`pyfftw.builders` helper functions are
+:ref:`introduced <builders_tutorial>`, which ease the creation of
+:class:`pyfftw.FFTW` objects.
+
+.. _interfaces_tutorial:
+
+Quick and easy: the :mod:`pyfftw.interfaces` module
+---------------------------------------------------
+
+The easiest way to begin using :mod:`pyfftw` is through the
+:mod:`pyfftw.interfaces` module. This module implements two APIs:
+:mod:`pyfftw.interfaces.numpy_fft` and
+:mod:`pyfftw.interfaces.scipy_fftpack` which are (apart from a small
+caveat [#caveat]_) drop in replacements for :mod:`numpy.fft` and
+:mod:`scipy.fftpack` respectively.
+
+.. doctest::
+
+ >>> import pyfftw
+ >>> import numpy
+ >>> a = pyfftw.empty_aligned(128, dtype='complex128', n=16)
+ >>> a[:] = numpy.random.randn(128) + 1j*numpy.random.randn(128)
+ >>> b = pyfftw.interfaces.numpy_fft.fft(a)
+ >>> c = numpy.fft.fft(a)
+ >>> numpy.allclose(b, c)
+ True
+
+We initially create and fill a complex array, ``a``, of length 128.
+:func:`pyfftw.empty_aligned` is a helper function that works like
+:func:`numpy.empty` but returns the array aligned to a particular number of
+bytes in memory, in this case 16. If the alignment is not specified then the
+library inspects the CPU for an appropriate alignment value. Having byte aligned
+arrays allows FFTW to performed vector operations, potentially speeding up the
+FFT (a similar :func:`pyfftw.byte_align` exists to align a pre-existing array as
+necessary).
+
+Calling :func:`pyfftw.interfaces.numpy_fft.fft` on ``a`` gives the same
+output (to numerical precision) as calling :func:`numpy.fft.fft` on ``a``.
+
+If you wanted to modify existing code that uses :mod:`numpy.fft` to use
+:mod:`pyfftw.interfaces`, this is done simply by replacing all instances of
+:mod:`numpy.fft` with :mod:`pyfftw.interfaces.numpy_fft` (similarly for
+:mod:`scipy.fftpack` and :mod:`pyfftw.interfaces.scipy_fftpack`), and then,
+optionally, enabling the cache (see below).
+
+The first call for a given transform size and shape and dtype and so on
+may be slow, this is down to FFTW needing to plan the transform for the first
+time. Once this has been done, subsequent equivalent transforms during the
+same session are much faster. It's possible to export and save the internal
+knowledge (the *wisdom*) about how the transform is done. This is described
+:ref:`below <wisdom_tutorial>`.
+
+Even after the first transform of a given specification has been performed,
+subsequent transforms are never as fast as using :class:`pyfftw.FFTW` objects
+directly, and in many cases are substantially slower. This is because of the
+internal overhead of creating a new :class:`pyfftw.FFTW` object on every call.
+For this reason, a cache is provided, which is recommended to be used whenever
+:mod:`pyfftw.interfaces` is used. Turn the cache on using
+:func:`pyfftw.interfaces.cache.enable`. This function turns the cache on
+globally. Note that using the cache invokes the threading module.
+
+The cache temporarily stores a copy of any interim :class:`pyfftw.FFTW`
+objects that are created. If they are not used for some period of time,
+which can be set with :func:`pyfftw.interfaces.cache.set_keepalive_time`,
+then they are removed from the cache (liberating any associated memory).
+The default keepalive time is 0.1 seconds.
+
+Monkey patching 3rd party libraries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Since :mod:`pyfftw.interfaces.numpy_fft` and
+:mod:`pyfftw.interfaces.scipy_fftpack` are drop-in replacements for their
+:mod:`numpy.fft` and :mod:`scipy.fftpack` libraries respectively, it is
+possible use them as replacements at run-time through monkey patching.
+
+The following code demonstrates :func:`scipy.signal.fftconvolve` being monkey
+patched in order to speed it up.
+
+.. testcode::
+
+ import pyfftw
+ import scipy.signal
+ import numpy
+ from timeit import Timer
+
+ a = pyfftw.empty_aligned((128, 64), dtype='complex128')
+ b = pyfftw.empty_aligned((128, 64), dtype='complex128')
+
+ a[:] = numpy.random.randn(128, 64) + 1j*numpy.random.randn(128, 64)
+ b[:] = numpy.random.randn(128, 64) + 1j*numpy.random.randn(128, 64)
+
+ t = Timer(lambda: scipy.signal.fftconvolve(a, b))
+
+ print('Time with scipy.fftpack: %1.3f seconds' % t.timeit(number=100))
+
+ # Monkey patch fftpack with pyfftw.interfaces.scipy_fftpack
+ scipy.fftpack = pyfftw.interfaces.scipy_fftpack
+ scipy.signal.fftconvolve(a, b) # We cheat a bit by doing the planning first
+
+ # Turn on the cache for optimum performance
+ pyfftw.interfaces.cache.enable()
+
+ print('Time with monkey patched scipy_fftpack: %1.3f seconds' %
+ t.timeit(number=100))
+
+.. testoutput::
+ :hide:
+
+ ...
+ ...
+
+which outputs something like:
+
+.. code-block:: none
+
+ Time with scipy.fftpack: 0.598 seconds
+ Time with monkey patched scipy_fftpack: 0.251 seconds
+
+Note that prior to Scipy 0.16, it was necessary to patch the individual
+functions in ``scipy.signal.signaltools``. For example:
+
+.. code-block:: python
+
+ scipy.signal.signaltools.ifftn = pyfftw.interfaces.scipy_fftpack.ifftn
+
+
+.. _FFTW_tutorial:
+
+The workhorse :class:`pyfftw.FFTW` class
+----------------------------------------
+
+The core of this library is provided through the :class:`pyfftw.FFTW`
+class. FFTW is fully encapsulated within this class.
+
+The following gives an overview of the :class:`pyfftw.FFTW` class, but
+the easiest way to of dealing with it is through the
+:mod:`pyfftw.builders` helper functions, also
+:ref:`discussed in this tutorial <builders_tutorial>`.
+
+For users that already have some experience of FFTW, there is no
+interface distinction between any of the supported data types, shapes
+or transforms, and operating on arbitrarily strided arrays (which are
+common when using :mod:`numpy`) is fully supported with no copies
+necessary.
+
+In its simplest form, a :class:`pyfftw.FFTW` object is created with
+a pair of complementary :mod:`numpy` arrays: an input array and an
+output array. They are complementary insomuch as the data types and the
+array sizes together define exactly what transform should be performed.
+We refer to a valid transform as a :ref:`scheme <fftw_schemes>`.
+
+Internally, three precisions of FFT are supported. These correspond
+to single precision floating point, double precision floating point
+and long double precision floating
+point, which correspond to :mod:`numpy`'s ``float32``, ``float64``
+and ``longdouble`` dtypes respectively (and the corresponding
+complex types). The precision is decided by the relevant scheme,
+which is specified by the dtype of the input array.
+
+Various schemes are supported by :class:`pyfftw.FFTW`. The scheme
+that is used depends on the data types of the input array and output
+arrays, the shape of the arrays and the direction flag. For a full
+discussion of the schemes available, see the API documentation for
+:class:`pyfftw.FFTW`.
+
+One-Dimensional Transforms
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We will first consider creating a simple one-dimensional transform of
+a one-dimensional complex array:
+
+.. testcode::
+
+ import pyfftw
+
+ a = pyfftw.empty_aligned(128, dtype='complex128')
+ b = pyfftw.empty_aligned(128, dtype='complex128')
+
+ fft_object = pyfftw.FFTW(a, b)
+
+In this case, we create 2 complex arrays, ``a`` and ``b`` each of
+length 128. As before, we use :func:`pyfftw.empty_aligned` to
+make sure the array is aligned.
+
+Given these 2 arrays, the only transform that makes sense is a
+1D complex DFT. The direction in this case is the default, which is
+forward, and so that is the transform that is *planned*. The
+returned ``fft_object`` represents such a transform.
+
+In general, the creation of the :class:`pyfftw.FFTW` object clears the
+contents of the arrays, so the arrays should be filled or updated
+after creation.
+
+Similarly, to plan the inverse:
+
+.. testcode::
+
+ c = pyfftw.empty_aligned(128, dtype='complex128')
+ ifft_object = pyfftw.FFTW(b, c, direction='FFTW_BACKWARD')
+
+In this case, the direction argument is given as ``'FFTW_BACKWARD'``
+(to override the default of ``'FFTW_FORWARD'``).
+
+The actual FFT is performed by calling the returned objects:
+
+.. testcode::
+
+ import numpy
+
+ # Generate some data
+ ar, ai = numpy.random.randn(2, 128)
+ a[:] = ar + 1j*ai
+
+ fft_a = fft_object()
+
+Note that calling the object like this performs the FFT and returns
+the result in an array. This is the *same* array as ``b``:
+
+.. doctest::
+
+ >>> fft_a is b
+ True
+
+This is particularly useful when using :mod:`pyfftw.builders` to
+generate the :class:`pyfftw.FFTW` objects.
+
+Calling the FFT object followed by the inverse FFT object yields
+an output that is numerically the same as the original ``a``
+(within numerical accuracy).
+
+.. doctest::
+
+ >>> fft_a = fft_object()
+ >>> ifft_b = ifft_object()
+ >>> ifft_b is c
+ True
+ >>> numpy.allclose(a, c)
+ True
+ >>> a is c
+ False
+
+In this case, the normalisation of the DFT is performed automatically
+by the inverse FFTW object (``ifft_object``). This can be disabled
+by setting the ``normalise_idft=False`` argument.
+
+It is possible to change the data on which a :class:`pyfftw.FFTW`
+operates. The :meth:`pyfftw.FFTW.__call__` accepts both an
+``input_array`` and an ``output_array`` argument to update the
+arrays. The arrays should be compatible with the arrays with which
+the :class:`pyfftw.FFTW` object was originally created. Please read the
+API docs on :meth:`pyfftw.FFTW.__call__` to fully understand the
+requirements for updating the array.
+
+.. doctest::
+
+ >>> d = pyfftw.empty_aligned(4, dtype='complex128')
+ >>> e = pyfftw.empty_aligned(4, dtype='complex128')
+ >>> f = pyfftw.empty_aligned(4, dtype='complex128')
+ >>> fft_object = pyfftw.FFTW(d, e)
+ >>> fft_object.input_array is d # get the input array from the object
+ True
+ >>> f[:] = [1, 2, 3, 4] # Add some data to f
+ >>> fft_object(f)
+ array([ 10.+0.j, -2.+2.j, -2.+0.j, -2.-2.j])
+ >>> fft_object.input_array is d # No longer true!
+ False
+ >>> fft_object.input_array is f # It has been updated with f :)
+ True
+
+If the new input array is of the wrong dtype or wrongly strided,
+:meth:`pyfftw.FFTW.__call__` method will copy the new array into the
+internal array, if necessary changing it's dtype in the process.
+
+It should be made clear that the :meth:`pyfftw.FFTW.__call__` method
+is simply a helper routine around the other methods of the object.
+Though it is expected that most of the time
+:meth:`pyfftw.FFTW.__call__` will be sufficient, all the FFTW
+functionality can be accessed through other methods at a slightly
+lower level.
+
+Multi-Dimensional Transforms
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Arrays of more than one dimension are easily supported as well.
+In this case, the ``axes`` argument specifies over which axes the
+transform is to be taken.
+
+.. testcode::
+
+ import pyfftw
+
+ a = pyfftw.empty_aligned((128, 64), dtype='complex128')
+ b = pyfftw.empty_aligned((128, 64), dtype='complex128')
+
+ # Plan an fft over the last axis
+ fft_object_a = pyfftw.FFTW(a, b)
+
+ # Over the first axis
+ fft_object_b = pyfftw.FFTW(a, b, axes=(0,))
+
+ # Over the both axes
+ fft_object_c = pyfftw.FFTW(a, b, axes=(0,1))
+
+For further information on all the supported transforms, including
+real transforms, as well as full documentaion on all the
+instantiation arguments, see the :class:`pyfftw.FFTW` documentation.
+
+.. _wisdom_tutorial:
+
+Wisdom
+~~~~~~
+
+When creating a :class:`pyfftw.FFTW` object, it is possible to instruct
+FFTW how much effort it should put into finding the fastest possible
+method for computing the DFT. This is done by specifying a suitable
+planner flag in ``flags`` argument to :class:`pyfftw.FFTW`. Some
+of the planner flags can take a very long time to complete which can
+be problematic.
+
+When the a particular transform has been created, distinguished by
+things like the data type, the shape, the stridings and the flags,
+FFTW keeps a record of the fastest way to compute such a transform in
+future. This is referred to as
+`wisdom <http://www.fftw.org/fftw3_doc/Wisdom.html>`_. When
+the program is completed, the wisdom that has been accumulated is
+forgotten.
+
+It is possible to output the accumulated wisdom using the
+:ref:`wisdom output routines <wisdom_functions>`.
+:func:`pyfftw.export_wisdom` exports and returns the wisdom as a tuple
+of strings that can be easily written to file. To load the wisdom back
+in, use the :func:`pyfftw.import_wisdom` function which takes as its
+argument that same tuple of strings that was returned from
+:func:`pyfftw.export_wisdom`.
+
+If for some reason you wish to forget the accumulated wisdom, call
+:func:`pyfftw.forget_wisdom`.
+
+.. _builders_tutorial:
+
+The :mod:`pyfftw.builders` functions
+------------------------------------
+
+If you absolutely need the flexibility of dealing with
+:class:`pyfftw.FFTW` directly, an easier option than constructing valid
+arrays and so on is to use the convenient :mod:`pyfftw.builders` package.
+These functions take care of much of the difficulty in specifying the
+exact size and dtype requirements to produce a valid scheme.
+
+The :mod:`pyfftw.builders` functions are a series of helper functions
+that provide an interface very much like that provided by
+:mod:`numpy.fft`, only instead of returning the result of the
+transform, a :class:`pyfftw.FFTW` object (or in some cases a wrapper
+around :class:`pyfftw.FFTW`) is returned.
+
+.. testcode::
+
+ import pyfftw
+
+ a = pyfftw.empty_aligned((128, 64), dtype='complex128')
+
+ # Generate some data
+ ar, ai = numpy.random.randn(2, 128, 64)
+ a[:] = ar + 1j*ai
+
+ fft_object = pyfftw.builders.fft(a)
+
+ b = fft_object()
+
+``fft_object`` is an instance of :class:`pyfftw.FFTW`, ``b`` is
+the result of the DFT.
+
+Note that in this example, unlike creating a :class:`pyfftw.FFTW`
+object using the direct interface, we can fill the array in advance.
+This is because by default all the functions in :mod:`pyfftw.builders`
+keep a copy of the input array during creation (though this can
+be disabled).
+
+The :mod:`pyfftw.builders` functions construct an output array of
+the correct size and type. In the case of the regular DFTs, this
+always creates an output array of the same size as the input array.
+In the case of the real transform, the output array is the right
+shape to satisfy the scheme requirements.
+
+The precision of the transform is determined by the dtype of the
+input array. If the input array is a floating point array, then
+the precision of the floating point is used. If the input array
+is not a floating point array then a double precision transform is used.
+Any calls made to the resultant object with an array of the same
+size will then be copied into the internal array of the object,
+changing the dtype in the process.
+
+Like :mod:`numpy.fft`, it is possible to specify a length (in the
+one-dimensional case) or a shape (in the multi-dimensional case) that
+may be different to the array that is passed in. In such a case,
+a wrapper object of type
+:class:`pyfftw.builders._utils._FFTWWrapper` is returned. From an
+interface perspective, this is identical to :class:`pyfftw.FFTW`. The
+difference is in the way calls to the object are handled. With
+:class:`pyfftw.builders._utils._FFTWWrapper` objects, an array that
+is passed as an argument when calling the object is *copied* into the
+internal array. This is done by a suitable slicing of the new
+passed-in array and the internal array and is done precisely because
+the shape of the transform is different to the shape of the input
+array.
+
+.. testcode::
+
+ a = pyfftw.empty_aligned((128, 64), dtype='complex128')
+
+ fft_wrapper_object = pyfftw.builders.fftn(a, s=(32, 256))
+
+ b = fft_wrapper_object()
+
+Inspecting these objects gives us their shapes:
+
+.. doctest::
+
+ >>> b.shape
+ (32, 256)
+ >>> fft_wrapper_object.input_array.shape
+ (32, 256)
+ >>> a.shape
+ (128, 64)
+
+It is only possible to call ``fft_wrapper_object`` with an array
+that is the same shape as ``a``. In this case, the first axis of ``a``
+is sliced to include only the first 32 elements, and the second axis
+of the internal array is sliced to include only the last 64 elements.
+This way, shapes are made consistent for copying.
+
+Understanding :mod:`numpy.fft`, these functions are largely
+self-explanatory. We point the reader to the :mod:`API docs <pyfftw.builders>`
+for more information.
+
+.. rubric:: Footnotes
+
+.. [#caveat] :mod:`pyfftw.interfaces` deals with repeated values in the
+ ``axes`` argument differently to :mod:`numpy.fft` (and probably to
+ :mod:`scipy.fftpack` to, but that's not documented clearly).
+ Specifically, :mod:`numpy.fft` takes the transform along a given axis
+ as many times as it appears in the ``axes`` argument.
+ :mod:`pyfftw.interfaces` takes the transform only once along each
+ axis that appears, regardless of how many times it appears. This is
+ deemed to be such a fringe corner case that it is ignored.
diff --git a/test/_cook_nd_args.py b/test/_cook_nd_args.py
new file mode 100644
index 0000000..d72fc61
--- /dev/null
+++ b/test/_cook_nd_args.py
@@ -0,0 +1,60 @@
+# This file is licensed differently to the rest of pyFFTW. The license
+# is as set out below.
+#
+# Copyright (c) 2005-2011, NumPy Developers.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following
+# disclaimer in the documentation and/or other materials provided
+# with the distribution.
+#
+# * Neither the name of the NumPy Developers nor the names of any
+# contributors may be used to endorse or promote products derived
+# from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# A module containing the latest version of _cook_nd_args from
+# numpy.fft.fftpack. It can be used to overwrite an earlier
+# broken version in the tests.
+
+from numpy.core import take
+
+def _cook_nd_args(a, s=None, axes=None, invreal=0):
+ if s is None:
+ shapeless = 1
+ if axes is None:
+ s = list(a.shape)
+ else:
+ s = take(a.shape, axes)
+ else:
+ shapeless = 0
+ s = list(s)
+ if axes is None:
+ axes = range(-len(s), 0)
+ if len(s) != len(axes):
+ raise ValueError("Shape and axes have different lengths.")
+ if invreal and shapeless:
+ # Here is the fix. The following line is replaced
+ # (see numpy commit 88a02920daf0b408086106439c53bd488e73af29):
+ #s[axes[-1]] = (s[axes[-1]] - 1) * 2
+ s[-1] = (a.shape[axes[-1]] - 1) * 2
+ return s, axes
diff --git a/pyfftw/cpu.pxd b/test/_get_default_args.py
similarity index 65%
copy from pyfftw/cpu.pxd
copy to test/_get_default_args.py
index 10f0acd..d7d19b2 100644
--- a/pyfftw/cpu.pxd
+++ b/test/_get_default_args.py
@@ -1,7 +1,7 @@
-# Copyright 2014 Knowledge Economy Developments Ltd
-#
+# Copyright 2015 Knowledge Economy Developments Ltd
+#
# Henry Gomersall
-# heng at kedevelopments.co.uk
+# henry.gomersall at kedevelopments.co.uk
#
# All rights reserved.
#
@@ -32,6 +32,27 @@
# POSSIBILITY OF SUCH DAMAGE.
#
-cdef extern from "cpu.h":
+import sys
+import inspect
+
+def get_default_args(function):
+
+ if sys.version_info < (3, 0):
+ # The slightly hacky Python 2.7 way
+ argspec = inspect.getargspec(function)
+ default_args = dict(list(zip(
+ argspec.args[-len(argspec.defaults):], argspec.defaults)))
+
+ else:
+ # The better Python 3 way
+ sig = inspect.signature(function)
+
+ default_args = {}
+ for parameter in sig.parameters:
+
+ default_val = sig.parameters[parameter].default
+ if default_val is not inspect.Parameter.empty:
+ # Add it to the parameter list
+ default_args[parameter] = default_val
- int simd_alignment()
+ return default_args
diff --git a/test/test_pyfftw_base.py b/test/test_pyfftw_base.py
index cfd8517..50bf4a6 100644
--- a/test/test_pyfftw_base.py
+++ b/test/test_pyfftw_base.py
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -40,7 +40,7 @@ from timeit import Timer
import unittest
class FFTWBaseTest(unittest.TestCase):
-
+
def reference_fftn(self, a, axes):
return numpy.fft.fftn(a, axes=axes)
@@ -53,7 +53,7 @@ class FFTWBaseTest(unittest.TestCase):
self.assertRaisesRegex = self.assertRaisesRegexp
def setUp(self):
-
+
self.input_dtype = numpy.complex64
self.output_dtype = numpy.complex64
self.np_fft_comparison = numpy.fft.fft
@@ -62,7 +62,7 @@ class FFTWBaseTest(unittest.TestCase):
return
def tearDown(self):
-
+
return
def get_input_dtype_alignment(self):
@@ -100,7 +100,7 @@ class FFTWBaseTest(unittest.TestCase):
t = Timer(stmt=pyfftw_callable)
t_numpy_fft = Timer(stmt=numpy_fft_callable)
-
+
t_str = ("%.2f" % (1000.0/N*t.timeit(N)))+' ms'
t_numpy_str = ("%.2f" % (1000.0/N*t_numpy_fft.timeit(N)))+' ms'
@@ -109,8 +109,8 @@ class FFTWBaseTest(unittest.TestCase):
')')
- def run_validate_fft(self, a, b, axes, fft=None, ifft=None,
- force_unaligned_data=False, create_array_copies=True,
+ def run_validate_fft(self, a, b, axes, fft=None, ifft=None,
+ force_unaligned_data=False, create_array_copies=True,
threads=1, flags=('FFTW_ESTIMATE',)):
''' Run a validation of the FFTW routines for the passed pair
of arrays, a and b, and the axes argument.
@@ -139,7 +139,7 @@ class FFTWBaseTest(unittest.TestCase):
if force_unaligned_data:
flags.append('FFTW_UNALIGNED')
-
+
if fft == None:
fft = FFTW(a,b,axes=axes, direction='FFTW_FORWARD',
flags=flags, threads=threads)
@@ -163,14 +163,14 @@ class FFTWBaseTest(unittest.TestCase):
# sometimes fails. I assume that numpy.fft has different internals
# to fftw.
self.assertTrue(numpy.allclose(b, ref_b, rtol=1e-2, atol=1e-3))
-
+
# Test the inverse FFT by comparing the result to the starting
# value (which is scaled as per FFTW being unnormalised).
ifft.execute()
# The scaling is the product of the lengths of the fft along
# the axes along which the fft is taken.
scaling = numpy.prod(numpy.array(a.shape)[list(axes)])
-
+
self.assertEqual(ifft.N, scaling)
self.assertEqual(fft.N, scaling)
@@ -185,14 +185,14 @@ def run_test_suites(test_suites, run_tests=None):
If run_tests is not None, then it should be a dictionary with
keys being the test suite class name, and the values being
a list of test methods to run. Alternatively, the key can
- be 'all' in which case all the test suites will be run with
+ be 'all' in which case all the test suites will be run with
the provided list of test suites.
'''
suite = unittest.TestSuite()
for test_class in test_suites:
tests = unittest.TestLoader().loadTestsFromTestCase(test_class)
-
+
if run_tests is not None:
if test_class.__name__ in run_tests:
this_suite_run = set(run_tests[test_class.__name__])
@@ -211,5 +211,5 @@ def run_test_suites(test_suites, run_tests=None):
suite.addTests(tests)
-
+
unittest.TextTestRunner(verbosity=2).run(suite)
diff --git a/test/test_pyfftw_builders.py b/test/test_pyfftw_builders.py
index 2661924..2208fbb 100644
--- a/test/test_pyfftw_builders.py
+++ b/test/test_pyfftw_builders.py
@@ -1,5 +1,5 @@
# Copyright 2015 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -68,7 +68,7 @@ output_dtypes = {
functions = {
'fft': 'complex',
- 'ifft': 'complex',
+ 'ifft': 'complex',
'rfft': 'r2c',
'irfft': 'c2r',
'rfftn': 'r2c',
@@ -124,11 +124,11 @@ class BuildersTestFFT(unittest.TestCase):
yield test_shape, s, kwargs
- def validate_pyfftw_object(self, array_type, test_shape, dtype,
+ def validate_pyfftw_object(self, array_type, test_shape, dtype,
s, kwargs):
input_array = array_type(test_shape, dtype)
-
+
# Use char because of potential MSVC related bug.
if input_array.dtype.char == np.dtype('clongdouble').char:
np_input_array = numpy.complex128(input_array)
@@ -147,7 +147,7 @@ class BuildersTestFFT(unittest.TestCase):
input_array.copy(), s, **kwargs)
# We run FFT twice to check two operations don't
- # yield different results (which they might if
+ # yield different results (which they might if
# the state is buggered up).
output_array = FFTW_object(input_array.copy())
output_array_2 = FFTW_object(input_array.copy())
@@ -169,19 +169,19 @@ class BuildersTestFFT(unittest.TestCase):
# Make sure a warning is raised
self.assertIs(
w[-1].category, numpy.ComplexWarning)
-
+
self.assertTrue(
- numpy.allclose(output_array, test_out_array,
+ numpy.allclose(output_array, test_out_array,
rtol=1e-2, atol=1e-4))
self.assertTrue(
- numpy.allclose(output_array_2, test_out_array,
+ numpy.allclose(output_array_2, test_out_array,
rtol=1e-2, atol=1e-4))
return FFTW_object
def axes_from_kwargs(self, kwargs):
-
+
default_args = get_default_args(getattr(builders, self.func))
if 'axis' in kwargs:
@@ -246,12 +246,12 @@ class BuildersTestFFT(unittest.TestCase):
def test_valid(self):
dtype_tuple = input_dtypes[functions[self.func]]
-
+
for dtype in dtype_tuple[0]:
for test_shape, s, kwargs in self.test_data:
s = None
- FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
+ FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
test_shape, dtype, s, kwargs)
self.assertTrue(type(FFTW_object) == FFTW)
@@ -266,29 +266,29 @@ class BuildersTestFFT(unittest.TestCase):
inp_dtype_tuple = input_dtypes[functions[self.func]]
output_dtype_tuple = output_dtypes[functions[self.func]]
- for input_dtype, output_dtype in zip(inp_dtype_tuple[0],
+ for input_dtype, output_dtype in zip(inp_dtype_tuple[0],
output_dtype_tuple):
for test_shape, s, kwargs in self.test_data:
s = None
- FFTW_object = self.validate_pyfftw_object(inp_dtype_tuple[1],
+ FFTW_object = self.validate_pyfftw_object(inp_dtype_tuple[1],
test_shape, input_dtype, s, kwargs)
self.assertTrue(
- FFTW_object.output_array.dtype.char ==
+ FFTW_object.output_array.dtype.char ==
np.dtype(output_dtype).char)
def test_fail_on_invalid_s_or_axes(self):
dtype_tuple = input_dtypes[functions[self.func]]
-
+
for dtype in dtype_tuple[0]:
for test_shape, args, exception, e_str in self.invalid_args:
input_array = dtype_tuple[1](test_shape, dtype)
-
+
self.assertRaisesRegex(exception, e_str,
- getattr(builders, self.func),
+ getattr(builders, self.func),
*((input_array,) + args))
@@ -297,7 +297,7 @@ class BuildersTestFFT(unittest.TestCase):
for dtype in dtype_tuple[0]:
for test_shape, s, kwargs in self.test_data:
- FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
+ FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
test_shape, dtype, s, kwargs)
self.assertTrue(type(FFTW_object) == FFTW)
@@ -321,12 +321,12 @@ class BuildersTestFFT(unittest.TestCase):
# They implicitly overwrite the input anyway
_kwargs['overwrite_input'] = True
- FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
+ FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
test_shape, dtype, s, _kwargs)
self.assertTrue(
type(FFTW_object) == utils._FFTWWrapper)
-
+
def test_bigger_s(self):
dtype_tuple = input_dtypes[functions[self.func]]
for dtype in dtype_tuple[0]:
@@ -338,7 +338,7 @@ class BuildersTestFFT(unittest.TestCase):
except TypeError:
s += 2
- FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
+ FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
test_shape, dtype, s, kwargs)
self.assertTrue(
@@ -355,11 +355,11 @@ class BuildersTestFFT(unittest.TestCase):
except TypeError:
s -= 2
- FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
+ FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
test_shape, dtype, s, kwargs)
self.assertTrue(
- type(FFTW_object) == utils._FFTWWrapper)
+ type(FFTW_object) == utils._FFTWWrapper)
def test_bigger_and_smaller_s(self):
dtype_tuple = input_dtypes[functions[self.func]]
@@ -375,15 +375,15 @@ class BuildersTestFFT(unittest.TestCase):
s += i * 2
i *= i
- FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
+ FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
test_shape, dtype, s, kwargs)
self.assertTrue(
type(FFTW_object) == utils._FFTWWrapper)
-
+
def test_auto_contiguous_input(self):
dtype_tuple = input_dtypes[functions[self.func]]
-
+
for dtype in dtype_tuple[0]:
for test_shape, s, kwargs in self.test_data:
_kwargs = kwargs.copy()
@@ -403,14 +403,14 @@ class BuildersTestFFT(unittest.TestCase):
input_array = dtype_tuple[1](_test_shape, dtype)[slices]
# check the input is non contiguous
- self.assertFalse(input_array.flags['C_CONTIGUOUS'] or
+ self.assertFalse(input_array.flags['C_CONTIGUOUS'] or
input_array.flags['F_CONTIGUOUS'])
# Firstly check the non-contiguous case (for both
# FFTW and _FFTWWrapper)
_kwargs['auto_contiguous'] = False
-
+
# We also need to make sure we're not copying due
# to a trivial misalignment
_kwargs['auto_align_input'] = False
@@ -421,7 +421,7 @@ class BuildersTestFFT(unittest.TestCase):
internal_input_array = FFTW_object.input_array
flags = internal_input_array.flags
self.assertTrue(input_array is internal_input_array)
- self.assertFalse(flags['C_CONTIGUOUS'] or
+ self.assertFalse(flags['C_CONTIGUOUS'] or
flags['F_CONTIGUOUS'])
FFTW_object = getattr(builders, self.func)(
@@ -440,9 +440,9 @@ class BuildersTestFFT(unittest.TestCase):
internal_input_array = FFTW_object.input_array
flags = internal_input_array.flags
- self.assertTrue(flags['C_CONTIGUOUS'] or
+ self.assertTrue(flags['C_CONTIGUOUS'] or
flags['F_CONTIGUOUS'])
-
+
FFTW_object = getattr(builders, self.func)(
input_array, s2, **_kwargs)
@@ -454,7 +454,7 @@ class BuildersTestFFT(unittest.TestCase):
def test_auto_align_input(self):
dtype_tuple = input_dtypes[functions[self.func]]
-
+
for dtype in dtype_tuple[0]:
for test_shape, s, kwargs in self.test_data:
_kwargs = kwargs.copy()
@@ -489,7 +489,7 @@ class BuildersTestFFT(unittest.TestCase):
self.assertTrue(FFTW_object.simd_aligned)
- self.assertTrue('FFTW_UNALIGNED' not in FFTW_object.flags)
+ self.assertTrue('FFTW_UNALIGNED' not in FFTW_object.flags)
FFTW_object = getattr(builders, self.func)(
input_array.copy(), s2, **_kwargs)
@@ -508,7 +508,7 @@ class BuildersTestFFT(unittest.TestCase):
for test_shape, s, kwargs in self.test_data:
s = None
- FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
+ FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
test_shape, dtype, s, kwargs)
self.assertTrue(type(FFTW_object) == FFTW)
@@ -536,7 +536,7 @@ class BuildersTestFFT(unittest.TestCase):
padding_slicer[axes[0]] = slice(s, None)
# Get a valid object
- FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
+ FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
test_shape, dtype, s, kwargs)
internal_array = FFTW_object.input_array
@@ -559,7 +559,7 @@ class BuildersTestFFT(unittest.TestCase):
'''
dtype_tuple = input_dtypes[functions[self.func]]
test_shape = (16,)
-
+
for dtype in dtype_tuple[0]:
s = None
if self.axes_kw == 'axis':
@@ -567,11 +567,11 @@ class BuildersTestFFT(unittest.TestCase):
else:
kwargs = {'axes': (-1,)}
- for each_effort in ('FFTW_ESTIMATE', 'FFTW_MEASURE',
+ for each_effort in ('FFTW_ESTIMATE', 'FFTW_MEASURE',
'FFTW_PATIENT', 'FFTW_EXHAUSTIVE'):
-
+
kwargs['planner_effort'] = each_effort
-
+
FFTW_object = self.validate_pyfftw_object(
dtype_tuple[1], test_shape, dtype, s, kwargs)
@@ -580,7 +580,7 @@ class BuildersTestFFT(unittest.TestCase):
kwargs['planner_effort'] = 'garbage'
self.assertRaisesRegex(ValueError, 'Invalid planner effort',
- self.validate_pyfftw_object,
+ self.validate_pyfftw_object,
*(dtype_tuple[1], test_shape, dtype, s, kwargs))
def test_threads_arg(self):
@@ -588,7 +588,7 @@ class BuildersTestFFT(unittest.TestCase):
'''
dtype_tuple = input_dtypes[functions[self.func]]
test_shape = (16,)
-
+
for dtype in dtype_tuple[0]:
s = None
if self.axes_kw == 'axis':
@@ -597,16 +597,16 @@ class BuildersTestFFT(unittest.TestCase):
kwargs = {'axes': (-1,)}
kwargs['threads'] = 2
-
+
# Should just work
FFTW_object = self.validate_pyfftw_object(
dtype_tuple[1], test_shape, dtype, s, kwargs)
kwargs['threads'] = 'bleh'
-
+
# Should not work
self.assertRaises(TypeError,
- self.validate_pyfftw_object,
+ self.validate_pyfftw_object,
*(dtype_tuple[1], test_shape, dtype, s, kwargs))
@@ -614,13 +614,13 @@ class BuildersTestFFT(unittest.TestCase):
'''Test the overwrite_input flag
'''
dtype_tuple = input_dtypes[functions[self.func]]
-
+
for dtype in dtype_tuple[0]:
for test_shape, s, _kwargs in self.test_data:
s = None
kwargs = _kwargs.copy()
- FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
+ FFTW_object = self.validate_pyfftw_object(dtype_tuple[1],
test_shape, dtype, s, kwargs)
if self.func not in ('irfft2', 'irfftn'):
@@ -643,7 +643,7 @@ class BuildersTestFFT(unittest.TestCase):
for test_shape, s, kwargs in self.test_data:
input_array = dtype_tuple[1](test_shape, dtype)
-
+
FFTW_object = getattr(
builders, self.func)(input_array, s, **kwargs)
@@ -656,7 +656,7 @@ class BuildersTestFFT(unittest.TestCase):
'''Test the avoid_copy flag
'''
dtype_tuple = input_dtypes[functions[self.func]]
-
+
for dtype in dtype_tuple[0]:
for test_shape, s, kwargs in self.test_data:
_kwargs = kwargs.copy()
@@ -672,7 +672,7 @@ class BuildersTestFFT(unittest.TestCase):
input_array = dtype_tuple[1](test_shape, dtype)
- self.assertRaisesRegex(ValueError,
+ self.assertRaisesRegex(ValueError,
'Cannot avoid copy.*transform shape.*',
getattr(builders, self.func),
input_array, s2, **_kwargs)
@@ -685,7 +685,7 @@ class BuildersTestFFT(unittest.TestCase):
misaligned_input_array = dtype_tuple[1](
non_contiguous_shape, dtype)[non_contiguous_slices]
- self.assertRaisesRegex(ValueError,
+ self.assertRaisesRegex(ValueError,
'Cannot avoid copy.*not contiguous.*',
getattr(builders, self.func),
misaligned_input_array, s, **_kwargs)
@@ -699,7 +699,7 @@ class BuildersTestFFT(unittest.TestCase):
misaligned_input_array = _input_array[1:].view(
dtype=input_array.dtype).reshape(*test_shape)
- self.assertRaisesRegex(ValueError,
+ self.assertRaisesRegex(ValueError,
'Cannot avoid copy.*not aligned.*',
getattr(builders, self.func),
misaligned_input_array, s, **_kwargs)
diff --git a/test/test_pyfftw_call.py b/test/test_pyfftw_call.py
index fba1bc7..d277488 100644
--- a/test/test_pyfftw_call.py
+++ b/test/test_pyfftw_call.py
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -48,7 +48,7 @@ class FFTWCallTest(unittest.TestCase):
if not hasattr(self, 'assertRaisesRegex'):
self.assertRaisesRegex = self.assertRaisesRegexp
-
+
def setUp(self):
self.input_array = empty_aligned((256, 512), dtype='complex128', n=16)
@@ -56,22 +56,22 @@ class FFTWCallTest(unittest.TestCase):
self.fft = FFTW(self.input_array, self.output_array)
- self.input_array[:] = (numpy.random.randn(*self.input_array.shape)
+ self.input_array[:] = (numpy.random.randn(*self.input_array.shape)
+ 1j*numpy.random.randn(*self.input_array.shape))
-
+
def test_call(self):
'''Test a call to an instance of the class.
'''
- self.input_array[:] = (numpy.random.randn(*self.input_array.shape)
+ self.input_array[:] = (numpy.random.randn(*self.input_array.shape)
+ 1j*numpy.random.randn(*self.input_array.shape))
output_array = self.fft()
self.assertTrue(numpy.alltrue(output_array == self.output_array))
-
+
def test_call_with_positional_input_update(self):
'''Test the class call with a positional input update.
'''
@@ -86,7 +86,7 @@ class FFTWCallTest(unittest.TestCase):
self.fft.execute()
self.assertTrue(numpy.alltrue(output_array == self.output_array))
-
+
def test_call_with_keyword_input_update(self):
'''Test the class call with a keyword input update.
'''
@@ -101,8 +101,8 @@ class FFTWCallTest(unittest.TestCase):
self.fft.execute()
self.assertTrue(numpy.alltrue(output_array == self.output_array))
-
-
+
+
def test_call_with_keyword_output_update(self):
'''Test the class call with a keyword output update.
'''
@@ -158,7 +158,7 @@ class FFTWCallTest(unittest.TestCase):
self.fft.execute()
self.assertTrue(numpy.alltrue(returned_output_array == output_array))
-
+
def test_call_with_different_input_dtype(self):
'''Test the class call with an array with a different input dtype
'''
@@ -177,7 +177,7 @@ class FFTWCallTest(unittest.TestCase):
self.fft.execute()
self.assertTrue(numpy.alltrue(output_array == self.output_array))
-
+
def test_call_with_list_input(self):
'''Test the class call with a list rather than an array
'''
@@ -194,21 +194,21 @@ class FFTWCallTest(unittest.TestCase):
'''
new_shape = self.input_array.shape + (2, )
- invalid_array = (numpy.random.randn(*new_shape)
+ invalid_array = (numpy.random.randn(*new_shape)
+ 1j*numpy.random.randn(*new_shape))
-
- self.assertRaises(ValueError, self.fft,
+
+ self.assertRaises(ValueError, self.fft,
*(),
**{'output_array':invalid_array})
- self.assertRaises(ValueError, self.fft,
+ self.assertRaises(ValueError, self.fft,
*(),
**{'input_array':invalid_array})
def test_call_with_auto_input_alignment(self):
'''Test the class call with a keyword input update.
'''
- input_array = (numpy.random.randn(*self.input_array.shape)
+ input_array = (numpy.random.randn(*self.input_array.shape)
+ 1j*numpy.random.randn(*self.input_array.shape))
output_array = self.fft(
@@ -224,11 +224,11 @@ class FFTWCallTest(unittest.TestCase):
a_[:] = a
# Just confirm that a usual update will fail
- self.assertRaisesRegex(ValueError, 'Invalid input alignment',
+ self.assertRaisesRegex(ValueError, 'Invalid input alignment',
self.fft.update_arrays, *(a_, self.output_array))
-
+
self.fft(a_, self.output_array)
-
+
self.assertTrue(numpy.alltrue(output_array == self.output_array))
# now try with a single byte offset and SIMD off
@@ -271,7 +271,7 @@ class FFTWCallTest(unittest.TestCase):
+ 1j*numpy.random.randn(*shape), n=16)
fft = FFTW(input_array[:,:,0], self.output_array)
-
+
test_output_array = fft().copy()
new_input_array = byte_align(
@@ -294,14 +294,14 @@ class FFTWCallTest(unittest.TestCase):
+ 1j*numpy.random.randn(*shape), n=16)
fft = FFTW(self.input_array, self.output_array)
-
+
self.assertRaisesRegex(ValueError, 'Invalid input shape',
self.fft, **{'input_array': input_array[:,:,0]})
def test_call_with_unaligned(self):
'''Make sure the right thing happens with unaligned data.
'''
- input_array = (numpy.random.randn(*self.input_array.shape)
+ input_array = (numpy.random.randn(*self.input_array.shape)
+ 1j*numpy.random.randn(*self.input_array.shape))
output_array = self.fft(
@@ -333,30 +333,30 @@ class FFTWCallTest(unittest.TestCase):
output_array = fft().copy()
# Check a_ is not aligned...
- self.assertRaisesRegex(ValueError, 'Invalid input alignment',
+ self.assertRaisesRegex(ValueError, 'Invalid input alignment',
self.fft.update_arrays, *(a_, output_array))
# and b_ too
- self.assertRaisesRegex(ValueError, 'Invalid output alignment',
+ self.assertRaisesRegex(ValueError, 'Invalid output alignment',
self.fft.update_arrays, *(input_array, b_))
-
+
# But it should still work with the a_
fft(a_)
# However, trying to update the output will raise an error
- self.assertRaisesRegex(ValueError, 'Invalid output alignment',
+ self.assertRaisesRegex(ValueError, 'Invalid output alignment',
self.fft.update_arrays, *(input_array, b_))
# Same with SIMD off
fft = FFTW(input_array, output_array, flags=('FFTW_UNALIGNED',))
fft(a_)
- self.assertRaisesRegex(ValueError, 'Invalid output alignment',
+ self.assertRaisesRegex(ValueError, 'Invalid output alignment',
self.fft.update_arrays, *(input_array, b_))
def test_call_with_normalisation_on(self):
_input_array = empty_aligned((256, 512), dtype='complex128', n=16)
- ifft = FFTW(self.output_array, _input_array,
+ ifft = FFTW(self.output_array, _input_array,
direction='FFTW_BACKWARD')
self.fft(normalise_idft=True) # Shouldn't make any difference
@@ -380,7 +380,7 @@ class FFTWCallTest(unittest.TestCase):
def test_call_with_normalisation_default(self):
_input_array = empty_aligned((256, 512), dtype='complex128', n=16)
- ifft = FFTW(self.output_array, _input_array,
+ ifft = FFTW(self.output_array, _input_array,
direction='FFTW_BACKWARD')
self.fft()
@@ -395,7 +395,8 @@ class FFTWCallTest(unittest.TestCase):
# Should be the case for double inputs...
_input_array = empty_aligned((256, 512), dtype='complex128', n=16)
- ifft = FFTW(self.output_array, _input_array,
+ self.fft()
+ ifft = FFTW(self.output_array, _input_array,
direction='FFTW_BACKWARD')
ref_output = ifft(normalise_idft=False).copy()/numpy.float64(ifft.N)
@@ -406,8 +407,8 @@ class FFTWCallTest(unittest.TestCase):
# ... and single inputs.
_input_array = empty_aligned((256, 512), dtype='complex64', n=16)
- ifft = FFTW(numpy.array(self.output_array, _input_array.dtype),
- _input_array,
+ ifft = FFTW(numpy.array(self.output_array, _input_array.dtype),
+ _input_array,
direction='FFTW_BACKWARD')
ref_output = ifft(normalise_idft=False).copy()/numpy.float64(ifft.N)
@@ -415,7 +416,47 @@ class FFTWCallTest(unittest.TestCase):
self.assertTrue(numpy.alltrue(ref_output == test_output))
-
+ def test_call_with_ortho_on(self):
+ _input_array = empty_aligned((256, 512), dtype='complex128', n=16)
+
+ ifft = FFTW(self.output_array, _input_array,
+ direction='FFTW_BACKWARD')
+
+ self.fft(ortho=True, normalise_idft=False)
+
+ # ortho case preserves the norm in forward direction
+ self.assertTrue(
+ numpy.allclose(numpy.linalg.norm(self.input_array),
+ numpy.linalg.norm(self.output_array)))
+
+ ifft(ortho=True, normalise_idft=False)
+
+ # ortho case preserves the norm in backward direction
+ self.assertTrue(
+ numpy.allclose(numpy.linalg.norm(_input_array),
+ numpy.linalg.norm(self.output_array)))
+
+ self.assertTrue(numpy.allclose(self.input_array, _input_array))
+
+ # cant select both ortho and normalise_idft
+ self.assertRaisesRegex(ValueError, 'Invalid options',
+ self.fft, normalise_idft=True, ortho=True)
+ # cant specify orth=True with default normalise_idft=True
+ self.assertRaisesRegex(ValueError, 'Invalid options',
+ self.fft, ortho=True)
+
+ def test_call_with_ortho_off(self):
+ _input_array = empty_aligned((256, 512), dtype='complex128', n=16)
+
+ ifft = FFTW(self.output_array, _input_array,
+ direction='FFTW_BACKWARD')
+
+ self.fft(ortho=False)
+ ifft(ortho=False)
+
+ # Scaling by normalise_idft is performed by default
+ self.assertTrue(numpy.allclose(self.input_array, _input_array))
+
test_cases = (
FFTWCallTest,)
@@ -424,4 +465,3 @@ test_set = None
if __name__ == '__main__':
run_test_suites(test_cases, test_set)
-
diff --git a/test/test_pyfftw_class_misc.py b/test/test_pyfftw_class_misc.py
index b8f3e62..42725fe 100644
--- a/test/test_pyfftw_class_misc.py
+++ b/test/test_pyfftw_class_misc.py
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -45,7 +45,7 @@ import warnings
# FFTW tests that don't seem to fit anywhere else
class FFTWMiscTest(unittest.TestCase):
-
+
def __init__(self, *args, **kwargs):
super(FFTWMiscTest, self).__init__(*args, **kwargs)
@@ -62,7 +62,7 @@ class FFTWMiscTest(unittest.TestCase):
self.fft = FFTW(self.input_array, self.output_array)
- self.output_array[:] = (numpy.random.randn(*self.output_array.shape)
+ self.output_array[:] = (numpy.random.randn(*self.output_array.shape)
+ 1j*numpy.random.randn(*self.output_array.shape))
def test_aligned_flag(self):
@@ -71,7 +71,7 @@ class FFTWMiscTest(unittest.TestCase):
fft = FFTW(self.input_array, self.output_array)
self.assertTrue(fft.simd_aligned)
- fft = FFTW(self.input_array, self.output_array,
+ fft = FFTW(self.input_array, self.output_array,
flags=('FFTW_UNALIGNED',))
self.assertFalse(fft.simd_aligned)
@@ -82,7 +82,7 @@ class FFTWMiscTest(unittest.TestCase):
fft = FFTW(self.input_array, self.output_array)
self.assertEqual(fft.flags, ('FFTW_MEASURE',))
- fft = FFTW(self.input_array, self.output_array,
+ fft = FFTW(self.input_array, self.output_array,
flags=('FFTW_DESTROY_INPUT', 'FFTW_UNALIGNED'))
self.assertEqual(fft.flags, ('FFTW_DESTROY_INPUT', 'FFTW_UNALIGNED'))
@@ -109,7 +109,7 @@ class FFTWMiscTest(unittest.TestCase):
'''Test to see if the alignment code is working as expected
'''
- # Start by creating arrays that are only on various byte
+ # Start by creating arrays that are only on various byte
# alignments (4, 16 and 32)
_input_array = empty_aligned(len(self.input_array.ravel())*2+5,
dtype='float32', n=32)
@@ -197,9 +197,9 @@ class FFTWMiscTest(unittest.TestCase):
else:
# This should work (and not segfault!)
- fft.update_arrays(input_arrays[update_align],
+ fft.update_arrays(input_arrays[update_align],
output_arrays[out_align])
- fft.update_arrays(input_arrays[in_align],
+ fft.update_arrays(input_arrays[in_align],
output_arrays[update_align])
fft.execute()
@@ -317,7 +317,7 @@ class FFTWMiscTest(unittest.TestCase):
'''
self.assertEqual(self.fft.direction, 'FFTW_FORWARD')
- new_fft = FFTW(self.input_array, self.output_array,
+ new_fft = FFTW(self.input_array, self.output_array,
direction='FFTW_BACKWARD')
self.assertEqual(new_fft.direction, 'FFTW_BACKWARD')
diff --git a/test/test_pyfftw_complex.py b/test/test_pyfftw_complex.py
index ef6f5d6..22505aa 100644
--- a/test/test_pyfftw_complex.py
+++ b/test/test_pyfftw_complex.py
@@ -1,6 +1,6 @@
#
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -50,16 +50,16 @@ from .test_pyfftw_base import FFTWBaseTest, run_test_suites
class Complex64FFTW1DTest(object):
def test_time(self):
-
+
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
fft, ifft = self.run_validate_fft(a, b, axes)
- self.timer_routine(fft.execute,
+ self.timer_routine(fft.execute,
lambda: self.np_fft_comparison(a))
self.assertTrue(True)
@@ -67,7 +67,7 @@ class Complex64FFTW1DTest(object):
in_shape = self.input_shapes['1d']
out_shape = self.output_shapes['1d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -86,7 +86,7 @@ class Complex64FFTW1DTest(object):
def test_multiple_1d(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -95,9 +95,9 @@ class Complex64FFTW1DTest(object):
def test_default_args(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
a, b = self.create_test_arrays(in_shape, out_shape)
-
+
fft = FFTW(a,b)
fft.execute()
ref_b = self.reference_fftn(a, axes=(-1,))
@@ -106,21 +106,21 @@ class Complex64FFTW1DTest(object):
def test_time_with_array_update(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
fft, ifft = self.run_validate_fft(a, b, axes)
-
+
def fftw_callable():
fft.update_arrays(a,b)
fft.execute()
- self.timer_routine(fftw_callable,
+ self.timer_routine(fftw_callable,
lambda: self.np_fft_comparison(a))
self.assertTrue(True)
-
+
def test_planning_time_limit(self):
in_shape = self.input_shapes['1d']
out_shape = self.output_shapes['1d']
@@ -151,7 +151,7 @@ class Complex64FFTW1DTest(object):
if sys.platform == 'win32':
# Give a 6x margin on windows. The timers are low
# precision and FFTW seems to take longer anyway.
- # Also, we need to allow for processor contention which
+ # Also, we need to allow for processor contention which
# Appveyor seems prone to.
self.assertTrue(limited_time < time_limit*6)
else:
@@ -167,27 +167,27 @@ class Complex64FFTW1DTest(object):
self.assertRaisesRegex(TypeError, 'Invalid planning timelimit',
FFTW, *(a,b, axes), **{'planning_timelimit': 'foo'})
-
+
def test_planner_flags(self):
'''Test all the planner flags on a small array
'''
in_shape = self.input_shapes['small_1d']
out_shape = self.output_shapes['small_1d']
-
+
axes=(0,)
a, b = self.create_test_arrays(in_shape, out_shape)
for each_flag in pyfftw.pyfftw._flag_dict:
if each_flag == 'FFTW_WISDOM_ONLY':
continue
- fft, ifft = self.run_validate_fft(a, b, axes,
+ fft, ifft = self.run_validate_fft(a, b, axes,
flags=(each_flag,))
self.assertTrue(each_flag in fft.flags)
self.assertTrue(each_flag in ifft.flags)
# also, test no flags (which should still work)
- fft, ifft = self.run_validate_fft(a, b, axes,
+ fft, ifft = self.run_validate_fft(a, b, axes,
flags=())
def test_wisdom_only(self):
@@ -198,20 +198,20 @@ class Complex64FFTW1DTest(object):
a, b = self.create_test_arrays(in_shape, out_shape)
forget_wisdom()
# with no wisdom, an error should be raised with FFTW_WISDOM_ONLY
- #
+ #
# NB: wisdom is specific to aligned/unaligned distinction, so we must
# ensure that the arrays don't get copied (and potentially
- # switched between aligned and unaligned) by run_validate_fft()...
- self.assertRaisesRegex(RuntimeError, 'No FFTW wisdom',
- self.run_validate_fft, *(a, b, axes),
- **{'flags':('FFTW_ESTIMATE', 'FFTW_WISDOM_ONLY'),
+ # switched between aligned and unaligned) by run_validate_fft()...
+ self.assertRaisesRegex(RuntimeError, 'No FFTW wisdom',
+ self.run_validate_fft, *(a, b, axes),
+ **{'flags':('FFTW_ESTIMATE', 'FFTW_WISDOM_ONLY'),
'create_array_copies': False})
# now plan the FFT
self.run_validate_fft(a, b, axes, flags=('FFTW_ESTIMATE',),
create_array_copies=False)
# now FFTW_WISDOM_ONLY should not raise an error because the plan should
# be in the wisdom
- self.run_validate_fft(a, b, axes, flags=('FFTW_ESTIMATE',
+ self.run_validate_fft(a, b, axes, flags=('FFTW_ESTIMATE',
'FFTW_WISDOM_ONLY'), create_array_copies=False)
def test_destroy_input(self):
@@ -226,7 +226,7 @@ class Complex64FFTW1DTest(object):
axes=(0,)
a, b = self.create_test_arrays(in_shape, out_shape)
- self.run_validate_fft(a, b, axes,
+ self.run_validate_fft(a, b, axes,
flags=('FFTW_ESTIMATE','FFTW_DESTROY_INPUT'))
def test_invalid_flag_fail(self):
@@ -238,8 +238,8 @@ class Complex64FFTW1DTest(object):
axes=(0,)
a, b = self.create_test_arrays(in_shape, out_shape)
- self.assertRaisesRegex(ValueError, 'Invalid flag',
- self.run_validate_fft, *(a, b, axes),
+ self.assertRaisesRegex(ValueError, 'Invalid flag',
+ self.run_validate_fft, *(a, b, axes),
**{'flags':('garbage',)})
def test_alignment(self):
@@ -250,14 +250,14 @@ class Complex64FFTW1DTest(object):
input_dtype_alignment = self.get_input_dtype_alignment()
output_dtype_alignment = self.get_output_dtype_alignment()
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
a = byte_align(a, n=16)
b = byte_align(b, n=16)
- fft, ifft = self.run_validate_fft(a, b, axes,
+ fft, ifft = self.run_validate_fft(a, b, axes,
force_unaligned_data=True)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -286,51 +286,51 @@ class Complex64FFTW1DTest(object):
.view(dtype=self.output_dtype).reshape(*out_shape))
b_[:] = b
- a[:] = a_orig
- fft, ifft = self.run_validate_fft(a, b, axes,
+ a[:] = a_orig
+ fft, ifft = self.run_validate_fft(a, b, axes,
create_array_copies=False)
self.assertTrue(fft.input_alignment == 16)
self.assertTrue(fft.output_alignment == 16)
a[:] = a_orig
- fft, ifft = self.run_validate_fft(a, b_, axes,
+ fft, ifft = self.run_validate_fft(a, b_, axes,
create_array_copies=False)
self.assertTrue(fft.input_alignment == input_dtype_alignment)
self.assertTrue(fft.output_alignment == output_dtype_alignment)
- a_[:] = a_orig
- fft, ifft = self.run_validate_fft(a_, b, axes,
- create_array_copies=False)
+ a_[:] = a_orig
+ fft, ifft = self.run_validate_fft(a_, b, axes,
+ create_array_copies=False)
self.assertTrue(fft.input_alignment == input_dtype_alignment)
self.assertTrue(fft.output_alignment == output_dtype_alignment)
- a_[:] = a_orig
- fft, ifft = self.run_validate_fft(a_, b_, axes,
- create_array_copies=False)
+ a_[:] = a_orig
+ fft, ifft = self.run_validate_fft(a_, b_, axes,
+ create_array_copies=False)
self.assertTrue(fft.input_alignment == input_dtype_alignment)
self.assertTrue(fft.output_alignment == output_dtype_alignment)
- a[:] = a_orig
- fft, ifft = self.run_validate_fft(a, b, axes,
+ a[:] = a_orig
+ fft, ifft = self.run_validate_fft(a, b, axes,
create_array_copies=False, force_unaligned_data=True)
self.assertTrue(fft.input_alignment == input_dtype_alignment)
self.assertTrue(fft.output_alignment == output_dtype_alignment)
-
+
def test_incorrect_byte_alignment_fails(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
input_dtype_alignment = self.get_input_dtype_alignment()
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
a = byte_align(a, n=16)
b = byte_align(b, n=16)
- fft, ifft = self.run_validate_fft(a, b, axes,
+ fft, ifft = self.run_validate_fft(a, b, axes,
force_unaligned_data=True)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -361,7 +361,7 @@ class Complex64FFTW1DTest(object):
FFTW, *(a_, b_))
def test_zero_length_fft_axis_fail(self):
-
+
in_shape = (1024, 0)
out_shape = in_shape
@@ -377,10 +377,10 @@ class Complex64FFTW1DTest(object):
_out_shape = self.output_shapes['2d']
out_shape = (_out_shape[0]+1, _out_shape[1])
-
+
axes=(0,)
a, b = self.create_test_arrays(in_shape, out_shape)
-
+
with self.assertRaisesRegex(ValueError, 'Invalid shapes'):
FFTW(a, b, axes, direction=self.direction)
@@ -388,7 +388,7 @@ class Complex64FFTW1DTest(object):
in_shape = self.input_shapes['3d']
_out_shape = self.output_shapes['3d']
out_shape = (_out_shape[0], _out_shape[1]+1, _out_shape[2])
-
+
axes=(2,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -397,19 +397,19 @@ class Complex64FFTW1DTest(object):
def test_extra_dimension_fail(self):
in_shape = self.input_shapes['2d']
- _out_shape = self.output_shapes['2d']
+ _out_shape = self.output_shapes['2d']
out_shape = (2, _out_shape[0], _out_shape[1])
-
+
axes=(1,)
a, b = self.create_test_arrays(in_shape, out_shape)
-
+
with self.assertRaisesRegex(ValueError, 'Invalid shapes'):
FFTW(a, b, direction=self.direction)
-
+
def test_f_contiguous_1d(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(0,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -422,7 +422,7 @@ class Complex64FFTW1DTest(object):
def test_different_dtypes_fail(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -435,24 +435,24 @@ class Complex64FFTW1DTest(object):
b_ = numpy.complex64(b)
self.assertRaisesRegex(ValueError, 'Invalid scheme',
FFTW, *(a_,b_))
-
+
def test_update_data(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
fft, ifft = self.run_validate_fft(a, b, axes)
a, b = self.create_test_arrays(in_shape, out_shape)
-
+
self.run_validate_fft(a, b, axes, fft=fft, ifft=ifft)
-
+
def test_with_not_ndarray_error(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
a, b = self.create_test_arrays(in_shape, out_shape)
self.assertRaisesRegex(ValueError, 'Invalid output array',
@@ -464,11 +464,11 @@ class Complex64FFTW1DTest(object):
def test_update_data_with_not_ndarray_error(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
- fft, ifft = self.run_validate_fft(a, b, axes,
+ fft, ifft = self.run_validate_fft(a, b, axes,
create_array_copies=False)
self.assertRaisesRegex(ValueError, 'Invalid output array',
@@ -480,11 +480,11 @@ class Complex64FFTW1DTest(object):
def test_update_data_with_stride_error(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
- fft, ifft = self.run_validate_fft(a, b, axes,
+ fft, ifft = self.run_validate_fft(a, b, axes,
create_array_copies=False)
# We offset by 16 to make sure the byte alignment is still correct.
@@ -497,17 +497,17 @@ class Complex64FFTW1DTest(object):
b_ = b_[16:,16:]
with self.assertRaisesRegex(ValueError, 'Invalid input striding'):
- self.run_validate_fft(a_, b, axes,
+ self.run_validate_fft(a_, b, axes,
fft=fft, ifft=ifft, create_array_copies=False)
with self.assertRaisesRegex(ValueError, 'Invalid output striding'):
- self.run_validate_fft(a, b_, axes,
+ self.run_validate_fft(a, b_, axes,
fft=fft, ifft=ifft, create_array_copies=False)
def test_update_data_with_shape_error(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -519,11 +519,11 @@ class Complex64FFTW1DTest(object):
a_, b_ = self.create_test_arrays(in_shape, out_shape)
with self.assertRaisesRegex(ValueError, 'Invalid input shape'):
- self.run_validate_fft(a_, b, axes,
+ self.run_validate_fft(a_, b, axes,
fft=fft, ifft=ifft, create_array_copies=False)
with self.assertRaisesRegex(ValueError, 'Invalid output shape'):
- self.run_validate_fft(a, b_, axes,
+ self.run_validate_fft(a, b_, axes,
fft=fft, ifft=ifft, create_array_copies=False)
def test_update_unaligned_data_with_FFTW_UNALIGNED(self):
@@ -531,14 +531,14 @@ class Complex64FFTW1DTest(object):
out_shape = self.output_shapes['2d']
input_dtype_alignment = self.get_input_dtype_alignment()
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
a = byte_align(a, n=16)
b = byte_align(b, n=16)
- fft, ifft = self.run_validate_fft(a, b, axes,
+ fft, ifft = self.run_validate_fft(a, b, axes,
force_unaligned_data=True)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -570,7 +570,7 @@ class Complex64FFTW1DTest(object):
out_shape = self.output_shapes['2d']
input_dtype_alignment = self.get_input_dtype_alignment()
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -589,10 +589,10 @@ class Complex64FFTW1DTest(object):
b_ = b__[input_dtype_alignment:].view(dtype=self.output_dtype).reshape(*out_shape)
b_[:] = b
-
- fft, ifft = self.run_validate_fft(a_, b_, axes,
+
+ fft, ifft = self.run_validate_fft(a_, b_, axes,
force_unaligned_data=True)
-
+
self.run_validate_fft(a, b_, axes, fft=fft, ifft=ifft)
self.run_validate_fft(a_, b, axes, fft=fft, ifft=ifft)
self.run_validate_fft(a_, b_, axes, fft=fft, ifft=ifft)
@@ -603,7 +603,7 @@ class Complex64FFTW1DTest(object):
out_shape = self.output_shapes['2d']
byte_error = 1
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -611,7 +611,7 @@ class Complex64FFTW1DTest(object):
b = byte_align(b, n=16)
fft, ifft = self.run_validate_fft(a, b, axes)
-
+
a, b = self.create_test_arrays(in_shape, out_shape)
# Offset from 16 byte aligned to guarantee it's not
@@ -631,31 +631,31 @@ class Complex64FFTW1DTest(object):
b_ = (b__[byte_error:]
.view(dtype=self.output_dtype).reshape(*out_shape))
b_[:] = b
-
+
with self.assertRaisesRegex(ValueError, 'Invalid output alignment'):
- self.run_validate_fft(a, b_, axes, fft=fft, ifft=ifft,
+ self.run_validate_fft(a, b_, axes, fft=fft, ifft=ifft,
create_array_copies=False)
with self.assertRaisesRegex(ValueError, 'Invalid input alignment'):
- self.run_validate_fft(a_, b, axes, fft=fft, ifft=ifft,
+ self.run_validate_fft(a_, b, axes, fft=fft, ifft=ifft,
create_array_copies=False)
# Should also be true for the unaligned case
- fft, ifft = self.run_validate_fft(a, b, axes,
+ fft, ifft = self.run_validate_fft(a, b, axes,
force_unaligned_data=True)
with self.assertRaisesRegex(ValueError, 'Invalid output alignment'):
- self.run_validate_fft(a, b_, axes, fft=fft, ifft=ifft,
+ self.run_validate_fft(a, b_, axes, fft=fft, ifft=ifft,
create_array_copies=False)
with self.assertRaisesRegex(ValueError, 'Invalid input alignment'):
- self.run_validate_fft(a_, b, axes, fft=fft, ifft=ifft,
+ self.run_validate_fft(a_, b, axes, fft=fft, ifft=ifft,
create_array_copies=False)
def test_invalid_axes(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-3,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -668,34 +668,34 @@ class Complex64FFTW1DTest(object):
class Complex64FFTWTest(Complex64FFTW1DTest, FFTWBaseTest):
-
+
def test_2d(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-2,-1)
a, b = self.create_test_arrays(in_shape, out_shape)
self.run_validate_fft(a, b, axes, create_array_copies=False)
-
+
def test_multiple_2d(self):
in_shape = self.input_shapes['3d']
out_shape = self.output_shapes['3d']
-
+
axes=(-2,-1)
a, b = self.create_test_arrays(in_shape, out_shape)
self.run_validate_fft(a, b, axes, create_array_copies=False)
-
+
def test_3d(self):
in_shape = self.input_shapes['3d']
out_shape = self.output_shapes['3d']
-
+
axes=(0, 1, 2)
a, b = self.create_test_arrays(in_shape, out_shape)
self.run_validate_fft(a, b, axes, create_array_copies=False)
-
+
def test_non_monotonic_increasing_axes(self):
'''Test the case where the axes arg does not monotonically increase.
'''
@@ -704,15 +704,15 @@ class Complex64FFTWTest(Complex64FFTW1DTest, FFTWBaseTest):
# We still need the shapes to work!
in_shape = numpy.asarray(self.input_shapes['2d'])[list(axes)]
out_shape = numpy.asarray(self.output_shapes['2d'])[list(axes)]
-
+
a, b = self.create_test_arrays(in_shape, out_shape, axes=axes)
self.run_validate_fft(a, b, axes, create_array_copies=False)
-
+
def test_non_contiguous_2d(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-2,-1)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -722,7 +722,7 @@ class Complex64FFTWTest(Complex64FFTW1DTest, FFTWBaseTest):
b_sliced = b[20:146:2, 100:1458:7]
self.run_validate_fft(a_sliced, b_sliced, axes, create_array_copies=False)
-
+
def test_non_contiguous_2d_in_3d(self):
in_shape = (256, 4, 2048)
out_shape = in_shape
@@ -738,7 +738,7 @@ class Complex64FFTWTest(Complex64FFTW1DTest, FFTWBaseTest):
class Complex128FFTWTest(Complex64FFTWTest):
-
+
def setUp(self):
self.input_dtype = numpy.complex128
@@ -749,14 +749,14 @@ class Complex128FFTWTest(Complex64FFTWTest):
return
class ComplexLongDoubleFFTWTest(Complex64FFTWTest):
-
+
def setUp(self):
self.input_dtype = numpy.clongdouble
self.output_dtype = numpy.clongdouble
self.np_fft_comparison = self.reference_fftn
- self.direction = 'FFTW_FORWARD'
+ self.direction = 'FFTW_FORWARD'
return
def reference_fftn(self, a, axes):
@@ -770,7 +770,7 @@ class ComplexLongDoubleFFTWTest(Complex64FFTWTest):
def test_time(self):
pass
- @unittest.skip('numpy.fft has issues with this dtype.')
+ @unittest.skip('numpy.fft has issues with this dtype.')
def test_time_with_array_update(self):
pass
@@ -784,4 +784,3 @@ test_set = None
if __name__ == '__main__':
run_test_suites(test_cases, test_set)
-
diff --git a/test/test_pyfftw_interfaces_cache.py b/test/test_pyfftw_interfaces_cache.py
index 65fede5..152aeb3 100644
--- a/test/test_pyfftw_interfaces_cache.py
+++ b/test/test_pyfftw_interfaces_cache.py
@@ -1,6 +1,6 @@
#
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -33,6 +33,7 @@
# POSSIBILITY OF SUCH DAMAGE.
#
+import copy
from pyfftw import interfaces, builders
import numpy
@@ -57,15 +58,17 @@ class InterfacesNumpyFFTCacheTestFFT(InterfacesNumpyFFTTestFFT):
((32, 64), {}),
)
- def validate(self, array_type, test_shape, dtype,
- s, kwargs):
+ def validate(self, array_type, test_shape, dtype,
+ s, kwargs, copy_func=copy.copy):
# Do it with the cache
- interfaces.cache.enable()
- output = self._validate(array_type, test_shape, dtype, s, kwargs)
- output2 = self._validate(array_type, test_shape, dtype, s, kwargs)
+ interfaces.cache.enable()
+ output = self._validate(array_type, test_shape, dtype, s, kwargs,
+ copy_func=copy_func)
+ output2 = self._validate(array_type, test_shape, dtype, s, kwargs,
+ copy_func=copy_func)
- self.assertIsNot(output, output2)
+ self.assertIsNot(output, output2)
# Turn it off to finish
interfaces.cache.disable()
@@ -79,7 +82,7 @@ class CacheSpecificInterfacesUtils(unittest.TestCase):
data_shape = (128,)
# Monkey patch the module with a custom _Cache object
- _Cache_class = interfaces.cache._Cache
+ _Cache_class = interfaces.cache._Cache
class _SlowLookupCache(_Cache_class):
def _lookup(self, key):
@@ -110,10 +113,10 @@ class CacheSpecificInterfacesUtils(unittest.TestCase):
finally:
# Revert the monkey patching
interfaces.cache._Cache = _Cache_class
-
+
class InterfacesCacheTest(unittest.TestCase):
-
+
def test_missing_threading(self):
self.assertIs(interfaces.cache._fftw_cache, None)
@@ -123,7 +126,7 @@ class InterfacesCacheTest(unittest.TestCase):
with self.assertRaises(ImportError):
interfaces.cache.enable()
- interfaces.cache._threading = mod_threading
+ interfaces.cache._threading = mod_threading
def test_is_enabled(self):
self.assertIs(interfaces.cache._fftw_cache, None)
@@ -165,7 +168,7 @@ class CacheTest(unittest.TestCase):
'''
# Firstly make sure we've exited any lingering threads from other
# tests.
- time.sleep(0.1)
+ time.sleep(0.1)
self.assertTrue(threading.active_count() == 1)
@@ -175,8 +178,8 @@ class CacheTest(unittest.TestCase):
parent_t = threading.Thread(target=cache_parent_thread)
parent_t.start()
-
- time.sleep(0.1)
+
+ time.sleep(0.1)
# Check it's running
self.assertTrue(threading.active_count() == 3)
@@ -196,7 +199,7 @@ class CacheTest(unittest.TestCase):
_cache = interfaces.cache._Cache()
time.sleep(0.2)
self.assertTrue(threading.active_count() == 2)
-
+
del _cache
time.sleep(0.2)
self.assertTrue(threading.active_count() == 1)
@@ -270,7 +273,7 @@ class CacheTest(unittest.TestCase):
keepalive_time = _cache.keepalive_time
if os.name == 'nt':
- # A hack to keep appveyor from falling over here. I suspect the
+ # A hack to keep appveyor from falling over here. I suspect the
# contention is too much to work properly. Either way, let's
# assume it's a windows problem for now...
time.sleep(keepalive_time * 8)
@@ -306,10 +309,10 @@ class InterfacesNumpyFFTCacheTestRFFT(InterfacesNumpyFFTCacheTestFFT):
class InterfacesNumpyFFTCacheTestIRFFT(InterfacesNumpyFFTCacheTestFFT):
func = 'irfft'
- realinv = True
+ realinv = True
class InterfacesNumpyFFTCacheTestFFT2(InterfacesNumpyFFTCacheTestFFT):
- axes_kw = 'axes'
+ axes_kw = 'axes'
func = 'ifft2'
test_shapes = (
((128, 64), {'axes': None}),
@@ -317,7 +320,7 @@ class InterfacesNumpyFFTCacheTestFFT2(InterfacesNumpyFFTCacheTestFFT):
((32, 64), {'axes': (-2, -1)}),
((4, 6, 8, 4), {'axes': (0, 3)}),
)
-
+
invalid_args = (
((100,), ((100, 200),), ValueError, 'Shape error'),
((100, 200), ((100, 200, 100),), ValueError, 'Shape error'),
@@ -335,7 +338,7 @@ class InterfacesNumpyFFTCacheTestRFFT2(InterfacesNumpyFFTCacheTestFFT2):
class InterfacesNumpyFFTCacheTestIRFFT2(InterfacesNumpyFFTCacheTestFFT2):
func = 'irfft2'
- realinv = True
+ realinv = True
class InterfacesNumpyFFTCacheTestFFTN(InterfacesNumpyFFTCacheTestFFT2):
func = 'ifftn'
diff --git a/test/test_pyfftw_multithreaded.py b/test/test_pyfftw_multithreaded.py
index 8970eac..89ba4e2 100644
--- a/test/test_pyfftw_multithreaded.py
+++ b/test/test_pyfftw_multithreaded.py
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -43,11 +43,11 @@ import unittest
from .test_pyfftw_base import FFTWBaseTest
class Complex64MultiThreadedTest(FFTWBaseTest):
-
+
def run_multithreaded_test(self, threads):
in_shape = self.input_shapes['2d'];
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -55,7 +55,7 @@ class Complex64MultiThreadedTest(FFTWBaseTest):
fft_, ifft_ = self.run_validate_fft(a, b, axes, threads=1)
- self.timer_routine(fft.execute, fft_.execute,
+ self.timer_routine(fft.execute, fft_.execute,
comparison_string='singled threaded')
self.assertTrue(True)
@@ -67,27 +67,27 @@ class Complex64MultiThreadedTest(FFTWBaseTest):
self.run_multithreaded_test(4)
def test_7_threads(self):
- self.run_multithreaded_test(7)
+ self.run_multithreaded_test(7)
def test_25_threads(self):
- self.run_multithreaded_test(25)
+ self.run_multithreaded_test(25)
class Complex128MultiThreadedTest(Complex64MultiThreadedTest):
-
+
def setUp(self):
self.input_dtype = numpy.complex128
self.output_dtype = numpy.complex128
- self.np_fft_comparison = numpy.fft.fft
+ self.np_fft_comparison = numpy.fft.fft
return
class ComplexLongDoubleMultiThreadedTest(Complex64MultiThreadedTest):
-
+
def setUp(self):
self.input_dtype = numpy.clongdouble
self.output_dtype = numpy.clongdouble
- self.np_fft_comparison = self.reference_fftn
+ self.np_fft_comparison = self.reference_fftn
return
def reference_fftn(self, a, axes):
diff --git a/test/test_pyfftw_numpy_interface.py b/test/test_pyfftw_numpy_interface.py
index 3a501a6..3207a89 100644
--- a/test/test_pyfftw_numpy_interface.py
+++ b/test/test_pyfftw_numpy_interface.py
@@ -1,5 +1,5 @@
# Copyright 2015 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -37,6 +37,7 @@ from pyfftw import interfaces
from .test_pyfftw_base import run_test_suites
from ._get_default_args import get_default_args
+from distutils.version import LooseVersion
import unittest
import numpy
from numpy import fft as np_fft
@@ -44,7 +45,7 @@ import warnings
import copy
warnings.filterwarnings('always')
-if numpy.version.version <= '1.6.2':
+if LooseVersion(numpy.version.version) <= LooseVersion('1.6.2'):
# We overwrite the broken _cook_nd_args with a fixed version.
from ._cook_nd_args import _cook_nd_args
numpy.fft.fftpack._cook_nd_args = _cook_nd_args
@@ -59,10 +60,21 @@ def make_complex_data(shape, dtype):
def make_real_data(shape, dtype):
return dtype(numpy.random.randn(*shape))
+def _numpy_fft_has_norm_kwarg():
+ """returns True if numpy's fft supports the norm keyword argument
+
+ This should be true for numpy >= 1.10
+ """
+ # return LooseVersion(numpy.version.version) >= LooseVersion('1.10')
+ try:
+ np_fft.fft(numpy.ones(4), norm=None)
+ return True
+ except TypeError:
+ return False
functions = {
'fft': 'complex',
- 'ifft': 'complex',
+ 'ifft': 'complex',
'rfft': 'r2c',
'irfft': 'c2r',
'rfftn': 'r2c',
@@ -111,8 +123,9 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
((128, 32), {'axis': -1}),
((59, 100), {}),
((59, 99), {'axis': -1}),
- ((59, 99), {'axis': 0}),
+ ((59, 99), {'axis': 0}),
((32, 32, 4), {'axis': 1}),
+ ((32, 32, 2), {'axis': 1, 'norm': 'ortho'}),
((64, 128, 16), {}),
)
@@ -125,6 +138,7 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
((100,), (100, -20), IndexError, ''))
realinv = False
+ has_norm_kwarg = _numpy_fft_has_norm_kwarg()
@property
def test_data(self):
@@ -132,6 +146,9 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
axes = self.axes_from_kwargs(kwargs)
s = self.s_from_kwargs(test_shape, kwargs)
+ if not self.has_norm_kwarg and 'norm' in kwargs:
+ kwargs.pop('norm')
+
if self.realinv:
test_shape = list(test_shape)
test_shape[axes[-1]] = test_shape[axes[-1]]//2 + 1
@@ -147,28 +164,29 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
if not hasattr(self, 'assertRaisesRegex'):
self.assertRaisesRegex = self.assertRaisesRegexp
- def validate(self, array_type, test_shape, dtype,
- s, kwargs):
+ def validate(self, array_type, test_shape, dtype,
+ s, kwargs, copy_func=copy.copy):
# Do it without the cache
# without:
interfaces.cache.disable()
- self._validate(array_type, test_shape, dtype, s, kwargs)
+ self._validate(array_type, test_shape, dtype, s, kwargs,
+ copy_func=copy_func)
def munge_input_array(self, array, kwargs):
return array
- def _validate(self, array_type, test_shape, dtype,
- s, kwargs):
+ def _validate(self, array_type, test_shape, dtype,
+ s, kwargs, copy_func=copy.copy):
input_array = self.munge_input_array(
array_type(test_shape, dtype), kwargs)
- orig_input_array = copy.copy(input_array)
+ orig_input_array = copy_func(input_array)
np_input_array = numpy.asarray(input_array)
-
+
if np_input_array.dtype == 'clongdouble':
np_input_array = numpy.complex128(input_array)
@@ -181,21 +199,24 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
# a complex array is turned into a real array
if 'axes' in kwargs:
- axes = {'axes': kwargs['axes']}
+ validator_kwargs = {'axes': kwargs['axes']}
elif 'axis' in kwargs:
- axes = {'axis': kwargs['axis']}
+ validator_kwargs = {'axis': kwargs['axis']}
else:
- axes = {}
+ validator_kwargs = {}
+
+ if self.has_norm_kwarg and 'norm' in kwargs:
+ validator_kwargs['norm'] = kwargs['norm']
try:
test_out_array = getattr(self.validator_module, self.func)(
- copy.copy(np_input_array), s, **axes)
+ copy_func(np_input_array), s, **validator_kwargs)
except Exception as e:
interface_exception = None
try:
getattr(self.test_interface, self.func)(
- copy.copy(input_array), s, **kwargs)
+ copy_func(input_array), s, **kwargs)
except Exception as _interface_exception:
# It's necessary to assign the exception to the
# already defined variable in Python 3.
@@ -204,12 +225,12 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
# If the test interface raised, so must this.
self.assertEqual(type(interface_exception), type(e),
- msg='Interface exception raised. ' +
+ msg='Interface exception raised. ' +
'Testing for: ' + repr(e))
return
output_array = getattr(self.test_interface, self.func)(
- copy.copy(input_array), s, **kwargs)
+ copy_func(input_array), s, **kwargs)
if (functions[self.func] == 'r2c'):
if numpy.iscomplexobj(input_array):
@@ -217,17 +238,17 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
# Make sure a warning is raised
self.assertIs(
w[-1].category, numpy.ComplexWarning)
-
+
self.assertTrue(
- numpy.allclose(output_array, test_out_array,
+ numpy.allclose(output_array, test_out_array,
rtol=1e-2, atol=1e-4))
input_precision_dtype = numpy.asanyarray(input_array).real.dtype
- self.assertEqual(input_precision_dtype,
+ self.assertEqual(input_precision_dtype,
output_array.real.dtype)
- if (not self.overwrite_input_flag in kwargs or
+ if (not self.overwrite_input_flag in kwargs or
not kwargs[self.overwrite_input_flag]):
self.assertTrue(numpy.allclose(input_array,
orig_input_array))
@@ -307,38 +328,42 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
def test_valid(self):
dtype_tuple = self.io_dtypes[functions[self.func]]
-
+
for dtype in dtype_tuple[0]:
for test_shape, s, kwargs in self.test_data:
s = None
- self.validate(dtype_tuple[1],
+ self.validate(dtype_tuple[1],
test_shape, dtype, s, kwargs)
def test_on_non_numpy_array(self):
dtype_tuple = self.io_dtypes[functions[self.func]]
-
- array_type = (lambda test_shape, dtype:
+
+ array_type = (lambda test_shape, dtype:
dtype_tuple[1](test_shape, dtype).tolist())
for dtype in dtype_tuple[0]:
for test_shape, s, kwargs in self.test_data:
s = None
- self.validate(array_type,
+ self.validate(array_type,
test_shape, dtype, s, kwargs)
- def test_fail_on_invalid_s_or_axes(self):
+ def test_fail_on_invalid_s_or_axes_or_norm(self):
dtype_tuple = self.io_dtypes[functions[self.func]]
-
+
for dtype in dtype_tuple[0]:
for test_shape, args, exception, e_str in self.invalid_args:
input_array = dtype_tuple[1](test_shape, dtype)
-
+
+ if len(args) > 2 and not self.has_norm_kwarg:
+ # skip tests invovling norm argument if it isn't available
+ continue
+
self.assertRaisesRegex(exception, e_str,
- getattr(self.test_interface, self.func),
+ getattr(self.test_interface, self.func),
*((input_array,) + args))
@@ -347,7 +372,7 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
for dtype in dtype_tuple[0]:
for test_shape, s, kwargs in self.test_data:
- self.validate(dtype_tuple[1],
+ self.validate(dtype_tuple[1],
test_shape, dtype, s, kwargs)
def test_bigger_s(self):
@@ -361,7 +386,7 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
except TypeError:
s += 2
- self.validate(dtype_tuple[1],
+ self.validate(dtype_tuple[1],
test_shape, dtype, s, kwargs)
@@ -376,10 +401,10 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
except TypeError:
s -= 2
- self.validate(dtype_tuple[1],
+ self.validate(dtype_tuple[1],
test_shape, dtype, s, kwargs)
- def check_arg(self, arg, arg_test_values, array_type, test_shape,
+ def check_arg(self, arg, arg_test_values, array_type, test_shape,
dtype, s, kwargs):
'''Check that the correct arg is passed to the builder'''
# We trust the builders to work as expected when passed
@@ -404,19 +429,19 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
_kwargs[arg] = each_value
builder_args = getattr(self.test_interface, self.func)(
input_array.copy(), s, **_kwargs)
-
+
self.assertTrue(builder_args[1][arg] == each_value)
# make sure it was called
self.assertTrue(len(return_values) > 0)
except:
raise
-
+
finally:
# Make sure we set it back
setattr(self.test_interface, self.func, real_fft)
- # Validate it aswell
+ # Validate it aswell
for each_value in arg_test_values:
_kwargs[arg] = each_value
builder_args = getattr(self.test_interface, self.func)(
@@ -437,7 +462,7 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
for dtype in dtype_tuple[0]:
for test_shape, s, kwargs in self.test_data:
- self.check_arg('auto_contiguous', (True, False),
+ self.check_arg('auto_contiguous', (True, False),
dtype_tuple[1], test_shape, dtype, s, kwargs)
def test_bigger_and_smaller_s(self):
@@ -454,7 +479,7 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
s += i * 2
i *= i
- self.validate(dtype_tuple[1],
+ self.validate(dtype_tuple[1],
test_shape, dtype, s, kwargs)
@@ -469,7 +494,7 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
for test_shape, s, kwargs in self.test_data:
s = None
- self.validate(dtype_tuple[1],
+ self.validate(dtype_tuple[1],
test_shape, dtype, s, kwargs)
@@ -478,7 +503,7 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
'''
dtype_tuple = self.io_dtypes[functions[self.func]]
test_shape = (16,)
-
+
for dtype in dtype_tuple[0]:
s = None
if self.axes_kw == 'axis':
@@ -486,18 +511,18 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
else:
kwargs = {'axes': (-1,)}
- for each_effort in ('FFTW_ESTIMATE', 'FFTW_MEASURE',
+ for each_effort in ('FFTW_ESTIMATE', 'FFTW_MEASURE',
'FFTW_PATIENT', 'FFTW_EXHAUSTIVE'):
-
+
kwargs['planner_effort'] = each_effort
-
+
self.validate(
dtype_tuple[1], test_shape, dtype, s, kwargs)
kwargs['planner_effort'] = 'garbage'
self.assertRaisesRegex(ValueError, 'Invalid planner effort',
- self.validate,
+ self.validate,
*(dtype_tuple[1], test_shape, dtype, s, kwargs))
def test_threads_arg(self):
@@ -505,7 +530,7 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
'''
dtype_tuple = self.io_dtypes[functions[self.func]]
test_shape = (16,)
-
+
for dtype in dtype_tuple[0]:
s = None
if self.axes_kw == 'axis':
@@ -513,14 +538,14 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
else:
kwargs = {'axes': (-1,)}
- self.check_arg('threads', (1, 2, 5, 10),
+ self.check_arg('threads', (1, 2, 5, 10),
dtype_tuple[1], test_shape, dtype, s, kwargs)
kwargs['threads'] = 'bleh'
-
+
# Should not work
self.assertRaises(TypeError,
- self.validate,
+ self.validate,
*(dtype_tuple[1], test_shape, dtype, s, kwargs))
@@ -528,14 +553,14 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
'''Test the overwrite_input flag
'''
dtype_tuple = self.io_dtypes[functions[self.func]]
-
+
for dtype in dtype_tuple[0]:
for test_shape, s, _kwargs in self.test_data:
s = None
kwargs = _kwargs.copy()
self.validate(dtype_tuple[1], test_shape, dtype, s, kwargs)
-
+
self.check_arg(self.overwrite_input_flag, (True, False),
dtype_tuple[1], test_shape, dtype, s, kwargs)
@@ -549,50 +574,94 @@ class InterfacesNumpyFFTTestFFT(unittest.TestCase):
input_array = dtype_tuple[1](test_shape, dtype)
orig_input_array = input_array.copy()
-
+
getattr(self.test_interface, self.func)(
input_array, s, **kwargs)
self.assertTrue(
numpy.alltrue(input_array == orig_input_array))
+ def test_on_non_writeable_array_issue_92(self):
+ '''Test to make sure that locked arrays work.
+
+ Regression test for issue 92.
+ '''
+ def copy_with_writeable(array_to_copy):
+ array_copy = array_to_copy.copy()
+ array_copy.flags.writeable = array_to_copy.flags.writeable
+ return array_copy
+
+ dtype_tuple = self.io_dtypes[functions[self.func]]
+
+ def array_type(test_shape, dtype):
+ a = dtype_tuple[1](test_shape, dtype)
+ a.flags.writeable = False
+ return a
+
+ for dtype in dtype_tuple[0]:
+ for test_shape, s, kwargs in self.test_data:
+ s = None
+
+ self.validate(array_type,
+ test_shape, dtype, s, kwargs,
+ copy_func=copy_with_writeable)
+
+ def test_overwrite_input_for_issue_92(self):
+ '''Tests that trying to overwrite a locked array fails.
+ '''
+ a = numpy.zeros((4,))
+ a.flags.writeable = False
+ self.assertRaisesRegex(
+ ValueError,
+ 'overwrite_input cannot be True when the ' +
+ 'input array flags.writeable is False',
+ interfaces.numpy_fft.fft,
+ a, overwrite_input=True)
+
class InterfacesNumpyFFTTestIFFT(InterfacesNumpyFFTTestFFT):
func = 'ifft'
class InterfacesNumpyFFTTestRFFT(InterfacesNumpyFFTTestFFT):
func = 'rfft'
+ has_norm_kwarg = False
class InterfacesNumpyFFTTestIRFFT(InterfacesNumpyFFTTestFFT):
func = 'irfft'
realinv = True
+ has_norm_kwarg = False
class InterfacesNumpyFFTTestHFFT(InterfacesNumpyFFTTestFFT):
func = 'hfft'
realinv = True
+ has_norm_kwarg = False
class InterfacesNumpyFFTTestIHFFT(InterfacesNumpyFFTTestFFT):
func = 'ihfft'
+ has_norm_kwarg = False
class InterfacesNumpyFFTTestFFT2(InterfacesNumpyFFTTestFFT):
- axes_kw = 'axes'
+ axes_kw = 'axes'
func = 'ifft2'
test_shapes = (
((128, 64), {'axes': None}),
((128, 32), {'axes': None}),
((128, 32, 4), {'axes': (0, 2)}),
((59, 100), {'axes': (-2, -1)}),
+ ((32, 32), {'axes': (-2, -1), 'norm': 'ortho'}),
((64, 128, 16), {'axes': (0, 2)}),
((4, 6, 8, 4), {'axes': (0, 3)}),
)
-
+
invalid_args = (
((100,), ((100, 200),), ValueError, 'Shape error'),
((100, 200), ((100, 200, 100),), ValueError, 'Shape error'),
((100,), ((100, 200), (-3, -2, -1)), ValueError, 'Shape error'),
((100, 200), (100, -1), TypeError, ''),
((100, 200), ((100, 200), (-3, -2)), IndexError, 'Invalid axes'),
- ((100, 200), ((100,), (-3,)), IndexError, 'Invalid axes'))
+ ((100, 200), ((100,), (-3,)), IndexError, 'Invalid axes'),
+ # pass invalid normalisation string
+ ((100, 200), ((100,), (-3,), 'invalid_norm'), ValueError, ''))
def test_shape_and_s_different_lengths(self):
dtype_tuple = self.io_dtypes[functions[self.func]]
@@ -605,7 +674,7 @@ class InterfacesNumpyFFTTestFFT2(InterfacesNumpyFFTTestFFT):
self.skipTest('Not meaningful test on 1d arrays.')
del kwargs['axes']
- self.validate(dtype_tuple[1],
+ self.validate(dtype_tuple[1],
test_shape, dtype, s, kwargs)
@@ -614,10 +683,12 @@ class InterfacesNumpyFFTTestIFFT2(InterfacesNumpyFFTTestFFT2):
class InterfacesNumpyFFTTestRFFT2(InterfacesNumpyFFTTestFFT2):
func = 'rfft2'
+ has_norm_kwarg = False
class InterfacesNumpyFFTTestIRFFT2(InterfacesNumpyFFTTestFFT2):
func = 'irfft2'
- realinv = True
+ realinv = True
+ has_norm_kwarg = False
class InterfacesNumpyFFTTestFFTN(InterfacesNumpyFFTTestFFT2):
func = 'ifftn'
@@ -625,6 +696,7 @@ class InterfacesNumpyFFTTestFFTN(InterfacesNumpyFFTTestFFT2):
((128, 32, 4), {'axes': None}),
((64, 128, 16), {'axes': (0, 1, 2)}),
((4, 6, 8, 4), {'axes': (0, 3, 1)}),
+ ((4, 6, 4, 4), {'axes': (0, 3, 1), 'norm': 'ortho'}),
((4, 6, 8, 4), {'axes': (0, 3, 1, 2)}),
)
@@ -633,10 +705,12 @@ class InterfacesNumpyFFTTestIFFTN(InterfacesNumpyFFTTestFFTN):
class InterfacesNumpyFFTTestRFFTN(InterfacesNumpyFFTTestFFTN):
func = 'rfftn'
+ has_norm_kwarg = False
class InterfacesNumpyFFTTestIRFFTN(InterfacesNumpyFFTTestFFTN):
func = 'irfftn'
- realinv = True
+ realinv = True
+ has_norm_kwarg = False
test_cases = (
InterfacesNumpyFFTTestModule,
diff --git a/test/test_pyfftw_real_backward.py b/test/test_pyfftw_real_backward.py
index 2db26f1..46d8521 100644
--- a/test/test_pyfftw_real_backward.py
+++ b/test/test_pyfftw_real_backward.py
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -45,7 +45,7 @@ import unittest
from .test_pyfftw_complex import Complex64FFTWTest
class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
-
+
def setUp(self):
self.input_dtype = numpy.complex128
@@ -53,7 +53,7 @@ class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
self.np_fft_comparison = numpy.fft.irfft
self.direction = 'FFTW_BACKWARD'
-
+
def make_shapes(self):
self.input_shapes = {
@@ -71,24 +71,24 @@ class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
def test_invalid_args_raise(self):
in_shape = self.input_shapes['1d']
out_shape = self.output_shapes['1d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
# Note "thread" is incorrect, it should be "threads"
- self.assertRaises(TypeError, FFTW, a, b, axes,
+ self.assertRaises(TypeError, FFTW, a, b, axes,
direction='FFTW_BACKWARD', thread=4)
def create_test_arrays(self, input_shape, output_shape, axes=None):
a = self.input_dtype(numpy.random.randn(*input_shape)
+1j*numpy.random.randn(*input_shape))
-
+
b = self.output_dtype(numpy.random.randn(*output_shape))
# We fill a by doing the forward FFT from b.
# This means that the relevant bits that should be purely
- # real will be (for example the zero freq component).
+ # real will be (for example the zero freq component).
# This is easier than writing a complicate system to work it out.
try:
if axes == None:
@@ -97,9 +97,9 @@ class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
fft = FFTW(b,a,direction='FFTW_FORWARD', axes=axes)
b[:] = self.output_dtype(numpy.random.randn(*output_shape))
-
+
fft.execute()
-
+
scaling = numpy.prod(numpy.array(a.shape))
a = self.input_dtype(a/scaling)
@@ -109,15 +109,15 @@ class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
pass
b = self.output_dtype(numpy.random.randn(*output_shape))
-
+
return a, b
- def run_validate_fft(self, a, b, axes, fft=None, ifft=None,
+ def run_validate_fft(self, a, b, axes, fft=None, ifft=None,
force_unaligned_data=False, create_array_copies=True,
threads=1, flags=('FFTW_ESTIMATE',)):
''' *** EVERYTHING IS FLIPPED AROUND BECAUSE WE ARE
VALIDATING AN INVERSE FFT ***
-
+
Run a validation of the FFTW routines for the passed pair
of arrays, a and b, and the axes argument.
@@ -171,7 +171,7 @@ class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
# sometimes fails. I assume that numpy.fft has different internals
# to fftw.
self.assertTrue(numpy.allclose(b/scaling, ref_b, rtol=1e-2, atol=1e-3))
-
+
# Test the FFT by comparing the result to the starting
# value (which is scaled as per FFTW being unnormalised).
fft.execute()
@@ -182,7 +182,7 @@ class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
def test_time_with_array_update(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -192,19 +192,19 @@ class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
fft.update_arrays(b,a)
fft.execute()
- self.timer_routine(fftw_callable,
+ self.timer_routine(fftw_callable,
lambda: self.np_fft_comparison(a))
self.assertTrue(True)
-
+
def reference_fftn(self, a, axes):
# This needs to be an inverse
return numpy.fft.irfftn(a, axes=axes)
-
+
def test_wrong_direction_fail(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -259,9 +259,9 @@ class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
def test_default_args(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
a, b = self.create_test_arrays(in_shape, out_shape)
-
+
# default args should fail for backwards transforms
# (as the default is FFTW_FORWARD)
with self.assertRaisesRegex(ValueError, 'Invalid direction'):
@@ -270,7 +270,7 @@ class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
def test_non_contiguous_2d(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-2,-1)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -291,40 +291,40 @@ class RealBackwardDoubleFFTWTest(Complex64FFTWTest):
a_sliced = a[20:146:2, :, 100:786:7]
# b needs to be compatible
b_sliced = b[12:200:3, :, 300:2041:9]
-
- # The data doesn't work, so we need to generate it for the
+
+ # The data doesn't work, so we need to generate it for the
# correct size
a_, b_ = self.create_test_arrays(a_sliced.shape, b_sliced.shape, axes=axes)
# And then copy it into the non contiguous array
a_sliced[:] = a_
b_sliced[:] = b_
-
+
self.run_validate_fft(a_sliced, b_sliced, axes, create_array_copies=False)
def test_non_monotonic_increasing_axes(self):
- super(RealBackwardDoubleFFTWTest,
+ super(RealBackwardDoubleFFTWTest,
self).test_non_monotonic_increasing_axes()
class RealBackwardSingleFFTWTest(RealBackwardDoubleFFTWTest):
-
+
def setUp(self):
self.input_dtype = numpy.complex64
- self.output_dtype = numpy.float32
+ self.output_dtype = numpy.float32
self.np_fft_comparison = numpy.fft.irfft
- self.direction = 'FFTW_BACKWARD'
+ self.direction = 'FFTW_BACKWARD'
class RealBackwardLongDoubleFFTWTest(RealBackwardDoubleFFTWTest):
-
+
def setUp(self):
self.input_dtype = numpy.clongdouble
- self.output_dtype = numpy.longdouble
+ self.output_dtype = numpy.longdouble
self.np_fft_comparison = numpy.fft.irfft
- self.direction = 'FFTW_BACKWARD'
+ self.direction = 'FFTW_BACKWARD'
def reference_fftn(self, a, axes):
@@ -335,7 +335,7 @@ class RealBackwardLongDoubleFFTWTest(RealBackwardDoubleFFTWTest):
def test_time(self):
pass
- @unittest.skip('numpy.fft has issues with this dtype.')
+ @unittest.skip('numpy.fft has issues with this dtype.')
def test_time_with_array_update(self):
pass
diff --git a/test/test_pyfftw_real_forward.py b/test/test_pyfftw_real_forward.py
index c2462d7..fc3e4fc 100644
--- a/test/test_pyfftw_real_forward.py
+++ b/test/test_pyfftw_real_forward.py
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -43,15 +43,15 @@ import unittest
from .test_pyfftw_complex import Complex64FFTWTest
class RealForwardDoubleFFTWTest(Complex64FFTWTest):
-
+
def setUp(self):
self.input_dtype = numpy.float64
- self.output_dtype = numpy.complex128
+ self.output_dtype = numpy.complex128
self.np_fft_comparison = numpy.fft.rfft
self.direction = 'FFTW_FORWARD'
-
+
def make_shapes(self):
self.input_shapes = {
'small_1d': (16,),
@@ -72,15 +72,15 @@ class RealForwardDoubleFFTWTest(Complex64FFTWTest):
+1j*numpy.random.randn(*output_shape))
return a, b
-
+
def reference_fftn(self, a, axes):
return numpy.fft.rfftn(a, axes=axes)
-
+
def test_wrong_direction_fail(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-1,)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -90,7 +90,7 @@ class RealForwardDoubleFFTWTest(Complex64FFTWTest):
def test_non_contiguous_2d(self):
in_shape = self.input_shapes['2d']
out_shape = self.output_shapes['2d']
-
+
axes=(-2,-1)
a, b = self.create_test_arrays(in_shape, out_shape)
@@ -115,21 +115,21 @@ class RealForwardDoubleFFTWTest(Complex64FFTWTest):
self.run_validate_fft(a_sliced, b_sliced, axes, create_array_copies=False)
class RealForwardSingleFFTWTest(RealForwardDoubleFFTWTest):
-
+
def setUp(self):
self.input_dtype = numpy.float32
self.output_dtype = numpy.complex64
- self.np_fft_comparison = numpy.fft.rfft
-
+ self.np_fft_comparison = numpy.fft.rfft
+
self.direction = 'FFTW_FORWARD'
class RealForwardLongDoubleFFTWTest(RealForwardDoubleFFTWTest):
-
+
def setUp(self):
self.input_dtype = numpy.longdouble
- self.output_dtype = numpy.clongdouble
+ self.output_dtype = numpy.clongdouble
self.np_fft_comparison = numpy.fft.rfft
self.direction = 'FFTW_FORWARD'
@@ -138,7 +138,7 @@ class RealForwardLongDoubleFFTWTest(RealForwardDoubleFFTWTest):
def test_time(self):
pass
- @unittest.skip('numpy.fft has issues with this dtype.')
+ @unittest.skip('numpy.fft has issues with this dtype.')
def test_time_with_array_update(self):
pass
diff --git a/test/test_pyfftw_scipy_interface.py b/test/test_pyfftw_scipy_interface.py
index 931889d..9c2d24e 100644
--- a/test/test_pyfftw_scipy_interface.py
+++ b/test/test_pyfftw_scipy_interface.py
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -56,12 +56,12 @@ from . import test_pyfftw_numpy_interface
All the tests here just check that the call is made correctly.
'''
-funcs = ('fft','ifft', 'fft2', 'ifft2', 'fftn', 'ifftn',
+funcs = ('fft','ifft', 'fft2', 'ifft2', 'fftn', 'ifftn',
'rfft', 'irfft')
-acquired_names = ('dct', 'idct', 'diff', 'tilbert', 'itilbert', 'hilbert',
- 'ihilbert', 'cs_diff', 'sc_diff', 'ss_diff', 'cc_diff', 'shift',
- 'fftshift', 'ifftshift', 'fftfreq', 'rfftfreq', 'convolve',
+acquired_names = ('dct', 'idct', 'diff', 'tilbert', 'itilbert', 'hilbert',
+ 'ihilbert', 'cs_diff', 'sc_diff', 'ss_diff', 'cc_diff', 'shift',
+ 'fftshift', 'ifftshift', 'fftfreq', 'rfftfreq', 'convolve',
'_fftpack')
def make_complex_data(shape, dtype):
@@ -79,10 +79,10 @@ make_complex_data = test_pyfftw_numpy_interface.make_complex_data
complex_dtypes = test_pyfftw_numpy_interface.complex_dtypes
real_dtypes = test_pyfftw_numpy_interface.real_dtypes
-def numpy_fft_replacement(a, s, axes, overwrite_input, planner_effort,
+def numpy_fft_replacement(a, s, axes, overwrite_input, planner_effort,
threads, auto_align_input, auto_contiguous):
- return (a, s, axes, overwrite_input, planner_effort,
+ return (a, s, axes, overwrite_input, planner_effort,
threads, auto_align_input, auto_contiguous)
io_dtypes = {
@@ -97,29 +97,46 @@ class InterfacesScipyFFTPackTestSimple(unittest.TestCase):
'''
def test_scipy_overwrite(self):
- scipy_fftn = scipy.signal.signaltools.fftn
- scipy_ifftn = scipy.signal.signaltools.ifftn
+
+ new_style_scipy_fftn = False
+ try:
+ scipy_fftn = scipy.signal.signaltools.fftn
+ scipy_ifftn = scipy.signal.signaltools.ifftn
+ except AttributeError:
+ scipy_fftn = scipy.fftpack.fftn
+ scipy_ifftn = scipy.fftpack.ifftn
+ new_style_scipy_fftn = True
a = pyfftw.empty_aligned((128, 64), dtype='complex128', n=16)
b = pyfftw.empty_aligned((128, 64), dtype='complex128', n=16)
- a[:] = (numpy.random.randn(*a.shape) +
+ a[:] = (numpy.random.randn(*a.shape) +
1j*numpy.random.randn(*a.shape))
- b[:] = (numpy.random.randn(*b.shape) +
+ b[:] = (numpy.random.randn(*b.shape) +
1j*numpy.random.randn(*b.shape))
scipy_c = scipy.signal.fftconvolve(a, b)
- scipy.signal.signaltools.fftn = scipy_fftpack.fftn
- scipy.signal.signaltools.ifftn = scipy_fftpack.ifftn
+ if new_style_scipy_fftn:
+ scipy.fftpack.fftn = scipy_fftpack.fftn
+ scipy.fftpack.ifftn = scipy_fftpack.ifftn
+
+ else:
+ scipy.signal.signaltools.fftn = scipy_fftpack.fftn
+ scipy.signal.signaltools.ifftn = scipy_fftpack.ifftn
scipy_replaced_c = scipy.signal.fftconvolve(a, b)
self.assertTrue(numpy.allclose(scipy_c, scipy_replaced_c))
- scipy.signal.signaltools.fftn = scipy_fftn
- scipy.signal.signaltools.ifftn = scipy_ifftn
+ if new_style_scipy_fftn:
+ scipy.fftpack.fftn = scipy_fftn
+ scipy.fftpack.ifftn = scipy_ifftn
+
+ else:
+ scipy.signal.signaltools.fftn = scipy_fftn
+ scipy.signal.signaltools.ifftn = scipy_ifftn
def test_funcs(self):
@@ -134,7 +151,7 @@ class InterfacesScipyFFTPackTestSimple(unittest.TestCase):
args = tuple(args)
try:
- setattr(scipy_fftpack, each_func,
+ setattr(scipy_fftpack, each_func,
numpy_fft_replacement)
return_args = getattr(scipy_fftpack, each_func)(*args)
@@ -146,11 +163,11 @@ class InterfacesScipyFFTPackTestSimple(unittest.TestCase):
raise
finally:
- setattr(scipy_fftpack, each_func,
+ setattr(scipy_fftpack, each_func,
func_being_replaced)
def test_acquired_names(self):
- for each_name in acquired_names:
+ for each_name in acquired_names:
fftpack_attr = getattr(scipy.fftpack, each_name)
acquired_attr = getattr(scipy_fftpack, each_name)
@@ -167,7 +184,7 @@ for each_func in funcs:
parent_class_name = 'InterfacesNumpyFFTTest' + each_func.upper()
parent_class = getattr(test_pyfftw_numpy_interface, parent_class_name)
- class_dict = {'validator_module': scipy.fftpack,
+ class_dict = {'validator_module': scipy.fftpack,
'test_interface': scipy_fftpack,
'io_dtypes': io_dtypes,
'overwrite_input_flag': 'overwrite_x',
@@ -176,6 +193,9 @@ for each_func in funcs:
globals()[class_name] = type(class_name,
(parent_class,), class_dict)
+ # unlike numpy, none of the scipy functions support the norm kwarg
+ globals()[class_name].has_norm_kwarg = False
+
built_classes.append(globals()[class_name])
built_classes = tuple(built_classes)
diff --git a/test/test_pyfftw_utils.py b/test/test_pyfftw_utils.py
index 9013c5d..60673c6 100644
--- a/test/test_pyfftw_utils.py
+++ b/test/test_pyfftw_utils.py
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -41,7 +41,7 @@ import platform
import os
def get_cpus_info():
-
+
if 'Linux' in platform.system():
# A simple /proc/cpuinfo parser
with open(os.path.join('/', 'proc','cpuinfo'), 'r') as f:
@@ -72,14 +72,14 @@ class UtilsTest(unittest.TestCase):
return
def tearDown(self):
-
+
return
-
+
@unittest.skipIf('Linux' not in platform.system(),
'Skipping as we only have it set up for Linux at present.')
def test_get_alignment(self):
cpus_info = get_cpus_info()
-
+
for each_cpu in cpus_info:
if 'avx' in each_cpu['flags']:
self.assertTrue(pyfftw.simd_alignment == 32)
@@ -96,4 +96,3 @@ test_set = None
if __name__ == '__main__':
run_test_suites(test_cases, test_set)
-
diff --git a/test/test_pyfftw_wisdom.py b/test/test_pyfftw_wisdom.py
index 7df0342..939bf43 100644
--- a/test/test_pyfftw_wisdom.py
+++ b/test/test_pyfftw_wisdom.py
@@ -1,5 +1,5 @@
# Copyright 2014 Knowledge Economy Developments Ltd
-#
+#
# Henry Gomersall
# heng at kedevelopments.co.uk
#
@@ -44,9 +44,9 @@ import pickle
import unittest
class FFTWWisdomTest(unittest.TestCase):
-
+
def generate_wisdom(self):
- for each_dtype in (numpy.complex128, numpy.complex64,
+ for each_dtype in (numpy.complex128, numpy.complex64,
numpy.clongdouble):
a = empty_aligned((1,1024), each_dtype, n=16)
@@ -66,7 +66,7 @@ class FFTWWisdomTest(unittest.TestCase):
for n in range(0,2):
self.assertNotEqual(before_wisdom[n], after_wisdom[n])
-
+
def test_import(self):
forget_wisdom()
@@ -94,4 +94,3 @@ test_set = None
if __name__ == '__main__':
run_test_suites(test_cases, test_set)
-
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/pyfftw.git
More information about the debian-science-commits
mailing list