+0001: # cython: language_level=3

  __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_4) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 0002: #

 0003: # Copyright 2015 Knowledge Economy Developments Ltd

 0004: # Copyright 2014 David Wells

 0005: 

 0006: # Henry Gomersall

 0007: # heng@kedevelopments.co.uk

 0008: #

 0009: # All rights reserved.

 0010: #

 0011: # Redistribution and use in source and binary forms, with or without

 0012: # modification, are permitted provided that the following conditions are met:

 0013: #

 0014: # * Redistributions of source code must retain the above copyright notice, this

 0015: # list of conditions and the following disclaimer.

 0016: #

 0017: # * Redistributions in binary form must reproduce the above copyright notice,

 0018: # this list of conditions and the following disclaimer in the documentation

 0019: # and/or other materials provided with the distribution.

 0020: #

 0021: # * Neither the name of the copyright holder nor the names of its contributors

 0022: # may be used to endorse or promote products derived from this software without

 0023: # specific prior written permission.

 0024: #

 0025: # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 0026: # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 0027: # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 0028: # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

 0029: # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 0030: # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 0031: # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 0032: # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 0033: # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 0034: # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 0035: # POSSIBILITY OF SUCH DAMAGE.

 0036: #

+0037: import numpy as np

  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 37, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 0038: cimport numpy as np

 0039: from libc.stdlib cimport calloc, malloc, free

 0040: from libc.stdint cimport intptr_t, int64_t

 0041: from libc cimport limits

+0042: import warnings

  __pyx_t_1 = __Pyx_Import(__pyx_n_s_warnings, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_warnings, __pyx_t_1) < 0) __PYX_ERR(0, 42, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+0043: import threading

  __pyx_t_1 = __Pyx_Import(__pyx_n_s_threading, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 43, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_threading, __pyx_t_1) < 0) __PYX_ERR(0, 43, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 0044: 

+0045: cdef int _simd_alignment = simd_alignment()

  __pyx_v_6pyrost_3bin_6pyfftw__simd_alignment = simd_alignment();

 0046: 

 0047: #: A tuple of simd alignments that make sense for this cpu

+0048: if _simd_alignment == 16:

  switch (__pyx_v_6pyrost_3bin_6pyfftw__simd_alignment) {
    case 16:
/* … */
    break;
    case 32:

+0049:     _valid_simd_alignments = (16,)

    if (PyDict_SetItem(__pyx_d, __pyx_n_s_valid_simd_alignments, __pyx_tuple__36) < 0) __PYX_ERR(0, 49, __pyx_L1_error)
/* … */
  __pyx_tuple__36 = PyTuple_Pack(1, __pyx_int_16); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__36);
  __Pyx_GIVEREF(__pyx_tuple__36);

 0050: 

+0051: elif _simd_alignment == 32:

    break;
    default:

+0052:     _valid_simd_alignments = (16, 32)

    if (PyDict_SetItem(__pyx_d, __pyx_n_s_valid_simd_alignments, __pyx_tuple__37) < 0) __PYX_ERR(0, 52, __pyx_L1_error)
/* … */
  __pyx_tuple__37 = PyTuple_Pack(2, __pyx_int_16, __pyx_int_32); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__37);
  __Pyx_GIVEREF(__pyx_tuple__37);

 0053: 

 0054: else:

+0055:     _valid_simd_alignments = ()

    if (PyDict_SetItem(__pyx_d, __pyx_n_s_valid_simd_alignments, __pyx_empty_tuple) < 0) __PYX_ERR(0, 55, __pyx_L1_error)
    break;
  }

 0056: 

+0057: cpdef byte_align(array, n=None, dtype=None):

static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_1byte_align(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_6pyrost_3bin_6pyfftw_byte_align(PyObject *__pyx_v_array, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_6pyrost_3bin_6pyfftw_byte_align *__pyx_optional_args) {
  PyObject *__pyx_v_n = ((PyObject *)Py_None);
  PyObject *__pyx_v_dtype = ((PyObject *)Py_None);
  int __pyx_v_update_dtype;
  PyObject *__pyx_v_offset = NULL;
  PyObject *__pyx_v__array_aligned = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("byte_align", 0);
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_n = __pyx_optional_args->n;
      if (__pyx_optional_args->__pyx_n > 1) {
        __pyx_v_dtype = __pyx_optional_args->dtype;
      }
    }
  }
  __Pyx_INCREF(__pyx_v_array);
  __Pyx_INCREF(__pyx_v_n);
  __Pyx_INCREF(__pyx_v_dtype);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.byte_align", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_offset);
  __Pyx_XDECREF(__pyx_v__array_aligned);
  __Pyx_XDECREF(__pyx_v_array);
  __Pyx_XDECREF(__pyx_v_n);
  __Pyx_XDECREF(__pyx_v_dtype);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_1byte_align(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_byte_align[] = "byte_align(array, n=None, dtype=None)\nbyte_align(array, n=None, dtype=None)\n\n    Function that takes a numpy array and checks it is aligned on an n-byte\n    boundary, where ``n`` is an optional parameter. If ``n`` is not provided\n    then this function will inspect the CPU to determine alignment. If the\n    array is aligned then it is returned without further ado.  If it is not\n    aligned then a new array is created and the data copied in, but aligned\n    on the n-byte boundary.\n\n    ``dtype`` is an optional argument that forces the resultant array to be\n    of that dtype.\n    ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_1byte_align = {"byte_align", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6pyrost_3bin_6pyfftw_1byte_align, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6pyrost_3bin_6pyfftw_byte_align};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_1byte_align(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_array = 0;
  PyObject *__pyx_v_n = 0;
  PyObject *__pyx_v_dtype = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("byte_align (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_array,&__pyx_n_s_n,&__pyx_n_s_dtype,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_array)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "byte_align") < 0)) __PYX_ERR(0, 57, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_array = values[0];
    __pyx_v_n = values[1];
    __pyx_v_dtype = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("byte_align", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 57, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw.byte_align", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_byte_align(__pyx_self, __pyx_v_array, __pyx_v_n, __pyx_v_dtype);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_byte_align(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_array, PyObject *__pyx_v_n, PyObject *__pyx_v_dtype) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("byte_align", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2.__pyx_n = 2;
  __pyx_t_2.n = __pyx_v_n;
  __pyx_t_2.dtype = __pyx_v_dtype;
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_byte_align(__pyx_v_array, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.byte_align", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__38 = PyTuple_Pack(3, __pyx_n_s_array, __pyx_n_s_n, __pyx_n_s_dtype); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__38);
  __Pyx_GIVEREF(__pyx_tuple__38);
/* … */
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_1byte_align, 0, __pyx_n_s_byte_align, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_byte_align, __pyx_t_1) < 0) __PYX_ERR(0, 57, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_byte_align, 57, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 57, __pyx_L1_error)
/* … */
struct __pyx_opt_args_6pyrost_3bin_6pyfftw_byte_align {
  int __pyx_n;
  PyObject *n;
  PyObject *dtype;
};

 0058:     '''byte_align(array, n=None, dtype=None)

 0059: 

 0060:     Function that takes a numpy array and checks it is aligned on an n-byte

 0061:     boundary, where ``n`` is an optional parameter. If ``n`` is not provided

 0062:     then this function will inspect the CPU to determine alignment. If the

 0063:     array is aligned then it is returned without further ado.  If it is not

 0064:     aligned then a new array is created and the data copied in, but aligned

 0065:     on the n-byte boundary.

 0066: 

 0067:     ``dtype`` is an optional argument that forces the resultant array to be

 0068:     of that dtype.

 0069:     '''

 0070: 

+0071:     if not isinstance(array, np.ndarray):

  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_array, __pyx_ptype_5numpy_ndarray); 
  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+0072:         raise TypeError('Invalid array: byte_align requires a subclass '

    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __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_ERR(0, 72, __pyx_L1_error)
/* … */
  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_Invalid_array_byte_align_require); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple_);
  __Pyx_GIVEREF(__pyx_tuple_);

 0073:                 'of ndarray')

 0074: 

+0075:     if n is None:

  __pyx_t_2 = (__pyx_v_n == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
/* … */
  }

+0076:         n = _simd_alignment

    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_6pyrost_3bin_6pyfftw__simd_alignment); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_3);
    __pyx_t_3 = 0;

 0077: 

+0078:     if dtype is not None:

  __pyx_t_1 = (__pyx_v_dtype != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
/* … */
    goto __pyx_L5;
  }

+0079:         if not array.dtype == dtype:

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_dtype, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_1 = ((!__pyx_t_2) != 0);
    if (__pyx_t_1) {
/* … */
    }

+0080:             update_dtype = True

      __pyx_v_update_dtype = 1;

 0081: 

 0082:     else:

+0083:         dtype = array.dtype

  /*else*/ {
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF_SET(__pyx_v_dtype, __pyx_t_4);
    __pyx_t_4 = 0;

+0084:         update_dtype = False

    __pyx_v_update_dtype = 0;
  }
  __pyx_L5:;

 0085: 

 0086:     # See if we're already n byte aligned. If so, do nothing.

+0087:     offset = <intptr_t>np.PyArray_DATA(array) %n

  if (!(likely(((__pyx_v_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 87, __pyx_L1_error)
  __pyx_t_4 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_array)))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyNumber_Remainder(__pyx_t_4, __pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_offset = __pyx_t_3;
  __pyx_t_3 = 0;

 0088: 

+0089:     if offset is not 0 or update_dtype:

  __pyx_t_2 = (__pyx_v_offset != __pyx_int_0);
  __pyx_t_5 = (__pyx_t_2 != 0);
  if (!__pyx_t_5) {
  } else {
    __pyx_t_1 = __pyx_t_5;
    goto __pyx_L8_bool_binop_done;
  }
  __pyx_t_5 = (__pyx_v_update_dtype != 0);
  __pyx_t_1 = __pyx_t_5;
  __pyx_L8_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

 0090: 

+0091:         _array_aligned = empty_aligned(array.shape, dtype, n=n)

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_empty_aligned); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 91, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 91, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 91, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_GIVEREF(__pyx_t_4);
    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4);
    __Pyx_INCREF(__pyx_v_dtype);
    __Pyx_GIVEREF(__pyx_v_dtype);
    PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_dtype);
    __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 91, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_n, __pyx_v_n) < 0) __PYX_ERR(0, 91, __pyx_L1_error)
    __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 91, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v__array_aligned = __pyx_t_7;
    __pyx_t_7 = 0;

 0092: 

+0093:         _array_aligned[:] = array

    if (__Pyx_PyObject_SetSlice(__pyx_v__array_aligned, __pyx_v_array, 0, 0, NULL, NULL, &__pyx_slice__2, 0, 0, 0) < 0) __PYX_ERR(0, 93, __pyx_L1_error)
/* … */
  __pyx_slice__2 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__2)) __PYX_ERR(0, 93, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_slice__2);
  __Pyx_GIVEREF(__pyx_slice__2);

 0094: 

+0095:         array = _array_aligned.view(type=array.__class__)

    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v__array_aligned, __pyx_n_s_view); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 95, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 95, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_array, __pyx_n_s_class); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_type, __pyx_t_6) < 0) __PYX_ERR(0, 95, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF_SET(__pyx_v_array, __pyx_t_6);
    __pyx_t_6 = 0;

 0096: 

+0097:     return array

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_array);
  __pyx_r = __pyx_v_array;
  goto __pyx_L0;

 0098: 

+0099: cpdef is_byte_aligned(array, n=None):

static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_3is_byte_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_6pyrost_3bin_6pyfftw_is_byte_aligned(PyObject *__pyx_v_array, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_6pyrost_3bin_6pyfftw_is_byte_aligned *__pyx_optional_args) {
  PyObject *__pyx_v_n = ((PyObject *)Py_None);
  PyObject *__pyx_v_offset = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("is_byte_aligned", 0);
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_n = __pyx_optional_args->n;
    }
  }
  __Pyx_INCREF(__pyx_v_n);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.is_byte_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_offset);
  __Pyx_XDECREF(__pyx_v_n);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_3is_byte_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_2is_byte_aligned[] = "is_byte_aligned(array, n=None)\n is_n_byte_aligned(array, n=None)\n\n    Function that takes a numpy array and checks it is aligned on an n-byte\n    boundary, where ``n`` is an optional parameter, returning ``True`` if it is,\n    and ``False`` if it is not. If ``n`` is not provided then this function will\n    inspect the CPU to determine alignment.\n    ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_3is_byte_aligned = {"is_byte_aligned", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6pyrost_3bin_6pyfftw_3is_byte_aligned, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6pyrost_3bin_6pyfftw_2is_byte_aligned};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_3is_byte_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_array = 0;
  PyObject *__pyx_v_n = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("is_byte_aligned (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_array,&__pyx_n_s_n,0};
    PyObject* values[2] = {0,0};
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_array)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "is_byte_aligned") < 0)) __PYX_ERR(0, 99, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_array = values[0];
    __pyx_v_n = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("is_byte_aligned", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 99, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw.is_byte_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_2is_byte_aligned(__pyx_self, __pyx_v_array, __pyx_v_n);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_2is_byte_aligned(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_array, PyObject *__pyx_v_n) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("is_byte_aligned", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2.__pyx_n = 1;
  __pyx_t_2.n = __pyx_v_n;
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_is_byte_aligned(__pyx_v_array, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.is_byte_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__40 = PyTuple_Pack(2, __pyx_n_s_array, __pyx_n_s_n); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__40);
  __Pyx_GIVEREF(__pyx_tuple__40);
/* … */
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_3is_byte_aligned, 0, __pyx_n_s_is_byte_aligned, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_byte_aligned, __pyx_t_1) < 0) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__40, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_is_byte_aligned, 99, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(0, 99, __pyx_L1_error)
/* … */
struct __pyx_opt_args_6pyrost_3bin_6pyfftw_is_byte_aligned {
  int __pyx_n;
  PyObject *n;
};

 0100:     ''' is_n_byte_aligned(array, n=None)

 0101: 

 0102:     Function that takes a numpy array and checks it is aligned on an n-byte

 0103:     boundary, where ``n`` is an optional parameter, returning ``True`` if it is,

 0104:     and ``False`` if it is not. If ``n`` is not provided then this function will

 0105:     inspect the CPU to determine alignment.

 0106:     '''

+0107:     if not isinstance(array, np.ndarray):

  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_array, __pyx_ptype_5numpy_ndarray); 
  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+0108:         raise TypeError('Invalid array: is_n_byte_aligned requires a subclass '

    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __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_ERR(0, 108, __pyx_L1_error)
/* … */
  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Invalid_array_is_n_byte_aligned); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 108, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__3);
  __Pyx_GIVEREF(__pyx_tuple__3);

 0109:                 'of ndarray')

 0110: 

+0111:     if n is None:

  __pyx_t_2 = (__pyx_v_n == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
/* … */
  }

+0112:         n = _simd_alignment

    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_6pyrost_3bin_6pyfftw__simd_alignment); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_3);
    __pyx_t_3 = 0;

 0113: 

 0114:     # See if we're n byte aligned.

+0115:     offset = <intptr_t>np.PyArray_DATA(array) %n

  if (!(likely(((__pyx_v_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 115, __pyx_L1_error)
  __pyx_t_3 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_array)))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 115, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Remainder(__pyx_t_3, __pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 115, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_offset = __pyx_t_4;
  __pyx_t_4 = 0;

 0116: 

+0117:     return not bool(offset)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_offset); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 117, __pyx_L1_error)
  __pyx_t_4 = __Pyx_PyBool_FromLong((!((!(!__pyx_t_1)) != 0))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 0118: 

+0119: cpdef is_n_byte_aligned(array, n):

static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_5is_n_byte_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_6pyrost_3bin_6pyfftw_is_n_byte_aligned(PyObject *__pyx_v_array, PyObject *__pyx_v_n, CYTHON_UNUSED int __pyx_skip_dispatch) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("is_n_byte_aligned", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.is_n_byte_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_5is_n_byte_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4is_n_byte_aligned[] = "is_n_byte_aligned(array, n)\n is_n_byte_aligned(array, n)\n    **This function is deprecated:** ``is_byte_aligned`` **should be used\n    instead.**\n\n    Function that takes a numpy array and checks it is aligned on an n-byte\n    boundary, where ``n`` is a passed parameter, returning ``True`` if it is,\n    and ``False`` if it is not.\n    ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_5is_n_byte_aligned = {"is_n_byte_aligned", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6pyrost_3bin_6pyfftw_5is_n_byte_aligned, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6pyrost_3bin_6pyfftw_4is_n_byte_aligned};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_5is_n_byte_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_array = 0;
  PyObject *__pyx_v_n = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("is_n_byte_aligned (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_array,&__pyx_n_s_n,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_array)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("is_n_byte_aligned", 1, 2, 2, 1); __PYX_ERR(0, 119, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "is_n_byte_aligned") < 0)) __PYX_ERR(0, 119, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_array = values[0];
    __pyx_v_n = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("is_n_byte_aligned", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 119, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw.is_n_byte_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4is_n_byte_aligned(__pyx_self, __pyx_v_array, __pyx_v_n);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4is_n_byte_aligned(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_array, PyObject *__pyx_v_n) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("is_n_byte_aligned", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_is_n_byte_aligned(__pyx_v_array, __pyx_v_n, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.is_n_byte_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__42 = PyTuple_Pack(2, __pyx_n_s_array, __pyx_n_s_n); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__42);
  __Pyx_GIVEREF(__pyx_tuple__42);
/* … */
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_5is_n_byte_aligned, 0, __pyx_n_s_is_n_byte_aligned, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__43)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_n_byte_aligned, __pyx_t_1) < 0) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__42, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_is_n_byte_aligned, 119, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) __PYX_ERR(0, 119, __pyx_L1_error)

 0120:     ''' is_n_byte_aligned(array, n)

 0121:     **This function is deprecated:** ``is_byte_aligned`` **should be used

 0122:     instead.**

 0123: 

 0124:     Function that takes a numpy array and checks it is aligned on an n-byte

 0125:     boundary, where ``n`` is a passed parameter, returning ``True`` if it is,

 0126:     and ``False`` if it is not.

 0127:     '''

+0128:     return is_byte_aligned(array, n=n)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2.__pyx_n = 1;
  __pyx_t_2.n = __pyx_v_n;
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_is_byte_aligned(__pyx_v_array, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0129: 

+0130: cpdef empty_aligned(shape, dtype='float64', order='C', n=None):

static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_7empty_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_6pyrost_3bin_6pyfftw_empty_aligned(PyObject *__pyx_v_shape, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_6pyrost_3bin_6pyfftw_empty_aligned *__pyx_optional_args) {
  PyObject *__pyx_v_dtype = ((PyObject *)__pyx_n_u_float64);
  PyObject *__pyx_v_order = ((PyObject *)__pyx_n_u_C);
  PyObject *__pyx_v_n = ((PyObject *)Py_None);
  PY_LONG_LONG __pyx_v_array_length;
  PyObject *__pyx_v_itemsize = NULL;
  PyObject *__pyx_v_each_dimension = NULL;
  PyObject *__pyx_v__array_aligned = NULL;
  PyObject *__pyx_v__array_aligned_offset = NULL;
  PyObject *__pyx_v_array = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("empty_aligned", 0);
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_dtype = __pyx_optional_args->dtype;
      if (__pyx_optional_args->__pyx_n > 1) {
        __pyx_v_order = __pyx_optional_args->order;
        if (__pyx_optional_args->__pyx_n > 2) {
          __pyx_v_n = __pyx_optional_args->n;
        }
      }
    }
  }
  __Pyx_INCREF(__pyx_v_n);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.empty_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_itemsize);
  __Pyx_XDECREF(__pyx_v_each_dimension);
  __Pyx_XDECREF(__pyx_v__array_aligned);
  __Pyx_XDECREF(__pyx_v__array_aligned_offset);
  __Pyx_XDECREF(__pyx_v_array);
  __Pyx_XDECREF(__pyx_v_n);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_7empty_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_6empty_aligned[] = "empty_aligned(shape, dtype=u'float64', order=u'C', n=None)\nempty_aligned(shape, dtype='float64', order='C', n=None)\n\n    Function that returns an empty numpy array that is n-byte aligned,\n    where ``n`` is determined by inspecting the CPU if it is not\n    provided.\n\n    The alignment is given by the final optional argument, ``n``. If\n    ``n`` is not provided then this function will inspect the CPU to\n    determine alignment. The rest of the arguments are as per\n    :func:`numpy.empty`.\n    ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_7empty_aligned = {"empty_aligned", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6pyrost_3bin_6pyfftw_7empty_aligned, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6pyrost_3bin_6pyfftw_6empty_aligned};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_7empty_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_shape = 0;
  PyObject *__pyx_v_dtype = 0;
  PyObject *__pyx_v_order = 0;
  PyObject *__pyx_v_n = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("empty_aligned (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_dtype,&__pyx_n_s_order,&__pyx_n_s_n,0};
    PyObject* values[4] = {0,0,0,0};
    values[1] = ((PyObject *)__pyx_n_u_float64);
    values[2] = ((PyObject *)__pyx_n_u_C);
    values[3] = ((PyObject *)Py_None);
    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);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_order);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "empty_aligned") < 0)) __PYX_ERR(0, 130, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_shape = values[0];
    __pyx_v_dtype = values[1];
    __pyx_v_order = values[2];
    __pyx_v_n = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("empty_aligned", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 130, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw.empty_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_6empty_aligned(__pyx_self, __pyx_v_shape, __pyx_v_dtype, __pyx_v_order, __pyx_v_n);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_6empty_aligned(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_shape, PyObject *__pyx_v_dtype, PyObject *__pyx_v_order, PyObject *__pyx_v_n) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("empty_aligned", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2.__pyx_n = 3;
  __pyx_t_2.dtype = __pyx_v_dtype;
  __pyx_t_2.order = __pyx_v_order;
  __pyx_t_2.n = __pyx_v_n;
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_empty_aligned(__pyx_v_shape, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.empty_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__44 = PyTuple_Pack(4, __pyx_n_s_shape, __pyx_n_s_dtype, __pyx_n_s_order, __pyx_n_s_n); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__44);
  __Pyx_GIVEREF(__pyx_tuple__44);
/* … */
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_7empty_aligned, 0, __pyx_n_s_empty_aligned, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__45)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_empty_aligned, __pyx_t_1) < 0) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_empty_aligned, 130, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(0, 130, __pyx_L1_error)
/* … */
struct __pyx_opt_args_6pyrost_3bin_6pyfftw_empty_aligned {
  int __pyx_n;
  PyObject *dtype;
  PyObject *order;
  PyObject *n;
};

 0131:     '''empty_aligned(shape, dtype='float64', order='C', n=None)

 0132: 

 0133:     Function that returns an empty numpy array that is n-byte aligned,

 0134:     where ``n`` is determined by inspecting the CPU if it is not

 0135:     provided.

 0136: 

 0137:     The alignment is given by the final optional argument, ``n``. If

 0138:     ``n`` is not provided then this function will inspect the CPU to

 0139:     determine alignment. The rest of the arguments are as per

 0140:     :func:`numpy.empty`.

 0141:     '''

 0142:     cdef long long array_length

 0143: 

+0144:     if n is None:

  __pyx_t_1 = (__pyx_v_n == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
/* … */
  }

+0145:         n = _simd_alignment

    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_6pyrost_3bin_6pyfftw__simd_alignment); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 145, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_3);
    __pyx_t_3 = 0;

 0146: 

+0147:     itemsize = np.dtype(dtype).itemsize

  __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_v_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 147, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyInt_From_int(((PyArray_Descr *)__pyx_t_3)->elsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_itemsize = __pyx_t_4;
  __pyx_t_4 = 0;

 0148: 

 0149:     # Apparently there is an issue with numpy.prod wrapping around on 32-bits

 0150:     # on Windows 64-bit. This shouldn't happen, but the following code

 0151:     # alleviates the problem.

+0152:     if not isinstance(shape, (int, np.integer)):

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_integer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_1 = PyInt_Check(__pyx_v_shape); 
  __pyx_t_5 = (__pyx_t_1 != 0);
  if (!__pyx_t_5) {
  } else {
    __pyx_t_2 = __pyx_t_5;
    goto __pyx_L5_bool_binop_done;
  }
  __pyx_t_5 = PyObject_IsInstance(__pyx_v_shape, __pyx_t_3); 
  __pyx_t_1 = (__pyx_t_5 != 0);
  __pyx_t_2 = __pyx_t_1;
  __pyx_L5_bool_binop_done:;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
  if (__pyx_t_1) {
/* … */
    goto __pyx_L4;
  }

+0153:         array_length = 1

    __pyx_v_array_length = 1;

+0154:         for each_dimension in shape:

    if (likely(PyList_CheckExact(__pyx_v_shape)) || PyTuple_CheckExact(__pyx_v_shape)) {
      __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_6 = 0;
      __pyx_t_7 = NULL;
    } else {
      __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 154, __pyx_L1_error)
    }
    for (;;) {
      if (likely(!__pyx_t_7)) {
        if (likely(PyList_CheckExact(__pyx_t_3))) {
          if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_3)) break;
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_4 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 154, __pyx_L1_error)
          #else
          __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          #endif
        } else {
          if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 154, __pyx_L1_error)
          #else
          __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          #endif
        }
      } else {
        __pyx_t_4 = __pyx_t_7(__pyx_t_3);
        if (unlikely(!__pyx_t_4)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
            else __PYX_ERR(0, 154, __pyx_L1_error)
          }
          break;
        }
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_XDECREF_SET(__pyx_v_each_dimension, __pyx_t_4);
      __pyx_t_4 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0155:             array_length *= each_dimension

      __pyx_t_4 = __Pyx_PyInt_From_PY_LONG_LONG(__pyx_v_array_length); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 155, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_8 = PyNumber_InPlaceMultiply(__pyx_t_4, __pyx_v_each_dimension); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 155, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_9 = __Pyx_PyInt_As_PY_LONG_LONG(__pyx_t_8); if (unlikely((__pyx_t_9 == (PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_v_array_length = __pyx_t_9;

 0156: 

 0157:     else:

+0158:         array_length = shape

  /*else*/ {
    __pyx_t_9 = __Pyx_PyInt_As_PY_LONG_LONG(__pyx_v_shape); if (unlikely((__pyx_t_9 == (PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 158, __pyx_L1_error)
    __pyx_v_array_length = __pyx_t_9;
  }
  __pyx_L4:;

 0159: 

 0160:     # Allocate a new array that will contain the aligned data

+0161:     _array_aligned = np.empty(array_length*itemsize+n, dtype='int8')

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_From_PY_LONG_LONG(__pyx_v_array_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
  __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_n_u_int8) < 0) __PYX_ERR(0, 161, __pyx_L1_error)
  __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v__array_aligned = __pyx_t_10;
  __pyx_t_10 = 0;

 0162: 

 0163:     # We now need to know how to offset _array_aligned

 0164:     # so it is correctly aligned

+0165:     _array_aligned_offset = (n-<intptr_t>np.PyArray_DATA(_array_aligned))%n

  if (!(likely(((__pyx_v__array_aligned) == Py_None) || likely(__Pyx_TypeTest(__pyx_v__array_aligned, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 165, __pyx_L1_error)
  __pyx_t_10 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v__array_aligned)))); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 165, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_3 = PyNumber_Subtract(__pyx_v_n, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 165, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = PyNumber_Remainder(__pyx_t_3, __pyx_v_n); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 165, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v__array_aligned_offset = __pyx_t_10;
  __pyx_t_10 = 0;

 0166: 

+0167:     array = np.frombuffer(

  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 167, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_frombuffer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* … */
  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_10);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_10);
  __pyx_t_10 = 0;
/* … */
  __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 167, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+0168:             _array_aligned[_array_aligned_offset:_array_aligned_offset-n].data,

  __pyx_t_10 = PyNumber_Subtract(__pyx_v__array_aligned_offset, __pyx_v_n); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 168, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v__array_aligned, 0, 0, &__pyx_v__array_aligned_offset, &__pyx_t_10, NULL, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_data); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 168, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0169:             dtype=dtype).reshape(shape, order=order)

  __pyx_t_10 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 169, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_dtype, __pyx_v_dtype) < 0) __PYX_ERR(0, 169, __pyx_L1_error)
/* … */
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_reshape); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 169, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 169, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_INCREF(__pyx_v_shape);
  __Pyx_GIVEREF(__pyx_v_shape);
  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_shape);
  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 169, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_order, __pyx_v_order) < 0) __PYX_ERR(0, 169, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_array = __pyx_t_3;
  __pyx_t_3 = 0;

 0170: 

+0171:     return array

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_array);
  __pyx_r = __pyx_v_array;
  goto __pyx_L0;

 0172: 

+0173: cpdef zeros_aligned(shape, dtype='float64', order='C', n=None):

static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_9zeros_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_6pyrost_3bin_6pyfftw_zeros_aligned(PyObject *__pyx_v_shape, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_6pyrost_3bin_6pyfftw_zeros_aligned *__pyx_optional_args) {
  PyObject *__pyx_v_dtype = ((PyObject *)__pyx_n_u_float64);
  PyObject *__pyx_v_order = ((PyObject *)__pyx_n_u_C);
  PyObject *__pyx_v_n = ((PyObject *)Py_None);
  PyObject *__pyx_v_array = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("zeros_aligned", 0);
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_dtype = __pyx_optional_args->dtype;
      if (__pyx_optional_args->__pyx_n > 1) {
        __pyx_v_order = __pyx_optional_args->order;
        if (__pyx_optional_args->__pyx_n > 2) {
          __pyx_v_n = __pyx_optional_args->n;
        }
      }
    }
  }
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.zeros_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_array);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_9zeros_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_8zeros_aligned[] = "zeros_aligned(shape, dtype=u'float64', order=u'C', n=None)\nzeros_aligned(shape, dtype='float64', order='C', n=None)\n\n    Function that returns a numpy array of zeros that is n-byte aligned,\n    where ``n`` is determined by inspecting the CPU if it is not\n    provided.\n\n    The alignment is given by the final optional argument, ``n``. If\n    ``n`` is not provided then this function will inspect the CPU to\n    determine alignment. The rest of the arguments are as per\n    :func:`numpy.zeros`.\n    ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_9zeros_aligned = {"zeros_aligned", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6pyrost_3bin_6pyfftw_9zeros_aligned, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6pyrost_3bin_6pyfftw_8zeros_aligned};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_9zeros_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_shape = 0;
  PyObject *__pyx_v_dtype = 0;
  PyObject *__pyx_v_order = 0;
  PyObject *__pyx_v_n = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("zeros_aligned (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_dtype,&__pyx_n_s_order,&__pyx_n_s_n,0};
    PyObject* values[4] = {0,0,0,0};
    values[1] = ((PyObject *)__pyx_n_u_float64);
    values[2] = ((PyObject *)__pyx_n_u_C);
    values[3] = ((PyObject *)Py_None);
    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);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_order);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "zeros_aligned") < 0)) __PYX_ERR(0, 173, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_shape = values[0];
    __pyx_v_dtype = values[1];
    __pyx_v_order = values[2];
    __pyx_v_n = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("zeros_aligned", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 173, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw.zeros_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_8zeros_aligned(__pyx_self, __pyx_v_shape, __pyx_v_dtype, __pyx_v_order, __pyx_v_n);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_8zeros_aligned(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_shape, PyObject *__pyx_v_dtype, PyObject *__pyx_v_order, PyObject *__pyx_v_n) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("zeros_aligned", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2.__pyx_n = 3;
  __pyx_t_2.dtype = __pyx_v_dtype;
  __pyx_t_2.order = __pyx_v_order;
  __pyx_t_2.n = __pyx_v_n;
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_zeros_aligned(__pyx_v_shape, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.zeros_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__46 = PyTuple_Pack(4, __pyx_n_s_shape, __pyx_n_s_dtype, __pyx_n_s_order, __pyx_n_s_n); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__46);
  __Pyx_GIVEREF(__pyx_tuple__46);
/* … */
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_9zeros_aligned, 0, __pyx_n_s_zeros_aligned, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__47)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_zeros_aligned, __pyx_t_1) < 0) __PYX_ERR(0, 173, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_codeobj__47 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__46, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_zeros_aligned, 173, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__47)) __PYX_ERR(0, 173, __pyx_L1_error)
/* … */
struct __pyx_opt_args_6pyrost_3bin_6pyfftw_zeros_aligned {
  int __pyx_n;
  PyObject *dtype;
  PyObject *order;
  PyObject *n;
};

 0174:     '''zeros_aligned(shape, dtype='float64', order='C', n=None)

 0175: 

 0176:     Function that returns a numpy array of zeros that is n-byte aligned,

 0177:     where ``n`` is determined by inspecting the CPU if it is not

 0178:     provided.

 0179: 

 0180:     The alignment is given by the final optional argument, ``n``. If

 0181:     ``n`` is not provided then this function will inspect the CPU to

 0182:     determine alignment. The rest of the arguments are as per

 0183:     :func:`numpy.zeros`.

 0184:     '''

+0185:     array = empty_aligned(shape, dtype=dtype, order=order, n=n)

  __pyx_t_2.__pyx_n = 3;
  __pyx_t_2.dtype = __pyx_v_dtype;
  __pyx_t_2.order = __pyx_v_order;
  __pyx_t_2.n = __pyx_v_n;
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_empty_aligned(__pyx_v_shape, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 185, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_array = __pyx_t_1;
  __pyx_t_1 = 0;

+0186:     array.fill(0)

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_array, __pyx_n_s_fill); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_int_0) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_int_0);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 186, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+0187:     return array

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_array);
  __pyx_r = __pyx_v_array;
  goto __pyx_L0;

 0188: 

+0189: cpdef ones_aligned(shape, dtype='float64', order='C', n=None):

static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_11ones_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_6pyrost_3bin_6pyfftw_ones_aligned(PyObject *__pyx_v_shape, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_6pyrost_3bin_6pyfftw_ones_aligned *__pyx_optional_args) {
  PyObject *__pyx_v_dtype = ((PyObject *)__pyx_n_u_float64);
  PyObject *__pyx_v_order = ((PyObject *)__pyx_n_u_C);
  PyObject *__pyx_v_n = ((PyObject *)Py_None);
  PyObject *__pyx_v_array = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ones_aligned", 0);
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_dtype = __pyx_optional_args->dtype;
      if (__pyx_optional_args->__pyx_n > 1) {
        __pyx_v_order = __pyx_optional_args->order;
        if (__pyx_optional_args->__pyx_n > 2) {
          __pyx_v_n = __pyx_optional_args->n;
        }
      }
    }
  }
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.ones_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_array);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_11ones_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_10ones_aligned[] = "ones_aligned(shape, dtype=u'float64', order=u'C', n=None)\nones_aligned(shape, dtype='float64', order='C', n=None)\n\n    Function that returns a numpy array of ones that is n-byte aligned,\n    where ``n`` is determined by inspecting the CPU if it is not\n    provided.\n\n    The alignment is given by the final optional argument, ``n``. If\n    ``n`` is not provided then this function will inspect the CPU to\n    determine alignment. The rest of the arguments are as per\n    :func:`numpy.ones`.\n    ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_11ones_aligned = {"ones_aligned", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6pyrost_3bin_6pyfftw_11ones_aligned, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6pyrost_3bin_6pyfftw_10ones_aligned};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_11ones_aligned(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_shape = 0;
  PyObject *__pyx_v_dtype = 0;
  PyObject *__pyx_v_order = 0;
  PyObject *__pyx_v_n = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ones_aligned (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_dtype,&__pyx_n_s_order,&__pyx_n_s_n,0};
    PyObject* values[4] = {0,0,0,0};
    values[1] = ((PyObject *)__pyx_n_u_float64);
    values[2] = ((PyObject *)__pyx_n_u_C);
    values[3] = ((PyObject *)Py_None);
    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);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_order);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ones_aligned") < 0)) __PYX_ERR(0, 189, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_shape = values[0];
    __pyx_v_dtype = values[1];
    __pyx_v_order = values[2];
    __pyx_v_n = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("ones_aligned", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 189, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw.ones_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_10ones_aligned(__pyx_self, __pyx_v_shape, __pyx_v_dtype, __pyx_v_order, __pyx_v_n);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_10ones_aligned(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_shape, PyObject *__pyx_v_dtype, PyObject *__pyx_v_order, PyObject *__pyx_v_n) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ones_aligned", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2.__pyx_n = 3;
  __pyx_t_2.dtype = __pyx_v_dtype;
  __pyx_t_2.order = __pyx_v_order;
  __pyx_t_2.n = __pyx_v_n;
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_ones_aligned(__pyx_v_shape, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.ones_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__48 = PyTuple_Pack(4, __pyx_n_s_shape, __pyx_n_s_dtype, __pyx_n_s_order, __pyx_n_s_n); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 189, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__48);
  __Pyx_GIVEREF(__pyx_tuple__48);
/* … */
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_11ones_aligned, 0, __pyx_n_s_ones_aligned, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__49)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ones_aligned, __pyx_t_1) < 0) __PYX_ERR(0, 189, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_ones_aligned, 189, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(0, 189, __pyx_L1_error)
/* … */
struct __pyx_opt_args_6pyrost_3bin_6pyfftw_ones_aligned {
  int __pyx_n;
  PyObject *dtype;
  PyObject *order;
  PyObject *n;
};

 0190:     '''ones_aligned(shape, dtype='float64', order='C', n=None)

 0191: 

 0192:     Function that returns a numpy array of ones that is n-byte aligned,

 0193:     where ``n`` is determined by inspecting the CPU if it is not

 0194:     provided.

 0195: 

 0196:     The alignment is given by the final optional argument, ``n``. If

 0197:     ``n`` is not provided then this function will inspect the CPU to

 0198:     determine alignment. The rest of the arguments are as per

 0199:     :func:`numpy.ones`.

 0200:     '''

+0201:     array = empty_aligned(shape, dtype=dtype, order=order, n=n)

  __pyx_t_2.__pyx_n = 3;
  __pyx_t_2.dtype = __pyx_v_dtype;
  __pyx_t_2.order = __pyx_v_order;
  __pyx_t_2.n = __pyx_v_n;
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_empty_aligned(__pyx_v_shape, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_array = __pyx_t_1;
  __pyx_t_1 = 0;

+0202:     array.fill(1)

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_array, __pyx_n_s_fill); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_int_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_int_1);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+0203:     return array

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_array);
  __pyx_r = __pyx_v_array;
  goto __pyx_L0;

 0204: 

 0205: cdef object directions

+0206: directions = {'FFTW_FORWARD': FFTW_FORWARD,

  __pyx_t_1 = __Pyx_PyDict_NewPresized(10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_FORWARD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_FORWARD, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0207:         'FFTW_BACKWARD': FFTW_BACKWARD,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_BACKWARD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_BACKWARD, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0208:         'FFTW_REDFT00': FFTW_REDFT00,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_REDFT00); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 208, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_REDFT00, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0209:         'FFTW_REDFT10': FFTW_REDFT10,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_REDFT10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 209, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_REDFT10, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0210:         'FFTW_REDFT01': FFTW_REDFT01,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_REDFT01); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_REDFT01, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0211:         'FFTW_REDFT11': FFTW_REDFT11,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_REDFT11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 211, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_REDFT11, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0212:         'FFTW_RODFT00': FFTW_RODFT00,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_RODFT00); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_RODFT00, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0213:         'FFTW_RODFT10': FFTW_RODFT10,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_RODFT10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 213, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_RODFT10, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0214:         'FFTW_RODFT01': FFTW_RODFT01,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_RODFT01); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_RODFT01, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0215:         'FFTW_RODFT11': FFTW_RODFT11}

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_RODFT11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_RODFT11, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_XGOTREF(__pyx_v_6pyrost_3bin_6pyfftw_directions);
  __Pyx_DECREF_SET(__pyx_v_6pyrost_3bin_6pyfftw_directions, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;

 0216: 

 0217: cdef object directions_lookup

+0218: directions_lookup = {FFTW_FORWARD: 'FFTW_FORWARD',

  __pyx_t_1 = __Pyx_PyDict_NewPresized(10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_FORWARD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_n_u_FFTW_FORWARD) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0219:         FFTW_BACKWARD: 'FFTW_BACKWARD',

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_BACKWARD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_n_u_FFTW_BACKWARD) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0220:         FFTW_REDFT00: 'FFTW_REDFT00',

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_REDFT00); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_n_u_FFTW_REDFT00) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0221:         FFTW_REDFT10: 'FFTW_REDFT10',

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_REDFT10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_n_u_FFTW_REDFT10) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0222:         FFTW_REDFT01: 'FFTW_REDFT01',

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_REDFT01); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_n_u_FFTW_REDFT01) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0223:         FFTW_REDFT11: 'FFTW_REDFT11',

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_REDFT11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_n_u_FFTW_REDFT11) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0224:         FFTW_RODFT00: 'FFTW_RODFT00',

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_RODFT00); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 224, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_n_u_FFTW_RODFT00) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0225:         FFTW_RODFT10: 'FFTW_RODFT10',

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_RODFT10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_n_u_FFTW_RODFT10) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0226:         FFTW_RODFT01: 'FFTW_RODFT01',

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_RODFT01); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_n_u_FFTW_RODFT01) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0227:         FFTW_RODFT11: 'FFTW_RODFT11'}

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_RODFT11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 227, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_n_u_FFTW_RODFT11) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_XGOTREF(__pyx_v_6pyrost_3bin_6pyfftw_directions_lookup);
  __Pyx_DECREF_SET(__pyx_v_6pyrost_3bin_6pyfftw_directions_lookup, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;

 0228: 

 0229: cdef object flag_dict

+0230: flag_dict = {'FFTW_MEASURE': FFTW_MEASURE,

  __pyx_t_1 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_MEASURE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_MEASURE, __pyx_t_2) < 0) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0231:         'FFTW_EXHAUSTIVE': FFTW_EXHAUSTIVE,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_EXHAUSTIVE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_EXHAUSTIVE, __pyx_t_2) < 0) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0232:         'FFTW_PATIENT': FFTW_PATIENT,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_PATIENT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 232, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_PATIENT, __pyx_t_2) < 0) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0233:         'FFTW_ESTIMATE': FFTW_ESTIMATE,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_ESTIMATE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_ESTIMATE, __pyx_t_2) < 0) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0234:         'FFTW_UNALIGNED': FFTW_UNALIGNED,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_UNALIGNED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_UNALIGNED, __pyx_t_2) < 0) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0235:         'FFTW_DESTROY_INPUT': FFTW_DESTROY_INPUT,

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_DESTROY_INPUT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_DESTROY_INPUT, __pyx_t_2) < 0) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+0236:         'FFTW_WISDOM_ONLY': FFTW_WISDOM_ONLY}

  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_e_6pyrost_3bin_6pyfftw_FFTW_WISDOM_ONLY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_FFTW_WISDOM_ONLY, __pyx_t_2) < 0) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_XGOTREF(__pyx_v_6pyrost_3bin_6pyfftw_flag_dict);
  __Pyx_DECREF_SET(__pyx_v_6pyrost_3bin_6pyfftw_flag_dict, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;

 0237: 

 0238: # Need a global lock to protect FFTW planning so that multiple Python threads

 0239: # do not attempt to plan simultaneously.

+0240: cdef object plan_lock = threading.Lock()

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_threading); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Lock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_XGOTREF(__pyx_v_6pyrost_3bin_6pyfftw_plan_lock);
  __Pyx_DECREF_SET(__pyx_v_6pyrost_3bin_6pyfftw_plan_lock, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;

 0241: 

 0242: # Function wrappers

 0243: # =================

 0244: # All of these have the same signature as the fftw_generic functions

 0245: # defined in the .pxd file. The arguments and return values are

 0246: # cast as required in order to call the actual fftw functions.

 0247: #

 0248: # The wrapper function names are simply the fftw names prefixed

 0249: # with a single underscore.

 0250: 

 0251: #     Planners

 0252: #     ========

 0253: #

 0254: # Complex double precision

+0255: cdef void* _fftw_plan_guru_dft(

static void *__pyx_f_6pyrost_3bin_6pyfftw__fftw_plan_guru_dft(int __pyx_v_rank, fftw_iodim *__pyx_v_dims, int __pyx_v_howmany_rank, fftw_iodim *__pyx_v_howmany_dims, void *__pyx_v__in, void *__pyx_v__out, int *__pyx_v_direction, unsigned int __pyx_v_flags) {
  void *__pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 0256:             int rank, fftw_iodim *dims,

 0257:             int howmany_rank, fftw_iodim *howmany_dims,

 0258:             void *_in, void *_out,

 0259:             int *direction, unsigned flags) nogil:

 0260: 

+0261:     return <void *>fftw_plan_guru_dft(rank, dims,

  __pyx_r = ((void *)fftw_plan_guru_dft(__pyx_v_rank, __pyx_v_dims, __pyx_v_howmany_rank, __pyx_v_howmany_dims, ((__pyx_t_6pyrost_3bin_6pyfftw_cdouble *)__pyx_v__in), ((__pyx_t_6pyrost_3bin_6pyfftw_cdouble *)__pyx_v__out), (__pyx_v_direction[0]), __pyx_v_flags));
  goto __pyx_L0;

 0262:             howmany_rank, howmany_dims,

 0263:             <cdouble *>_in, <cdouble *>_out,

 0264:             direction[0], flags)

 0265: 

 0266: # real to complex double precision

+0267: cdef void* _fftw_plan_guru_dft_r2c(

static void *__pyx_f_6pyrost_3bin_6pyfftw__fftw_plan_guru_dft_r2c(int __pyx_v_rank, fftw_iodim *__pyx_v_dims, int __pyx_v_howmany_rank, fftw_iodim *__pyx_v_howmany_dims, void *__pyx_v__in, void *__pyx_v__out, CYTHON_UNUSED int *__pyx_v_direction, unsigned int __pyx_v_flags) {
  void *__pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 0268:             int rank, fftw_iodim *dims,

 0269:             int howmany_rank, fftw_iodim *howmany_dims,

 0270:             void *_in, void *_out,

 0271:             int *direction, unsigned flags) nogil:

 0272: 

+0273:     return <void *>fftw_plan_guru_dft_r2c(rank, dims,

  __pyx_r = ((void *)fftw_plan_guru_dft_r2c(__pyx_v_rank, __pyx_v_dims, __pyx_v_howmany_rank, __pyx_v_howmany_dims, ((double *)__pyx_v__in), ((__pyx_t_6pyrost_3bin_6pyfftw_cdouble *)__pyx_v__out), __pyx_v_flags));
  goto __pyx_L0;

 0274:             howmany_rank, howmany_dims,

 0275:             <double *>_in, <cdouble *>_out,

 0276:             flags)

 0277: 

 0278: # complex to real double precision

+0279: cdef void* _fftw_plan_guru_dft_c2r(

static void *__pyx_f_6pyrost_3bin_6pyfftw__fftw_plan_guru_dft_c2r(int __pyx_v_rank, fftw_iodim *__pyx_v_dims, int __pyx_v_howmany_rank, fftw_iodim *__pyx_v_howmany_dims, void *__pyx_v__in, void *__pyx_v__out, CYTHON_UNUSED int *__pyx_v_direction, unsigned int __pyx_v_flags) {
  void *__pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 0280:             int rank, fftw_iodim *dims,

 0281:             int howmany_rank, fftw_iodim *howmany_dims,

 0282:             void *_in, void *_out,

 0283:             int *direction, unsigned flags) nogil:

 0284: 

+0285:     return <void *>fftw_plan_guru_dft_c2r(rank, dims,

  __pyx_r = ((void *)fftw_plan_guru_dft_c2r(__pyx_v_rank, __pyx_v_dims, __pyx_v_howmany_rank, __pyx_v_howmany_dims, ((__pyx_t_6pyrost_3bin_6pyfftw_cdouble *)__pyx_v__in), ((double *)__pyx_v__out), __pyx_v_flags));
  goto __pyx_L0;

 0286:             howmany_rank, howmany_dims,

 0287:             <cdouble *>_in, <double *>_out,

 0288:             flags)

 0289: 

 0290: # real to real double precision

+0291: cdef void* _fftw_plan_guru_r2r(

static void *__pyx_f_6pyrost_3bin_6pyfftw__fftw_plan_guru_r2r(int __pyx_v_rank, fftw_iodim *__pyx_v_dims, int __pyx_v_howmany_rank, fftw_iodim *__pyx_v_howmany_dims, void *__pyx_v__in, void *__pyx_v__out, int *__pyx_v_direction, int __pyx_v_flags) {
  void *__pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_fftw_plan_guru_r2r", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0292:             int rank, fftw_iodim *dims,

 0293:             int howmany_rank, fftw_iodim *howmany_dims,

 0294:             void *_in, void *_out,

 0295:             int *direction, int flags):

 0296: 

+0297:     return <void *>fftw_plan_guru_r2r(rank, dims,

  __pyx_r = ((void *)fftw_plan_guru_r2r(__pyx_v_rank, __pyx_v_dims, __pyx_v_howmany_rank, __pyx_v_howmany_dims, ((double *)__pyx_v__in), ((double *)__pyx_v__out), __pyx_v_direction, __pyx_v_flags));
  goto __pyx_L0;

 0298:             howmany_rank, howmany_dims,

 0299:             <double *>_in, <double *>_out,

 0300:             direction, flags)

 0301: 

 0302: #    Executors

 0303: #    =========

 0304: #

 0305: # Complex double precision

+0306: cdef void _fftw_execute_dft(void *_plan, void *_in, void *_out) nogil:

static void __pyx_f_6pyrost_3bin_6pyfftw__fftw_execute_dft(void *__pyx_v__plan, void *__pyx_v__in, void *__pyx_v__out) {
/* … */
  /* function exit code */
}

 0307: 

+0308:     fftw_execute_dft(<fftw_plan>_plan,

  fftw_execute_dft(((fftw_plan)__pyx_v__plan), ((__pyx_t_6pyrost_3bin_6pyfftw_cdouble *)__pyx_v__in), ((__pyx_t_6pyrost_3bin_6pyfftw_cdouble *)__pyx_v__out));

 0309:             <cdouble *>_in, <cdouble *>_out)

 0310: 

 0311: # real to complex double precision

+0312: cdef void _fftw_execute_dft_r2c(void *_plan, void *_in, void *_out) nogil:

static void __pyx_f_6pyrost_3bin_6pyfftw__fftw_execute_dft_r2c(void *__pyx_v__plan, void *__pyx_v__in, void *__pyx_v__out) {
/* … */
  /* function exit code */
}

 0313: 

+0314:     fftw_execute_dft_r2c(<fftw_plan>_plan,

  fftw_execute_dft_r2c(((fftw_plan)__pyx_v__plan), ((double *)__pyx_v__in), ((__pyx_t_6pyrost_3bin_6pyfftw_cdouble *)__pyx_v__out));

 0315:             <double *>_in, <cdouble *>_out)

 0316: 

 0317: # complex to real double precision

+0318: cdef void _fftw_execute_dft_c2r(void *_plan, void *_in, void *_out) nogil:

static void __pyx_f_6pyrost_3bin_6pyfftw__fftw_execute_dft_c2r(void *__pyx_v__plan, void *__pyx_v__in, void *__pyx_v__out) {
/* … */
  /* function exit code */
}

 0319: 

+0320:     fftw_execute_dft_c2r(<fftw_plan>_plan,

  fftw_execute_dft_c2r(((fftw_plan)__pyx_v__plan), ((__pyx_t_6pyrost_3bin_6pyfftw_cdouble *)__pyx_v__in), ((double *)__pyx_v__out));

 0321:             <cdouble *>_in, <double *>_out)

 0322: 

 0323: # real to real double precision

+0324: cdef void _fftw_execute_r2r(void *_plan, void *_in, void *_out) nogil:

static void __pyx_f_6pyrost_3bin_6pyfftw__fftw_execute_r2r(void *__pyx_v__plan, void *__pyx_v__in, void *__pyx_v__out) {
/* … */
  /* function exit code */
}

 0325: 

+0326:     fftw_execute_r2r(<fftw_plan>_plan, <double *>_in, <double *>_out)

  fftw_execute_r2r(((fftw_plan)__pyx_v__plan), ((double *)__pyx_v__in), ((double *)__pyx_v__out));

 0327: 

 0328: #    Destroyers

 0329: #    ==========

 0330: #

 0331: # Double precision

+0332: cdef void _fftw_destroy_plan(void *_plan):

static void __pyx_f_6pyrost_3bin_6pyfftw__fftw_destroy_plan(void *__pyx_v__plan) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_fftw_destroy_plan", 0);
/* … */
  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

 0333: 

+0334:     fftw_destroy_plan(<fftw_plan>_plan)

  fftw_destroy_plan(((fftw_plan)__pyx_v__plan));

 0335: 

 0336: # Function lookup tables

 0337: # ======================

 0338: # Planner table (of size the number of planners).

 0339: cdef fftw_generic_plan_guru planners[4]

 0340: 

+0341: cdef fftw_generic_plan_guru * _build_planner_list():

static __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_guru *__pyx_f_6pyrost_3bin_6pyfftw__build_planner_list(void) {
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_guru *__pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_build_planner_list", 0);
/* … */
  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0342:     planners[0] = <fftw_generic_plan_guru>&_fftw_plan_guru_dft

  (__pyx_v_6pyrost_3bin_6pyfftw_planners[0]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_guru)(&__pyx_f_6pyrost_3bin_6pyfftw__fftw_plan_guru_dft));

+0343:     planners[1] = <fftw_generic_plan_guru>&_fftw_plan_guru_dft_r2c

  (__pyx_v_6pyrost_3bin_6pyfftw_planners[1]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_guru)(&__pyx_f_6pyrost_3bin_6pyfftw__fftw_plan_guru_dft_r2c));

+0344:     planners[2] = <fftw_generic_plan_guru>&_fftw_plan_guru_dft_c2r

  (__pyx_v_6pyrost_3bin_6pyfftw_planners[2]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_guru)(&__pyx_f_6pyrost_3bin_6pyfftw__fftw_plan_guru_dft_c2r));

+0345:     planners[3] = <fftw_generic_plan_guru>&_fftw_plan_guru_r2r

  (__pyx_v_6pyrost_3bin_6pyfftw_planners[3]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_guru)(&__pyx_f_6pyrost_3bin_6pyfftw__fftw_plan_guru_r2r));

 0346: 

 0347: # Executor table (of size the number of executors)

 0348: cdef fftw_generic_execute executors[4]

 0349: 

+0350: cdef fftw_generic_execute * _build_executor_list():

static __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_execute *__pyx_f_6pyrost_3bin_6pyfftw__build_executor_list(void) {
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_execute *__pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_build_executor_list", 0);
/* … */
  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0351:     executors[0] = <fftw_generic_execute>&_fftw_execute_dft

  (__pyx_v_6pyrost_3bin_6pyfftw_executors[0]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_execute)(&__pyx_f_6pyrost_3bin_6pyfftw__fftw_execute_dft));

+0352:     executors[1] = <fftw_generic_execute>&_fftw_execute_dft_r2c

  (__pyx_v_6pyrost_3bin_6pyfftw_executors[1]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_execute)(&__pyx_f_6pyrost_3bin_6pyfftw__fftw_execute_dft_r2c));

+0353:     executors[2] = <fftw_generic_execute>&_fftw_execute_dft_c2r

  (__pyx_v_6pyrost_3bin_6pyfftw_executors[2]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_execute)(&__pyx_f_6pyrost_3bin_6pyfftw__fftw_execute_dft_c2r));

+0354:     executors[3] = <fftw_generic_execute>&_fftw_execute_r2r

  (__pyx_v_6pyrost_3bin_6pyfftw_executors[3]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_execute)(&__pyx_f_6pyrost_3bin_6pyfftw__fftw_execute_r2r));

 0355: 

 0356: # Destroyer table (of size the number of destroyers)

 0357: cdef fftw_generic_destroy_plan destroyers[1]

 0358: 

+0359: cdef fftw_generic_destroy_plan * _build_destroyer_list():

static __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_destroy_plan *__pyx_f_6pyrost_3bin_6pyfftw__build_destroyer_list(void) {
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_destroy_plan *__pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_build_destroyer_list", 0);
/* … */
  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0360:     destroyers[0] = <fftw_generic_destroy_plan>&_fftw_destroy_plan

  (__pyx_v_6pyrost_3bin_6pyfftw_destroyers[0]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_destroy_plan)(&__pyx_f_6pyrost_3bin_6pyfftw__fftw_destroy_plan));

 0361: 

 0362: # nthreads plan setters table

 0363: cdef fftw_generic_plan_with_nthreads nthreads_plan_setters[1]

 0364: 

+0365: cdef fftw_generic_plan_with_nthreads * _build_nthreads_plan_setters_list():

static __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_with_nthreads *__pyx_f_6pyrost_3bin_6pyfftw__build_nthreads_plan_setters_list(void) {
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_with_nthreads *__pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_build_nthreads_plan_setters_list", 0);
/* … */
  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0366:     nthreads_plan_setters[0] = (<fftw_generic_plan_with_nthreads>&fftw_plan_with_nthreads)

  (__pyx_v_6pyrost_3bin_6pyfftw_nthreads_plan_setters[0]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_with_nthreads)(&fftw_plan_with_nthreads));

 0367: 

 0368: # Set planner timelimits

 0369: cdef fftw_generic_set_timelimit set_timelimit_funcs[1]

 0370: 

+0371: cdef fftw_generic_set_timelimit * _build_set_timelimit_funcs_list():

static __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_set_timelimit *__pyx_f_6pyrost_3bin_6pyfftw__build_set_timelimit_funcs_list(void) {
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_set_timelimit *__pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_build_set_timelimit_funcs_list", 0);
/* … */
  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0372:     set_timelimit_funcs[0] = (<fftw_generic_set_timelimit>&fftw_set_timelimit)

  (__pyx_v_6pyrost_3bin_6pyfftw_set_timelimit_funcs[0]) = ((__pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_set_timelimit)(&fftw_set_timelimit));

 0373: 

 0374: # Data validators table

 0375: cdef validator validators[2]

 0376: 

+0377: cdef validator * _build_validators_list():

static __pyx_t_6pyrost_3bin_6pyfftw_validator *__pyx_f_6pyrost_3bin_6pyfftw__build_validators_list(void) {
  __pyx_t_6pyrost_3bin_6pyfftw_validator *__pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_build_validators_list", 0);
/* … */
  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0378:     validators[0] = &_validate_r2c_arrays

  (__pyx_v_6pyrost_3bin_6pyfftw_validators[0]) = (&__pyx_f_6pyrost_3bin_6pyfftw__validate_r2c_arrays);

+0379:     validators[1] = &_validate_c2r_arrays

  (__pyx_v_6pyrost_3bin_6pyfftw_validators[1]) = (&__pyx_f_6pyrost_3bin_6pyfftw__validate_c2r_arrays);

 0380: 

 0381: # Validator functions

 0382: # ===================

+0383: cdef bint _validate_r2c_arrays(np.ndarray input_array,

static int __pyx_f_6pyrost_3bin_6pyfftw__validate_r2c_arrays(PyArrayObject *__pyx_v_input_array, PyArrayObject *__pyx_v_output_array, int64_t *__pyx_v_axes, int64_t *__pyx_v_not_axes, int64_t __pyx_v_axes_length) {
  npy_intp *__pyx_v_in_shape;
  npy_intp *__pyx_v_out_shape;
  int64_t __pyx_v_n;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_validate_r2c_arrays", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0384:         np.ndarray output_array, int64_t *axes, int64_t *not_axes,

 0385:         int64_t axes_length):

 0386:     ''' Validates the input and output array to check for

 0387:     a valid real to complex transform.

 0388:     '''

 0389:     # We firstly need to confirm that the dimenions of the arrays

 0390:     # are the same

+0391:     if not (input_array.ndim == output_array.ndim):

  __pyx_t_1 = ((!((__pyx_v_input_array->nd == __pyx_v_output_array->nd) != 0)) != 0);
  if (__pyx_t_1) {
/* … */
  }

+0392:         return False

    __pyx_r = 0;
    goto __pyx_L0;

 0393: 

+0394:     in_shape = input_array.shape

  __pyx_t_2 = __pyx_v_input_array->dimensions;
  __pyx_v_in_shape = __pyx_t_2;

+0395:     out_shape = output_array.shape

  __pyx_t_2 = __pyx_v_output_array->dimensions;
  __pyx_v_out_shape = __pyx_t_2;

 0396: 

+0397:     for n in range(axes_length - 1):

  __pyx_t_3 = (__pyx_v_axes_length - 1);
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_n = __pyx_t_5;

+0398:         if not out_shape[axes[n]] == in_shape[axes[n]]:

    __pyx_t_1 = ((!(((__pyx_v_out_shape[(__pyx_v_axes[__pyx_v_n])]) == (__pyx_v_in_shape[(__pyx_v_axes[__pyx_v_n])])) != 0)) != 0);
    if (__pyx_t_1) {
/* … */
    }
  }

+0399:             return False

      __pyx_r = 0;
      goto __pyx_L0;

 0400: 

 0401:     # The critical axis is the last of those over which the

 0402:     # FFT is taken.

+0403:     if not (out_shape[axes[axes_length-1]]

  __pyx_t_1 = ((!(((__pyx_v_out_shape[(__pyx_v_axes[(__pyx_v_axes_length - 1)])]) == (((__pyx_v_in_shape[(__pyx_v_axes[(__pyx_v_axes_length - 1)])]) / 2) + 1)) != 0)) != 0);
  if (__pyx_t_1) {
/* … */
  }

 0404:             == in_shape[axes[axes_length-1]]//2 + 1):

+0405:         return False

    __pyx_r = 0;
    goto __pyx_L0;

 0406: 

+0407:     for n in range(input_array.ndim - axes_length):

  __pyx_t_3 = (__pyx_v_input_array->nd - __pyx_v_axes_length);
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_n = __pyx_t_5;

+0408:         if not out_shape[not_axes[n]] == in_shape[not_axes[n]]:

    __pyx_t_1 = ((!(((__pyx_v_out_shape[(__pyx_v_not_axes[__pyx_v_n])]) == (__pyx_v_in_shape[(__pyx_v_not_axes[__pyx_v_n])])) != 0)) != 0);
    if (__pyx_t_1) {
/* … */
    }
  }

+0409:             return False

      __pyx_r = 0;
      goto __pyx_L0;

 0410: 

+0411:     return True

  __pyx_r = 1;
  goto __pyx_L0;

 0412: 

+0413: cdef bint _validate_c2r_arrays(np.ndarray input_array,

static int __pyx_f_6pyrost_3bin_6pyfftw__validate_c2r_arrays(PyArrayObject *__pyx_v_input_array, PyArrayObject *__pyx_v_output_array, int64_t *__pyx_v_axes, int64_t *__pyx_v_not_axes, int64_t __pyx_v_axes_length) {
  npy_intp *__pyx_v_in_shape;
  npy_intp *__pyx_v_out_shape;
  int64_t __pyx_v_n;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_validate_c2r_arrays", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0414:         np.ndarray output_array, int64_t *axes, int64_t *not_axes,

 0415:         int64_t axes_length):

 0416:     ''' Validates the input and output array to check for

 0417:     a valid complex to real transform.

 0418:     '''

 0419: 

 0420:     # We firstly need to confirm that the dimenions of the arrays

 0421:     # are the same

+0422:     if not (input_array.ndim == output_array.ndim):

  __pyx_t_1 = ((!((__pyx_v_input_array->nd == __pyx_v_output_array->nd) != 0)) != 0);
  if (__pyx_t_1) {
/* … */
  }

+0423:         return False

    __pyx_r = 0;
    goto __pyx_L0;

 0424: 

+0425:     in_shape = input_array.shape

  __pyx_t_2 = __pyx_v_input_array->dimensions;
  __pyx_v_in_shape = __pyx_t_2;

+0426:     out_shape = output_array.shape

  __pyx_t_2 = __pyx_v_output_array->dimensions;
  __pyx_v_out_shape = __pyx_t_2;

 0427: 

+0428:     for n in range(axes_length - 1):

  __pyx_t_3 = (__pyx_v_axes_length - 1);
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_n = __pyx_t_5;

+0429:         if not in_shape[axes[n]] == out_shape[axes[n]]:

    __pyx_t_1 = ((!(((__pyx_v_in_shape[(__pyx_v_axes[__pyx_v_n])]) == (__pyx_v_out_shape[(__pyx_v_axes[__pyx_v_n])])) != 0)) != 0);
    if (__pyx_t_1) {
/* … */
    }
  }

+0430:             return False

      __pyx_r = 0;
      goto __pyx_L0;

 0431: 

 0432:     # The critical axis is the last of those over which the

 0433:     # FFT is taken.

+0434:     if not (in_shape[axes[axes_length-1]]

  __pyx_t_1 = ((!(((__pyx_v_in_shape[(__pyx_v_axes[(__pyx_v_axes_length - 1)])]) == (((__pyx_v_out_shape[(__pyx_v_axes[(__pyx_v_axes_length - 1)])]) / 2) + 1)) != 0)) != 0);
  if (__pyx_t_1) {
/* … */
  }

 0435:             == out_shape[axes[axes_length-1]]//2 + 1):

+0436:         return False

    __pyx_r = 0;
    goto __pyx_L0;

 0437: 

+0438:     for n in range(input_array.ndim - axes_length):

  __pyx_t_3 = (__pyx_v_input_array->nd - __pyx_v_axes_length);
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_n = __pyx_t_5;

+0439:         if not in_shape[not_axes[n]] == out_shape[not_axes[n]]:

    __pyx_t_1 = ((!(((__pyx_v_in_shape[(__pyx_v_not_axes[__pyx_v_n])]) == (__pyx_v_out_shape[(__pyx_v_not_axes[__pyx_v_n])])) != 0)) != 0);
    if (__pyx_t_1) {
/* … */
    }
  }

+0440:             return False

      __pyx_r = 0;
      goto __pyx_L0;

 0441: 

+0442:     return True

  __pyx_r = 1;
  goto __pyx_L0;

 0443: 

 0444: # Shape lookup functions

 0445: # ======================

+0446: def _lookup_shape_r2c_arrays(input_array, output_array):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_13_lookup_shape_r2c_arrays(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_12_lookup_shape_r2c_arrays[] = "_lookup_shape_r2c_arrays(input_array, output_array)";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_13_lookup_shape_r2c_arrays = {"_lookup_shape_r2c_arrays", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6pyrost_3bin_6pyfftw_13_lookup_shape_r2c_arrays, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6pyrost_3bin_6pyfftw_12_lookup_shape_r2c_arrays};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_13_lookup_shape_r2c_arrays(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_input_array = 0;
  CYTHON_UNUSED PyObject *__pyx_v_output_array = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_lookup_shape_r2c_arrays (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_input_array,&__pyx_n_s_output_array,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_array)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_output_array)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("_lookup_shape_r2c_arrays", 1, 2, 2, 1); __PYX_ERR(0, 446, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_lookup_shape_r2c_arrays") < 0)) __PYX_ERR(0, 446, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_input_array = values[0];
    __pyx_v_output_array = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_lookup_shape_r2c_arrays", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 446, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw._lookup_shape_r2c_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_12_lookup_shape_r2c_arrays(__pyx_self, __pyx_v_input_array, __pyx_v_output_array);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_12_lookup_shape_r2c_arrays(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_input_array, CYTHON_UNUSED PyObject *__pyx_v_output_array) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_lookup_shape_r2c_arrays", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw._lookup_shape_r2c_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__50 = PyTuple_Pack(2, __pyx_n_s_input_array, __pyx_n_s_output_array); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 446, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__50);
  __Pyx_GIVEREF(__pyx_tuple__50);
/* … */
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_13_lookup_shape_r2c_arrays, 0, __pyx_n_s_lookup_shape_r2c_arrays, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__51)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 446, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_lookup_shape_r2c_arrays, __pyx_t_1) < 0) __PYX_ERR(0, 446, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_codeobj__51 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__50, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_lookup_shape_r2c_arrays, 446, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__51)) __PYX_ERR(0, 446, __pyx_L1_error)

+0447:     return input_array.shape

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 447, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0448: 

+0449: def _lookup_shape_c2r_arrays(input_array, output_array):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_15_lookup_shape_c2r_arrays(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_14_lookup_shape_c2r_arrays[] = "_lookup_shape_c2r_arrays(input_array, output_array)";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_15_lookup_shape_c2r_arrays = {"_lookup_shape_c2r_arrays", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6pyrost_3bin_6pyfftw_15_lookup_shape_c2r_arrays, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6pyrost_3bin_6pyfftw_14_lookup_shape_c2r_arrays};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_15_lookup_shape_c2r_arrays(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  CYTHON_UNUSED PyObject *__pyx_v_input_array = 0;
  PyObject *__pyx_v_output_array = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_lookup_shape_c2r_arrays (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_input_array,&__pyx_n_s_output_array,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_array)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_output_array)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("_lookup_shape_c2r_arrays", 1, 2, 2, 1); __PYX_ERR(0, 449, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_lookup_shape_c2r_arrays") < 0)) __PYX_ERR(0, 449, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_input_array = values[0];
    __pyx_v_output_array = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_lookup_shape_c2r_arrays", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 449, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw._lookup_shape_c2r_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_14_lookup_shape_c2r_arrays(__pyx_self, __pyx_v_input_array, __pyx_v_output_array);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_14_lookup_shape_c2r_arrays(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_input_array, PyObject *__pyx_v_output_array) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_lookup_shape_c2r_arrays", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw._lookup_shape_c2r_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__52 = PyTuple_Pack(2, __pyx_n_s_input_array, __pyx_n_s_output_array); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 449, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__52);
  __Pyx_GIVEREF(__pyx_tuple__52);
/* … */
  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_15_lookup_shape_c2r_arrays, 0, __pyx_n_s_lookup_shape_c2r_arrays, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__53)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 449, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_lookup_shape_c2r_arrays, __pyx_t_1) < 0) __PYX_ERR(0, 449, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_codeobj__53 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_lookup_shape_c2r_arrays, 449, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__53)) __PYX_ERR(0, 449, __pyx_L1_error)

+0450:     return output_array.shape

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 450, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0451: 

 0452: # fftw_schemes is a dictionary with a mapping from a keys,

 0453: # which are a tuple of the string representation of numpy

 0454: # dtypes to a scheme name.

 0455: #

 0456: # scheme_functions is a dictionary of functions, either

 0457: # an index to the array of functions in the case of

 0458: # 'planner', 'executor' and 'generic_precision' or a callable

 0459: # in the case of 'validator' (generic_precision is a catchall for

 0460: # functions that only change based on the precision changing -

 0461: # i.e the prefix fftw, fftwl and fftwf is the only bit that changes).

 0462: #

 0463: # The array indices refer to the relevant functions for each scheme,

 0464: # the tables to which are defined above.

 0465: #

 0466: # The 'validator' function is a callable for validating the arrays

 0467: # that has the following signature:

 0468: # bool callable(ndarray in_array, ndarray out_array, axes, not_axes)

 0469: # and checks that the arrays are a valid pair. If it is set to None,

 0470: # then the default check is applied, which confirms that the arrays

 0471: # have the same shape.

 0472: #

 0473: # The 'fft_shape_lookup' function is a callable for returning the

 0474: # FFT shape - that is, an array that describes the length of the

 0475: # fft along each axis. It has the following signature:

 0476: # fft_shape = fft_shape_lookup(in_array, out_array)

 0477: # (note that this does not correspond to the lengths of the FFT that is

 0478: # actually taken, it's the lengths of the FFT that *could* be taken

 0479: # along each axis. It's necessary because the real FFT has a length

 0480: # that is different to the length of the input array).

 0481: 

 0482: cdef object fftw_schemes

 0483: fftw_schemes = {

+0484:         (np.dtype('complex128'), np.dtype('complex128')): ('c2c', '64'),

  __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 484, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 484, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 484, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 484, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
/* … */
  __pyx_tuple__54 = PyTuple_Pack(1, __pyx_n_u_complex128); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 484, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__54);
  __Pyx_GIVEREF(__pyx_tuple__54);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_tuple__55) < 0) __PYX_ERR(0, 484, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_tuple__55 = PyTuple_Pack(2, __pyx_n_u_c2c, __pyx_kp_u_64); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 484, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__55);
  __Pyx_GIVEREF(__pyx_tuple__55);

+0485:         (np.dtype('float64'), np.dtype('complex128')): ('r2c', '64'),

  __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 485, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 485, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3);
  __pyx_t_4 = 0;
  __pyx_t_3 = 0;
/* … */
  __pyx_tuple__56 = PyTuple_Pack(1, __pyx_n_u_float64); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 485, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__56);
  __Pyx_GIVEREF(__pyx_tuple__56);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_tuple__57) < 0) __PYX_ERR(0, 484, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_tuple__57 = PyTuple_Pack(2, __pyx_n_u_r2c, __pyx_kp_u_64); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(0, 485, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__57);
  __Pyx_GIVEREF(__pyx_tuple__57);

+0486:         (np.dtype('complex128'), np.dtype('float64')): ('c2r', '64')}

  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 486, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 486, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 486, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_tuple__58) < 0) __PYX_ERR(0, 484, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_XGOTREF(__pyx_v_6pyrost_3bin_6pyfftw_fftw_schemes);
  __Pyx_DECREF_SET(__pyx_v_6pyrost_3bin_6pyfftw_fftw_schemes, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;
/* … */
  __pyx_tuple__58 = PyTuple_Pack(2, __pyx_n_u_c2r, __pyx_kp_u_64); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 486, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__58);
  __Pyx_GIVEREF(__pyx_tuple__58);

 0487: 

 0488: cdef object fftw_default_output

 0489: fftw_default_output = {

+0490:     np.dtype('float64'): np.dtype('complex128'),

  __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_t_3) < 0) __PYX_ERR(0, 490, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0491:     np.dtype('complex128'): np.dtype('complex128')}

  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5numpy_dtype), __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_t_4) < 0) __PYX_ERR(0, 490, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_XGOTREF(__pyx_v_6pyrost_3bin_6pyfftw_fftw_default_output);
  __Pyx_DECREF_SET(__pyx_v_6pyrost_3bin_6pyfftw_fftw_default_output, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;

 0492: 

 0493: cdef object scheme_directions

 0494: scheme_directions = {

+0495:         ('c2c', '64'): ['FFTW_FORWARD', 'FFTW_BACKWARD'],

  __pyx_t_1 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 495, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 495, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_n_u_FFTW_FORWARD);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_FORWARD);
  PyList_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_FFTW_FORWARD);
  __Pyx_INCREF(__pyx_n_u_FFTW_BACKWARD);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_BACKWARD);
  PyList_SET_ITEM(__pyx_t_4, 1, __pyx_n_u_FFTW_BACKWARD);
  if (PyDict_SetItem(__pyx_t_1, __pyx_tuple__55, __pyx_t_4) < 0) __PYX_ERR(0, 495, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0496:         ('r2c', '64'): ['FFTW_FORWARD'],

  __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 496, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_n_u_FFTW_FORWARD);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_FORWARD);
  PyList_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_FFTW_FORWARD);
  if (PyDict_SetItem(__pyx_t_1, __pyx_tuple__57, __pyx_t_4) < 0) __PYX_ERR(0, 495, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0497:         ('c2r', '64'): ['FFTW_BACKWARD'],

  __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 497, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_n_u_FFTW_BACKWARD);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_BACKWARD);
  PyList_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_FFTW_BACKWARD);
  if (PyDict_SetItem(__pyx_t_1, __pyx_tuple__58, __pyx_t_4) < 0) __PYX_ERR(0, 495, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0498:         ('r2r', '64'): ['FFTW_REDFT00', 'FFTW_REDFT10', 'FFTW_REDFT01',

  __pyx_t_4 = PyList_New(8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 498, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_n_u_FFTW_REDFT00);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_REDFT00);
  PyList_SET_ITEM(__pyx_t_4, 0, __pyx_n_u_FFTW_REDFT00);
  __Pyx_INCREF(__pyx_n_u_FFTW_REDFT10);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_REDFT10);
  PyList_SET_ITEM(__pyx_t_4, 1, __pyx_n_u_FFTW_REDFT10);
  __Pyx_INCREF(__pyx_n_u_FFTW_REDFT01);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_REDFT01);
  PyList_SET_ITEM(__pyx_t_4, 2, __pyx_n_u_FFTW_REDFT01);
  __Pyx_INCREF(__pyx_n_u_FFTW_REDFT11);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_REDFT11);
  PyList_SET_ITEM(__pyx_t_4, 3, __pyx_n_u_FFTW_REDFT11);
  __Pyx_INCREF(__pyx_n_u_FFTW_RODFT00);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_RODFT00);
  PyList_SET_ITEM(__pyx_t_4, 4, __pyx_n_u_FFTW_RODFT00);
  __Pyx_INCREF(__pyx_n_u_FFTW_RODFT10);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_RODFT10);
  PyList_SET_ITEM(__pyx_t_4, 5, __pyx_n_u_FFTW_RODFT10);
  __Pyx_INCREF(__pyx_n_u_FFTW_RODFT01);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_RODFT01);
  PyList_SET_ITEM(__pyx_t_4, 6, __pyx_n_u_FFTW_RODFT01);
  __Pyx_INCREF(__pyx_n_u_FFTW_RODFT11);
  __Pyx_GIVEREF(__pyx_n_u_FFTW_RODFT11);
  PyList_SET_ITEM(__pyx_t_4, 7, __pyx_n_u_FFTW_RODFT11);
  if (PyDict_SetItem(__pyx_t_1, __pyx_tuple__59, __pyx_t_4) < 0) __PYX_ERR(0, 495, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_XGOTREF(__pyx_v_6pyrost_3bin_6pyfftw_scheme_directions);
  __Pyx_DECREF_SET(__pyx_v_6pyrost_3bin_6pyfftw_scheme_directions, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;
/* … */
  __pyx_tuple__59 = PyTuple_Pack(2, __pyx_n_u_r2r, __pyx_kp_u_64); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 498, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__59);
  __Pyx_GIVEREF(__pyx_tuple__59);

 0499:                         'FFTW_REDFT11', 'FFTW_RODFT00', 'FFTW_RODFT10',

 0500:                         'FFTW_RODFT01', 'FFTW_RODFT11']}

 0501: 

 0502: # In the following, -1 denotes using the default. A segfault has been

 0503: # reported on some systems when this is set to None. It seems

 0504: # sufficiently trivial to use -1 in place of None, especially given

 0505: # that scheme_functions is an internal cdef object.

+0506: cdef object _scheme_functions = {}

  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 506, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_XGOTREF(__pyx_v_6pyrost_3bin_6pyfftw__scheme_functions);
  __Pyx_DECREF_SET(__pyx_v_6pyrost_3bin_6pyfftw__scheme_functions, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;

+0507: _scheme_functions.update({

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_6pyrost_3bin_6pyfftw__scheme_functions, __pyx_n_s_update); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 507, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
/* … */
  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0508: ('c2c', '64'): {'planner': 0, 'executor':0, 'generic_precision':0,

  __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 508, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 508, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_planner, __pyx_int_0) < 0) __PYX_ERR(0, 508, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_executor, __pyx_int_0) < 0) __PYX_ERR(0, 508, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_generic_precision, __pyx_int_0) < 0) __PYX_ERR(0, 508, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_validator, __pyx_int_neg_1) < 0) __PYX_ERR(0, 508, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_fft_shape_lookup, __pyx_int_neg_1) < 0) __PYX_ERR(0, 508, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_tuple__55, __pyx_t_3) < 0) __PYX_ERR(0, 508, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 0509:     'validator': -1, 'fft_shape_lookup': -1},

+0510: ('r2c', '64'): {'planner': 1, 'executor': 1, 'generic_precision':0,

  __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 510, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_planner, __pyx_int_1) < 0) __PYX_ERR(0, 510, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_executor, __pyx_int_1) < 0) __PYX_ERR(0, 510, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_generic_precision, __pyx_int_0) < 0) __PYX_ERR(0, 510, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_validator, __pyx_int_0) < 0) __PYX_ERR(0, 510, __pyx_L1_error)

 0511:     'validator': 0,

+0512:     'fft_shape_lookup': _lookup_shape_r2c_arrays},

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_lookup_shape_r2c_arrays); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 512, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_fft_shape_lookup, __pyx_t_2) < 0) __PYX_ERR(0, 510, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_t_4, __pyx_tuple__57, __pyx_t_3) < 0) __PYX_ERR(0, 508, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0513: ('c2r', '64'): {'planner': 2, 'executor': 2, 'generic_precision':0,

  __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 513, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_planner, __pyx_int_2) < 0) __PYX_ERR(0, 513, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_executor, __pyx_int_2) < 0) __PYX_ERR(0, 513, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_generic_precision, __pyx_int_0) < 0) __PYX_ERR(0, 513, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_validator, __pyx_int_1) < 0) __PYX_ERR(0, 513, __pyx_L1_error)

 0514:     'validator': 1,

+0515:     'fft_shape_lookup': _lookup_shape_c2r_arrays},

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_lookup_shape_c2r_arrays); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_fft_shape_lookup, __pyx_t_2) < 0) __PYX_ERR(0, 513, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_t_4, __pyx_tuple__58, __pyx_t_3) < 0) __PYX_ERR(0, 508, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0516: ('r2r', '64'): {'planner': 3, 'executor': 3, 'generic_precision':0,

  __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 516, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_planner, __pyx_int_3) < 0) __PYX_ERR(0, 516, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_executor, __pyx_int_3) < 0) __PYX_ERR(0, 516, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_generic_precision, __pyx_int_0) < 0) __PYX_ERR(0, 516, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_validator, __pyx_int_neg_1) < 0) __PYX_ERR(0, 516, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_fft_shape_lookup, __pyx_int_neg_1) < 0) __PYX_ERR(0, 516, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_tuple__59, __pyx_t_3) < 0) __PYX_ERR(0, 508, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 0517:     'validator': -1, 'fft_shape_lookup': -1}})

 0518: 

+0519: def scheme_functions(scheme):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_17scheme_functions(PyObject *__pyx_self, PyObject *__pyx_v_scheme); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_16scheme_functions[] = "scheme_functions(scheme)";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_17scheme_functions = {"scheme_functions", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_17scheme_functions, METH_O, __pyx_doc_6pyrost_3bin_6pyfftw_16scheme_functions};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_17scheme_functions(PyObject *__pyx_self, PyObject *__pyx_v_scheme) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scheme_functions (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_16scheme_functions(__pyx_self, ((PyObject *)__pyx_v_scheme));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_16scheme_functions(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_scheme) {
  PyObject *__pyx_v_msg = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scheme_functions", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.scheme_functions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_msg);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__60 = PyTuple_Pack(2, __pyx_n_s_scheme, __pyx_n_s_msg); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 519, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__60);
  __Pyx_GIVEREF(__pyx_tuple__60);
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_17scheme_functions, 0, __pyx_n_s_scheme_functions, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__61)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 519, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_scheme_functions, __pyx_t_3) < 0) __PYX_ERR(0, 519, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__61 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__60, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_scheme_functions, 519, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__61)) __PYX_ERR(0, 519, __pyx_L1_error)

+0520:     if scheme in _scheme_functions:

  __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_scheme, __pyx_v_6pyrost_3bin_6pyfftw__scheme_functions, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 520, __pyx_L1_error)
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (likely(__pyx_t_2)) {
/* … */
  }

+0521:         return _scheme_functions[scheme]

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_6pyrost_3bin_6pyfftw__scheme_functions, __pyx_v_scheme); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 521, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_r = __pyx_t_3;
    __pyx_t_3 = 0;
    goto __pyx_L0;

 0522:     else:

+0523:         msg = "The scheme '%s' is not supported." % str(scheme)

  /*else*/ {
    __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_v_scheme); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyUnicode_Format(__pyx_kp_u_The_scheme_s_is_not_supported, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_msg = ((PyObject*)__pyx_t_4);
    __pyx_t_4 = 0;

+0524:         raise NotImplementedError(msg)

    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_v_msg); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 524, __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_ERR(0, 524, __pyx_L1_error)
  }

 0525: 

 0526: # Set the cleanup routine

+0527: cdef void _cleanup():

static void __pyx_f_6pyrost_3bin_6pyfftw__cleanup(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_cleanup", 0);
/* … */
  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

+0528:     fftw_cleanup()

  fftw_cleanup();

+0529:     fftw_cleanup_threads()

  fftw_cleanup_threads();

 0530: 

 0531: # Initialize the module

 0532: 

 0533: # Define the functions

+0534: _build_planner_list()

  (void)(__pyx_f_6pyrost_3bin_6pyfftw__build_planner_list());

+0535: _build_destroyer_list()

  (void)(__pyx_f_6pyrost_3bin_6pyfftw__build_destroyer_list());

+0536: _build_executor_list()

  (void)(__pyx_f_6pyrost_3bin_6pyfftw__build_executor_list());

+0537: _build_nthreads_plan_setters_list()

  (void)(__pyx_f_6pyrost_3bin_6pyfftw__build_nthreads_plan_setters_list());

+0538: _build_validators_list()

  (void)(__pyx_f_6pyrost_3bin_6pyfftw__build_validators_list());

+0539: _build_set_timelimit_funcs_list()

  (void)(__pyx_f_6pyrost_3bin_6pyfftw__build_set_timelimit_funcs_list());

 0540: 

+0541: fftw_init_threads()

  fftw_init_threads();

 0542: 

+0543: Py_AtExit(_cleanup)

  (void)(Py_AtExit(__pyx_f_6pyrost_3bin_6pyfftw__cleanup));

 0544: 

 0545: # Helper functions

+0546: cdef void make_axes_unique(int64_t *axes, int64_t axes_length,

static void __pyx_f_6pyrost_3bin_6pyfftw_make_axes_unique(int64_t *__pyx_v_axes, int64_t __pyx_v_axes_length, int64_t **__pyx_v_unique_axes, int64_t **__pyx_v_not_axes, int64_t __pyx_v_dimensions, int64_t *__pyx_v_unique_axes_length) {
  int64_t __pyx_v_unique_axes_count;
  int64_t __pyx_v_holding_offset;
  int64_t *__pyx_v_axes_holding;
  int64_t *__pyx_v_axes_holding_offset;
  int64_t __pyx_v_n;
  int64_t __pyx_v_not_axes_count;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("make_axes_unique", 0);
/* … */
  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

 0547:         int64_t **unique_axes, int64_t **not_axes, int64_t dimensions,

 0548:         int64_t *unique_axes_length):

 0549:     ''' Takes an array of axes and makes that array unique, returning

 0550:     the unique array in unique_axes. It also creates and fills another

 0551:     array, not_axes, with those axes that are not included in unique_axes.

 0552: 

 0553:     unique_axes_length is updated with the length of unique_axes.

 0554: 

 0555:     dimensions is the number of dimensions to which the axes array

 0556:     might refer.

 0557: 

 0558:     It is the responsibility of the caller to free unique_axes and not_axes.

 0559:     '''

 0560: 

+0561:     cdef int64_t unique_axes_count = 0

  __pyx_v_unique_axes_count = 0;

+0562:     cdef int64_t holding_offset = 0

  __pyx_v_holding_offset = 0;

 0563: 

 0564:     cdef int64_t *axes_holding = (

+0565:             <int64_t *>calloc(dimensions, sizeof(int64_t)))

  __pyx_v_axes_holding = ((int64_t *)calloc(__pyx_v_dimensions, (sizeof(int64_t))));

 0566:     cdef int64_t *axes_holding_offset = (

+0567:             <int64_t *>calloc(dimensions, sizeof(int64_t)))

  __pyx_v_axes_holding_offset = ((int64_t *)calloc(__pyx_v_dimensions, (sizeof(int64_t))));

 0568: 

+0569:     for n in range(dimensions):

  __pyx_t_1 = __pyx_v_dimensions;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_n = __pyx_t_3;

+0570:         axes_holding[n] = -1

    (__pyx_v_axes_holding[__pyx_v_n]) = -1L;
  }

 0571: 

 0572:     # Iterate over all the axes and store each index if it hasn't already

 0573:     # been stored (this keeps one and only one and the first index to axes

 0574:     # i.e. storing the unique set of entries).

 0575:     #

 0576:     # axes_holding_offset holds the shift due to repeated axes

+0577:     for n in range(axes_length):

  __pyx_t_1 = __pyx_v_axes_length;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_n = __pyx_t_3;

+0578:         if axes_holding[axes[n]] == -1:

    __pyx_t_4 = (((__pyx_v_axes_holding[(__pyx_v_axes[__pyx_v_n])]) == -1L) != 0);
    if (__pyx_t_4) {
/* … */
      goto __pyx_L7;
    }

+0579:             axes_holding[axes[n]] = n

      (__pyx_v_axes_holding[(__pyx_v_axes[__pyx_v_n])]) = __pyx_v_n;

+0580:             axes_holding_offset[axes[n]] = holding_offset

      (__pyx_v_axes_holding_offset[(__pyx_v_axes[__pyx_v_n])]) = __pyx_v_holding_offset;

+0581:             unique_axes_count += 1

      __pyx_v_unique_axes_count = (__pyx_v_unique_axes_count + 1);

 0582:         else:

+0583:             holding_offset += 1

    /*else*/ {
      __pyx_v_holding_offset = (__pyx_v_holding_offset + 1);
    }
    __pyx_L7:;
  }

 0584: 

+0585:     unique_axes[0] = <int64_t *>malloc(

  (__pyx_v_unique_axes[0]) = ((int64_t *)malloc((__pyx_v_unique_axes_count * (sizeof(int64_t)))));

 0586:             unique_axes_count * sizeof(int64_t))

 0587: 

+0588:     not_axes[0] = <int64_t *>malloc(

  (__pyx_v_not_axes[0]) = ((int64_t *)malloc(((__pyx_v_dimensions - __pyx_v_unique_axes_count) * (sizeof(int64_t)))));

 0589:             (dimensions - unique_axes_count) * sizeof(int64_t))

 0590: 

 0591:     # Now we need to write back the unique axes to a tmp axes

+0592:     cdef int64_t not_axes_count = 0

  __pyx_v_not_axes_count = 0;

 0593: 

+0594:     for n in range(dimensions):

  __pyx_t_1 = __pyx_v_dimensions;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_n = __pyx_t_3;

+0595:         if axes_holding[n] != -1:

    __pyx_t_4 = (((__pyx_v_axes_holding[__pyx_v_n]) != -1L) != 0);
    if (__pyx_t_4) {
/* … */
      goto __pyx_L10;
    }

+0596:             unique_axes[0][axes_holding[n] - axes_holding_offset[n]] = (

      ((__pyx_v_unique_axes[0])[((__pyx_v_axes_holding[__pyx_v_n]) - (__pyx_v_axes_holding_offset[__pyx_v_n]))]) = (__pyx_v_axes[(__pyx_v_axes_holding[__pyx_v_n])]);

 0597:                     axes[axes_holding[n]])

 0598: 

 0599:         else:

+0600:             not_axes[0][not_axes_count] = n

    /*else*/ {
      ((__pyx_v_not_axes[0])[__pyx_v_not_axes_count]) = __pyx_v_n;

+0601:             not_axes_count += 1

      __pyx_v_not_axes_count = (__pyx_v_not_axes_count + 1);
    }
    __pyx_L10:;
  }

 0602: 

+0603:     free(axes_holding)

  free(__pyx_v_axes_holding);

+0604:     free(axes_holding_offset)

  free(__pyx_v_axes_holding_offset);

 0605: 

+0606:     unique_axes_length[0] = unique_axes_count

  (__pyx_v_unique_axes_length[0]) = __pyx_v_unique_axes_count;

 0607: 

 0608: 

 0609: # The External Interface

 0610: # ======================

 0611: #

+0612: cdef class FFTW:

struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW {
  PyObject_HEAD
  struct __pyx_vtabstruct_6pyrost_3bin_6pyfftw_FFTW *__pyx_vtab;
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_guru _fftw_planner;
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_execute _fftw_execute;
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_destroy_plan _fftw_destroy;
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_with_nthreads _nthreads_plan_setter;
  void *_plan;
  PyArrayObject *_input_array;
  PyArrayObject *_output_array;
  int *_direction;
  unsigned int _flags;
  int _simd_allowed;
  int _input_array_alignment;
  int _output_array_alignment;
  int _use_threads;
  PyObject *_input_item_strides;
  PyObject *_input_strides;
  PyObject *_output_item_strides;
  PyObject *_output_strides;
  PyObject *_input_shape;
  PyObject *_output_shape;
  PyObject *_input_dtype;
  PyObject *_output_dtype;
  PyObject *_flags_used;
  double _normalisation_scaling;
  double _sqrt_normalisation_scaling;
  int _rank;
  __pyx_t_6pyrost_3bin_6pyfftw__fftw_iodim *_dims;
  int _howmany_rank;
  __pyx_t_6pyrost_3bin_6pyfftw__fftw_iodim *_howmany_dims;
  int64_t *_axes;
  int64_t *_not_axes;
  int64_t _total_size;
  int _normalise_idft;
  int _ortho;
};



struct __pyx_vtabstruct_6pyrost_3bin_6pyfftw_FFTW {
  PyObject *(*update_arrays)(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *, PyObject *, PyObject *, int __pyx_skip_dispatch);
  PyObject *(*_update_arrays)(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *, PyArrayObject *, PyArrayObject *);
  PyObject *(*execute)(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *, int __pyx_skip_dispatch);
};
static struct __pyx_vtabstruct_6pyrost_3bin_6pyfftw_FFTW *__pyx_vtabptr_6pyrost_3bin_6pyfftw_FFTW;

 0613:     '''

 0614:     FFTW is a class for computing a variety of discrete Fourier

 0615:     transforms of multidimensional, strided arrays using the FFTW

 0616:     library. The interface is designed to be somewhat pythonic, with

 0617:     the correct transform being inferred from the dtypes of the passed

 0618:     arrays.

 0619: 

 0620:     The exact scheme may be either directly specified with the

 0621:     ``direction`` parameter or inferred from the dtypes and relative

 0622:     shapes of the input arrays. Information on which shapes and dtypes

 0623:     imply which transformations is available in the :ref:`FFTW schemes

 0624:     <scheme_table>`. If a match is found, the plan corresponding to that

 0625:     scheme is created, operating on the arrays that are passed in. If no

 0626:     scheme can be created then a ``ValueError`` is raised.

 0627: 

 0628:     The actual transformation is performed by calling the

 0629:     :meth:`~pyfftw.FFTW.execute` method.

 0630: 

 0631:     The arrays can be updated by calling the

 0632:     :meth:`~pyfftw.FFTW.update_arrays` method.

 0633: 

 0634:     The created instance of the class is itself callable, and can perform

 0635:     the execution of the FFT, both with or without array updates, returning

 0636:     the result of the FFT. Unlike calling the :meth:`~pyfftw.FFTW.execute`

 0637:     method, calling the class instance will also optionally normalise the

 0638:     output as necessary. Additionally, calling with an input array update

 0639:     will also coerce that array to be the correct dtype.

 0640: 

 0641:     See the documentation on the :meth:`~pyfftw.FFTW.__call__` method

 0642:     for more information.

 0643:     '''

 0644:     # Each of these function pointers simply

 0645:     # points to a chosen fftw wrapper function

 0646:     cdef fftw_generic_plan_guru _fftw_planner

 0647:     cdef fftw_generic_execute _fftw_execute

 0648:     cdef fftw_generic_destroy_plan _fftw_destroy

 0649:     cdef fftw_generic_plan_with_nthreads _nthreads_plan_setter

 0650: 

 0651:     # The plan is typecast when it is created or used

 0652:     # within the wrapper functions

 0653:     cdef void *_plan

 0654: 

 0655:     cdef np.ndarray _input_array

 0656:     cdef np.ndarray _output_array

 0657:     cdef int *_direction

 0658:     cdef unsigned _flags

 0659: 

 0660:     cdef bint _simd_allowed

 0661:     cdef int _input_array_alignment

 0662:     cdef int _output_array_alignment

 0663:     cdef bint _use_threads

 0664: 

 0665:     cdef object _input_item_strides

 0666:     cdef object _input_strides

 0667:     cdef object _output_item_strides

 0668:     cdef object _output_strides

 0669:     cdef object _input_shape

 0670:     cdef object _output_shape

 0671:     cdef object _input_dtype

 0672:     cdef object _output_dtype

 0673:     cdef object _flags_used

 0674: 

 0675:     cdef double _normalisation_scaling

 0676:     cdef double _sqrt_normalisation_scaling

 0677: 

 0678:     cdef int _rank

 0679:     cdef _fftw_iodim *_dims

 0680:     cdef int _howmany_rank

 0681:     cdef _fftw_iodim *_howmany_dims

 0682: 

 0683:     cdef int64_t *_axes

 0684:     cdef int64_t *_not_axes

 0685: 

 0686:     cdef int64_t _total_size

 0687: 

 0688:     cdef bint _normalise_idft

 0689:     cdef bint _ortho

 0690: 

+0691:     def _get_N(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_1_get_N(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW__get_N[] = "FFTW._get_N(self)\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 PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_1_get_N = {"_get_N", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_1_get_N, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW__get_N};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_1_get_N(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_N (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW__get_N(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW__get_N(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_N", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW._get_N", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__62 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 691, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__62);
  __Pyx_GIVEREF(__pyx_tuple__62);
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_1_get_N, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_N, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__63)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 691, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_N, __pyx_t_3) < 0) __PYX_ERR(0, 691, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__63 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__62, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_N, 691, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__63)) __PYX_ERR(0, 691, __pyx_L1_error)

 0692:         '''

 0693:         The product of the lengths of the DFT over all DFT axes.

 0694:         1/N is the normalisation constant. For any input array A,

 0695:         and for any set of axes, 1/N * ifft(fft(A)) = A

 0696:         '''

+0697:         return self._total_size

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_self->_total_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 697, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0698: 

+0699:     N = property(_get_N)

  __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_N); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 699, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 699, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_N, __pyx_t_4) < 0) __PYX_ERR(0, 699, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0700: 

+0701:     def _get_simd_aligned(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_3_get_simd_aligned(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_2_get_simd_aligned[] = "FFTW._get_simd_aligned(self)\n\n        Return whether or not this FFTW object requires simd aligned\n        input and output data.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_3_get_simd_aligned = {"_get_simd_aligned", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_3_get_simd_aligned, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_2_get_simd_aligned};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_3_get_simd_aligned(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_simd_aligned (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_2_get_simd_aligned(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_2_get_simd_aligned(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_simd_aligned", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW._get_simd_aligned", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__64 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 701, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__64);
  __Pyx_GIVEREF(__pyx_tuple__64);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_3_get_simd_aligned, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_simd_aligned, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__65)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 701, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_simd_aligned, __pyx_t_4) < 0) __PYX_ERR(0, 701, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__65 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__64, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_simd_aligned, 701, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__65)) __PYX_ERR(0, 701, __pyx_L1_error)

 0702:         '''

 0703:         Return whether or not this FFTW object requires simd aligned

 0704:         input and output data.

 0705:         '''

+0706:         return self._simd_allowed

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_simd_allowed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 706, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0707: 

+0708:     simd_aligned = property(_get_simd_aligned)

  __Pyx_GetNameInClass(__pyx_t_4, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_simd_aligned); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 708, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 708, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_simd_aligned, __pyx_t_3) < 0) __PYX_ERR(0, 708, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0709: 

+0710:     def _get_input_alignment(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_5_get_input_alignment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_4_get_input_alignment[] = "FFTW._get_input_alignment(self)\n\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 PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_5_get_input_alignment = {"_get_input_alignment", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_5_get_input_alignment, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_4_get_input_alignment};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_5_get_input_alignment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_input_alignment (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_4_get_input_alignment(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_4_get_input_alignment(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_input_alignment", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW._get_input_alignment", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__66 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 710, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__66);
  __Pyx_GIVEREF(__pyx_tuple__66);
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_5_get_input_alignment, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_input_alignment, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__67)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 710, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_input_alignment, __pyx_t_3) < 0) __PYX_ERR(0, 710, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__67 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__66, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_input_alignment, 710, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__67)) __PYX_ERR(0, 710, __pyx_L1_error)

 0711:         '''

 0712:         Returns the byte alignment of the input arrays for which the

 0713:         :class:`~pyfftw.FFTW` object was created.

 0714: 

 0715:         Input array updates with arrays that are not aligned on this

 0716:         byte boundary will result in a ValueError being raised, or

 0717:         a copy being made if the :meth:`~pyfftw.FFTW.__call__`

 0718:         interface is used.

 0719:         '''

+0720:         return self._input_array_alignment

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_input_array_alignment); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 720, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0721: 

+0722:     input_alignment = property(_get_input_alignment)

  __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_input_alignment); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_alignment, __pyx_t_4) < 0) __PYX_ERR(0, 722, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0723: 

+0724:     def _get_output_alignment(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_7_get_output_alignment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_6_get_output_alignment[] = "FFTW._get_output_alignment(self)\n\n        Returns the byte alignment of the output arrays for which the\n        :class:`~pyfftw.FFTW` object was created.\n\n        Output array updates with arrays that are not aligned on this\n        byte boundary will result in a ValueError being raised.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_7_get_output_alignment = {"_get_output_alignment", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_7_get_output_alignment, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_6_get_output_alignment};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_7_get_output_alignment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_output_alignment (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_6_get_output_alignment(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_6_get_output_alignment(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_output_alignment", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW._get_output_alignment", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__68 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(0, 724, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__68);
  __Pyx_GIVEREF(__pyx_tuple__68);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_7_get_output_alignment, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_output_alignment, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__69)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 724, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_output_alignment, __pyx_t_4) < 0) __PYX_ERR(0, 724, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__69 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__68, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_output_alignment, 724, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__69)) __PYX_ERR(0, 724, __pyx_L1_error)

 0725:         '''

 0726:         Returns the byte alignment of the output arrays for which the

 0727:         :class:`~pyfftw.FFTW` object was created.

 0728: 

 0729:         Output array updates with arrays that are not aligned on this

 0730:         byte boundary will result in a ValueError being raised.

 0731:         '''

+0732:         return self._output_array_alignment

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_output_array_alignment); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 732, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0733: 

+0734:     output_alignment = property(_get_output_alignment)

  __Pyx_GetNameInClass(__pyx_t_4, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_output_alignment); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_alignment, __pyx_t_3) < 0) __PYX_ERR(0, 734, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0735: 

+0736:     def _get_flags_used(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_9_get_flags_used(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_8_get_flags_used[] = "FFTW._get_flags_used(self)\n\n        Return which flags were used to construct the FFTW object.\n\n        This includes flags that were added during initialisation.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_9_get_flags_used = {"_get_flags_used", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_9_get_flags_used, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_8_get_flags_used};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_9_get_flags_used(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_flags_used (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_8_get_flags_used(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_8_get_flags_used(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_flags_used", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW._get_flags_used", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__70 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__70);
  __Pyx_GIVEREF(__pyx_tuple__70);
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_9_get_flags_used, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_flags_used, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__71)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_flags_used, __pyx_t_3) < 0) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__71 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__70, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_flags_used, 736, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__71)) __PYX_ERR(0, 736, __pyx_L1_error)

 0737:         '''

 0738:         Return which flags were used to construct the FFTW object.

 0739: 

 0740:         This includes flags that were added during initialisation.

 0741:         '''

+0742:         return tuple(self._flags_used)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PySequence_Tuple(__pyx_v_self->_flags_used); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 742, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0743: 

+0744:     flags = property(_get_flags_used)

  __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_flags_used); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 744, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 744, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_flags, __pyx_t_4) < 0) __PYX_ERR(0, 744, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0745: 

+0746:     def _get_input_array(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_11_get_input_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_10_get_input_array[] = "FFTW._get_input_array(self)\n\n        Return the input array that is associated with the FFTW\n        instance.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_11_get_input_array = {"_get_input_array", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_11_get_input_array, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_10_get_input_array};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_11_get_input_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_input_array (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_10_get_input_array(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_10_get_input_array(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_input_array", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__72 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 746, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__72);
  __Pyx_GIVEREF(__pyx_tuple__72);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_11_get_input_array, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_input_array, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__73)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 746, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_input_array, __pyx_t_4) < 0) __PYX_ERR(0, 746, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__73 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_input_array, 746, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__73)) __PYX_ERR(0, 746, __pyx_L1_error)

 0747:         '''

 0748:         Return the input array that is associated with the FFTW

 0749:         instance.

 0750:         '''

+0751:         return self._input_array

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self->_input_array));
  __pyx_r = ((PyObject *)__pyx_v_self->_input_array);
  goto __pyx_L0;

 0752: 

+0753:     input_array = property(_get_input_array)

  __Pyx_GetNameInClass(__pyx_t_4, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_input_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 753, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 753, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_array, __pyx_t_3) < 0) __PYX_ERR(0, 753, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0754: 

+0755:     def _get_output_array(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_13_get_output_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_12_get_output_array[] = "FFTW._get_output_array(self)\n\n        Return the output array that is associated with the FFTW\n        instance.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_13_get_output_array = {"_get_output_array", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_13_get_output_array, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_12_get_output_array};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_13_get_output_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_output_array (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_12_get_output_array(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_12_get_output_array(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_output_array", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__74 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(0, 755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__74);
  __Pyx_GIVEREF(__pyx_tuple__74);
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_13_get_output_array, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_output_array, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__75)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_output_array, __pyx_t_3) < 0) __PYX_ERR(0, 755, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__75 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__74, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_output_array, 755, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__75)) __PYX_ERR(0, 755, __pyx_L1_error)

 0756:         '''

 0757:         Return the output array that is associated with the FFTW

 0758:         instance.

 0759:         '''

+0760:         return self._output_array

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self->_output_array));
  __pyx_r = ((PyObject *)__pyx_v_self->_output_array);
  goto __pyx_L0;

 0761: 

+0762:     output_array = property(_get_output_array)

  __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_output_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_array, __pyx_t_4) < 0) __PYX_ERR(0, 762, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0763: 

+0764:     def _get_input_strides(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_15_get_input_strides(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_14_get_input_strides[] = "FFTW._get_input_strides(self)\n\n        Return the strides of the input array for which the FFT is planned.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_15_get_input_strides = {"_get_input_strides", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_15_get_input_strides, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_14_get_input_strides};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_15_get_input_strides(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_input_strides (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_14_get_input_strides(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_14_get_input_strides(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_input_strides", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__76 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(0, 764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__76);
  __Pyx_GIVEREF(__pyx_tuple__76);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_15_get_input_strides, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_input_strides, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__77)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_input_strides, __pyx_t_4) < 0) __PYX_ERR(0, 764, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__77 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__76, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_input_strides, 764, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__77)) __PYX_ERR(0, 764, __pyx_L1_error)

 0765:         '''

 0766:         Return the strides of the input array for which the FFT is planned.

 0767:         '''

+0768:         return self._input_strides

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->_input_strides);
  __pyx_r = __pyx_v_self->_input_strides;
  goto __pyx_L0;

 0769: 

+0770:     input_strides = property(_get_input_strides)

  __Pyx_GetNameInClass(__pyx_t_4, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_input_strides); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 770, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 770, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_strides, __pyx_t_3) < 0) __PYX_ERR(0, 770, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0771: 

+0772:     def _get_output_strides(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_17_get_output_strides(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_16_get_output_strides[] = "FFTW._get_output_strides(self)\n\n        Return the strides of the output array for which the FFT is planned.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_17_get_output_strides = {"_get_output_strides", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_17_get_output_strides, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_16_get_output_strides};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_17_get_output_strides(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_output_strides (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_16_get_output_strides(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_16_get_output_strides(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_output_strides", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__78 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__78);
  __Pyx_GIVEREF(__pyx_tuple__78);
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_17_get_output_strides, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_output_strides, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__79)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_output_strides, __pyx_t_3) < 0) __PYX_ERR(0, 772, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__79 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__78, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_output_strides, 772, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__79)) __PYX_ERR(0, 772, __pyx_L1_error)

 0773:         '''

 0774:         Return the strides of the output array for which the FFT is planned.

 0775:         '''

+0776:         return self._output_strides

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->_output_strides);
  __pyx_r = __pyx_v_self->_output_strides;
  goto __pyx_L0;

 0777: 

+0778:     output_strides = property(_get_output_strides)

  __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_output_strides); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 778, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 778, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_strides, __pyx_t_4) < 0) __PYX_ERR(0, 778, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0779: 

+0780:     def _get_input_shape(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_19_get_input_shape(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_18_get_input_shape[] = "FFTW._get_input_shape(self)\n\n        Return the shape of the input array for which the FFT is planned.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_19_get_input_shape = {"_get_input_shape", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_19_get_input_shape, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_18_get_input_shape};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_19_get_input_shape(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_input_shape (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_18_get_input_shape(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_18_get_input_shape(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_input_shape", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__80 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 780, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__80);
  __Pyx_GIVEREF(__pyx_tuple__80);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_19_get_input_shape, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_input_shape, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__81)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 780, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_input_shape, __pyx_t_4) < 0) __PYX_ERR(0, 780, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__81 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__80, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_input_shape, 780, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__81)) __PYX_ERR(0, 780, __pyx_L1_error)

 0781:         '''

 0782:         Return the shape of the input array for which the FFT is planned.

 0783:         '''

+0784:         return self._input_shape

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->_input_shape);
  __pyx_r = __pyx_v_self->_input_shape;
  goto __pyx_L0;

 0785: 

+0786:     input_shape = property(_get_input_shape)

  __Pyx_GetNameInClass(__pyx_t_4, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_input_shape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 786, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 786, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_shape, __pyx_t_3) < 0) __PYX_ERR(0, 786, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0787: 

+0788:     def _get_output_shape(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_21_get_output_shape(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_20_get_output_shape[] = "FFTW._get_output_shape(self)\n\n        Return the shape of the output array for which the FFT is planned.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_21_get_output_shape = {"_get_output_shape", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_21_get_output_shape, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_20_get_output_shape};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_21_get_output_shape(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_output_shape (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_20_get_output_shape(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_20_get_output_shape(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_output_shape", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__82 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 788, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__82);
  __Pyx_GIVEREF(__pyx_tuple__82);
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_21_get_output_shape, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_output_shape, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__83)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 788, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_output_shape, __pyx_t_3) < 0) __PYX_ERR(0, 788, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__83 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__82, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_output_shape, 788, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__83)) __PYX_ERR(0, 788, __pyx_L1_error)

 0789:         '''

 0790:         Return the shape of the output array for which the FFT is planned.

 0791:         '''

+0792:         return self._output_shape

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->_output_shape);
  __pyx_r = __pyx_v_self->_output_shape;
  goto __pyx_L0;

 0793: 

+0794:     output_shape = property(_get_output_shape)

  __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_output_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 794, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 794, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_shape, __pyx_t_4) < 0) __PYX_ERR(0, 794, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0795: 

+0796:     def _get_input_dtype(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_23_get_input_dtype(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_22_get_input_dtype[] = "FFTW._get_input_dtype(self)\n\n        Return the dtype of the input array for which the FFT is planned.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_23_get_input_dtype = {"_get_input_dtype", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_23_get_input_dtype, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_22_get_input_dtype};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_23_get_input_dtype(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_input_dtype (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_22_get_input_dtype(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_22_get_input_dtype(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_input_dtype", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__84 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(0, 796, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__84);
  __Pyx_GIVEREF(__pyx_tuple__84);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_23_get_input_dtype, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_input_dtype, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__85)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 796, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_input_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 796, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__85 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__84, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_input_dtype, 796, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__85)) __PYX_ERR(0, 796, __pyx_L1_error)

 0797:         '''

 0798:         Return the dtype of the input array for which the FFT is planned.

 0799:         '''

+0800:         return self._input_dtype

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->_input_dtype);
  __pyx_r = __pyx_v_self->_input_dtype;
  goto __pyx_L0;

 0801: 

+0802:     input_dtype = property(_get_input_dtype)

  __Pyx_GetNameInClass(__pyx_t_4, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_input_dtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 802, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 802, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_input_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 802, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0803: 

+0804:     def _get_output_dtype(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_25_get_output_dtype(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_24_get_output_dtype[] = "FFTW._get_output_dtype(self)\n\n        Return the shape of the output array for which the FFT is planned.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_25_get_output_dtype = {"_get_output_dtype", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_25_get_output_dtype, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_24_get_output_dtype};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_25_get_output_dtype(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_output_dtype (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_24_get_output_dtype(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_24_get_output_dtype(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_output_dtype", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__86 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(0, 804, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__86);
  __Pyx_GIVEREF(__pyx_tuple__86);
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_25_get_output_dtype, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_output_dtype, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__87)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 804, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_output_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 804, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__87 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__86, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_output_dtype, 804, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__87)) __PYX_ERR(0, 804, __pyx_L1_error)

 0805:         '''

 0806:         Return the shape of the output array for which the FFT is planned.

 0807:         '''

+0808:         return self._output_dtype

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self->_output_dtype);
  __pyx_r = __pyx_v_self->_output_dtype;
  goto __pyx_L0;

 0809: 

+0810:     output_dtype = property(_get_output_dtype)

  __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_output_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 810, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 810, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_output_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 810, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0811: 

+0812:     def _get_direction(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_27_get_direction(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_26_get_direction[] = "FFTW._get_direction(self)\n\n        Return the planned FFT direction. Either `'FFTW_FORWARD'`,\n        `'FFTW_BACKWARD'`, or a list of real transform codes of the form\n        `['FFTW_R*DFT**']`.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_27_get_direction = {"_get_direction", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_27_get_direction, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_26_get_direction};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_27_get_direction(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_direction (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_26_get_direction(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_26_get_direction(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  int __pyx_v_i;
  PyObject *__pyx_v_transform_directions = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_direction", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW._get_direction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_transform_directions);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__88 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_i, __pyx_n_s_transform_directions); if (unlikely(!__pyx_tuple__88)) __PYX_ERR(0, 812, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__88);
  __Pyx_GIVEREF(__pyx_tuple__88);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_27_get_direction, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_direction, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__89)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 812, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_direction, __pyx_t_4) < 0) __PYX_ERR(0, 812, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__89 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__88, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_direction, 812, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__89)) __PYX_ERR(0, 812, __pyx_L1_error)

 0813:         '''

 0814:         Return the planned FFT direction. Either `'FFTW_FORWARD'`,

 0815:         `'FFTW_BACKWARD'`, or a list of real transform codes of the form

 0816:         `['FFTW_R*DFT**']`.

 0817:         '''

 0818:         cdef int i

+0819:         transform_directions = list()

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 819, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_transform_directions = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+0820:         if self._direction[0] in [FFTW_FORWARD, FFTW_BACKWARD]:

  __pyx_t_2 = (__pyx_v_self->_direction[0]);
  __pyx_t_4 = ((__pyx_t_2 == __pyx_e_6pyrost_3bin_6pyfftw_FFTW_FORWARD) != 0);
  if (!__pyx_t_4) {
  } else {
    __pyx_t_3 = __pyx_t_4;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_4 = ((__pyx_t_2 == __pyx_e_6pyrost_3bin_6pyfftw_FFTW_BACKWARD) != 0);
  __pyx_t_3 = __pyx_t_4;
  __pyx_L4_bool_binop_done:;
  __pyx_t_4 = (__pyx_t_3 != 0);
  if (__pyx_t_4) {
/* … */
  }

 0821:             # It would be nice to return a length-one list here (so that the

 0822:             # return type is always [str]). This is an annoying type difference,

 0823:             # but is backwards compatible.

+0824:             return directions_lookup[self._direction[0]]

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_6pyrost_3bin_6pyfftw_directions_lookup, (__pyx_v_self->_direction[0]), int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 824, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

 0825:         else:

+0826:             for i in range(self._rank):

  /*else*/ {
    __pyx_t_2 = __pyx_v_self->_rank;
    __pyx_t_5 = __pyx_t_2;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
      __pyx_v_i = __pyx_t_6;

+0827:                 transform_directions.append(directions_lookup[

      __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_6pyrost_3bin_6pyfftw_directions_lookup, (__pyx_v_self->_direction[__pyx_v_i]), int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 827, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_transform_directions, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 827, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    }
  }

 0828:                         self._direction[i]])

+0829:         return transform_directions

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_transform_directions);
  __pyx_r = __pyx_v_transform_directions;
  goto __pyx_L0;

 0830: 

+0831:     direction = property(_get_direction)

  __Pyx_GetNameInClass(__pyx_t_4, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_direction); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 831, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 831, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_direction, __pyx_t_3) < 0) __PYX_ERR(0, 831, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0832: 

+0833:     def _get_axes(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_29_get_axes(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_28_get_axes[] = "FFTW._get_axes(self)\n\n        Return the axes for the planned FFT in canonical form. That is, as\n        a tuple of positive integers. The order in which they were passed\n        is maintained.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_29_get_axes = {"_get_axes", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_29_get_axes, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_28_get_axes};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_29_get_axes(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_axes (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_28_get_axes(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_28_get_axes(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_v_axes = NULL;
  int __pyx_v_i;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_axes", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW._get_axes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_axes);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__90 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_axes, __pyx_n_s_i); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(0, 833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__90);
  __Pyx_GIVEREF(__pyx_tuple__90);
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_29_get_axes, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_axes, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__91)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 833, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_axes, __pyx_t_3) < 0) __PYX_ERR(0, 833, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__91 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__90, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_axes, 833, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__91)) __PYX_ERR(0, 833, __pyx_L1_error)

 0834:         '''

 0835:         Return the axes for the planned FFT in canonical form. That is, as

 0836:         a tuple of positive integers. The order in which they were passed

 0837:         is maintained.

 0838:         '''

+0839:         axes = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 839, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_axes = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+0840:         for i in range(self._rank):

  __pyx_t_2 = __pyx_v_self->_rank;
  __pyx_t_3 = __pyx_t_2;
  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
    __pyx_v_i = __pyx_t_4;

+0841:             axes.append(self._axes[i])

    __pyx_t_1 = __Pyx_PyInt_From_int64_t((__pyx_v_self->_axes[__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 841, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_axes, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 841, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  }

 0842: 

+0843:         return tuple(axes)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyList_AsTuple(__pyx_v_axes); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 843, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0844: 

+0845:     axes = property(_get_axes)

  __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_axes); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_axes, __pyx_t_4) < 0) __PYX_ERR(0, 845, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0846: 

+0847:     def _get_normalise_idft(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_31_get_normalise_idft(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_30_get_normalise_idft[] = "FFTW._get_normalise_idft(self)\n\n        If ``normalise_idft=True``, the inverse transform is scaled by 1/N.\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_31_get_normalise_idft = {"_get_normalise_idft", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_31_get_normalise_idft, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_30_get_normalise_idft};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_31_get_normalise_idft(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_normalise_idft (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_30_get_normalise_idft(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_30_get_normalise_idft(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_normalise_idft", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW._get_normalise_idft", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__92 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__92)) __PYX_ERR(0, 847, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__92);
  __Pyx_GIVEREF(__pyx_tuple__92);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_31_get_normalise_idft, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_normalise_idft, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__93)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 847, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_normalise_idft, __pyx_t_4) < 0) __PYX_ERR(0, 847, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__93 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__92, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_normalise_idft, 847, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__93)) __PYX_ERR(0, 847, __pyx_L1_error)

 0848:         '''

 0849:         If ``normalise_idft=True``, the inverse transform is scaled by 1/N.

 0850:         '''

+0851:         return self._normalise_idft

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_normalise_idft); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 851, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0852: 

+0853:     normalise_idft = property(_get_normalise_idft)

  __Pyx_GetNameInClass(__pyx_t_4, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_normalise_idft); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 853, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 853, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_normalise_idft, __pyx_t_3) < 0) __PYX_ERR(0, 853, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0854: 

+0855:     def _get_ortho(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_33_get_ortho(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_32_get_ortho[] = "FFTW._get_ortho(self)\n\n        If ``ortho=True`` both the forward and inverse transforms are scaled by\n        1/sqrt(N).\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_33_get_ortho = {"_get_ortho", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_33_get_ortho, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_32_get_ortho};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_33_get_ortho(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_ortho (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_32_get_ortho(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_32_get_ortho(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_ortho", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW._get_ortho", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__94 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__94)) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__94);
  __Pyx_GIVEREF(__pyx_tuple__94);
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_33_get_ortho, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW__get_ortho, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__95)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_ortho, __pyx_t_3) < 0) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__94, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_ortho, 855, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) __PYX_ERR(0, 855, __pyx_L1_error)

 0856:         '''

 0857:         If ``ortho=True`` both the forward and inverse transforms are scaled by

 0858:         1/sqrt(N).

 0859:         '''

+0860:         return self._ortho

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_ortho); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0861: 

+0862:     ortho = property(_get_ortho)

  __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW, __pyx_n_s_get_ortho); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 862, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 862, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_ortho, __pyx_t_4) < 0) __PYX_ERR(0, 862, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);

 0863: 

+0864:     def __cinit__(self, input_array, output_array, axes=(-1,),

/* Python wrapper */
static int __pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_35__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_35__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_input_array = 0;
  PyObject *__pyx_v_output_array = 0;
  PyObject *__pyx_v_axes = 0;
  PyObject *__pyx_v_direction = 0;
  PyObject *__pyx_v_flags = 0;
  unsigned int __pyx_v_threads;
  PyObject *__pyx_v_planning_timelimit = 0;
  int __pyx_v_normalise_idft;
  int __pyx_v_ortho;
  CYTHON_UNUSED PyObject *__pyx_v_args = 0;
  CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return -1;
  __Pyx_GOTREF(__pyx_v_kwargs);
  if (PyTuple_GET_SIZE(__pyx_args) > 9) {
    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 9, PyTuple_GET_SIZE(__pyx_args));
    if (unlikely(!__pyx_v_args)) {
      __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
      __Pyx_RefNannyFinishContext();
      return -1;
    }
    __Pyx_GOTREF(__pyx_v_args);
  } else {
    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
  }
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_input_array,&__pyx_n_s_output_array,&__pyx_n_s_axes,&__pyx_n_s_direction,&__pyx_n_s_flags,&__pyx_n_s_threads,&__pyx_n_s_planning_timelimit,&__pyx_n_s_normalise_idft,&__pyx_n_s_ortho,0};
    PyObject* values[9] = {0,0,0,0,0,0,0,0,0};
    values[2] = ((PyObject *)__pyx_tuple__4);
    values[3] = ((PyObject *)__pyx_n_u_FFTW_FORWARD);
/* … */
  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 864, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__4);
  __Pyx_GIVEREF(__pyx_tuple__4);
/* … */
  /* function exit code */
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kwargs);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_34__cinit__(struct __pyx_obj_6pyrost_3bin_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, int __pyx_v_normalise_idft, int __pyx_v_ortho, CYTHON_UNUSED PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) {
  PyObject *__pyx_v_given_directions = NULL;
  double __pyx_v__planning_timelimit;
  PyObject *__pyx_v_input_dtype = NULL;
  PyObject *__pyx_v_output_dtype = NULL;
  PyObject *__pyx_v_scheme = NULL;
  PyObject *__pyx_v_functions = NULL;
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_set_timelimit __pyx_v_set_timelimit_func;
  int __pyx_v_natural_input_alignment;
  int __pyx_v_natural_output_alignment;
  PyObject *__pyx_v_each_alignment = NULL;
  int __pyx_v_real_transforms;
  int __pyx_v_i;
  Py_ssize_t __pyx_v_n;
  int64_t __pyx_v_array_dimension;
  int64_t __pyx_v_unique_axes_length;
  int64_t *__pyx_v_unique_axes;
  int64_t *__pyx_v_not_axes;
  PyObject *__pyx_v_total_N = NULL;
  __pyx_t_6pyrost_3bin_6pyfftw_validator __pyx_v__validator;
  PyObject *__pyx_v_each_flag = NULL;
  PyObject *__pyx_v_fft_shape_lookup = NULL;
  PyObject *__pyx_v_fft_shape = NULL;
  PyObject *__pyx_v_input_strides_array = NULL;
  PyObject *__pyx_v_output_strides_array = NULL;
  void *__pyx_v_plan;
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_plan_guru __pyx_v_fftw_planner;
  int __pyx_v_rank;
  fftw_iodim *__pyx_v_dims;
  int __pyx_v_howmany_rank;
  fftw_iodim *__pyx_v_howmany_dims;
  void *__pyx_v__in;
  void *__pyx_v__out;
  unsigned int __pyx_v_c_flags;
  PyObject *__pyx_7genexpr__pyx_v_stride = NULL;
  PyObject *__pyx_8genexpr1__pyx_v_stride = NULL;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);
  __Pyx_INCREF(__pyx_v_direction);
  __Pyx_INCREF(__pyx_v_flags);
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_given_directions);
  __Pyx_XDECREF(__pyx_v_input_dtype);
  __Pyx_XDECREF(__pyx_v_output_dtype);
  __Pyx_XDECREF(__pyx_v_scheme);
  __Pyx_XDECREF(__pyx_v_functions);
  __Pyx_XDECREF(__pyx_v_each_alignment);
  __Pyx_XDECREF(__pyx_v_total_N);
  __Pyx_XDECREF(__pyx_v_each_flag);
  __Pyx_XDECREF(__pyx_v_fft_shape_lookup);
  __Pyx_XDECREF(__pyx_v_fft_shape);
  __Pyx_XDECREF(__pyx_v_input_strides_array);
  __Pyx_XDECREF(__pyx_v_output_strides_array);
  __Pyx_XDECREF(__pyx_7genexpr__pyx_v_stride);
  __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_stride);
  __Pyx_XDECREF(__pyx_v_direction);
  __Pyx_XDECREF(__pyx_v_flags);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0865:                   direction='FFTW_FORWARD', flags=('FFTW_MEASURE',),

    values[4] = ((PyObject *)__pyx_tuple__5);
/* … */
  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_u_FFTW_MEASURE); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__5);
  __Pyx_GIVEREF(__pyx_tuple__5);

+0866:                   unsigned int threads=1, planning_timelimit=None,

    values[6] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        default:
        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_array)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_output_array)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 9, 1); __PYX_ERR(0, 864, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_axes);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_direction);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_threads);
          if (value) { values[5] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_planning_timelimit);
          if (value) { values[6] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normalise_idft);
          if (value) { values[7] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  8:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ortho);
          if (value) { values[8] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        const Py_ssize_t used_pos_args = (pos_args < 9) ? pos_args : 9;
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 864, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        default:
        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        case  1:
        case  0:
        goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_input_array = values[0];
    __pyx_v_output_array = values[1];
    __pyx_v_axes = values[2];
    __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_ERR(0, 866, __pyx_L3_error)
    } else {
      __pyx_v_threads = ((unsigned int)1);
    }
    __pyx_v_planning_timelimit = values[6];
    if (values[7]) {
      __pyx_v_normalise_idft = __Pyx_PyObject_IsTrue(values[7]); if (unlikely((__pyx_v_normalise_idft == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 867, __pyx_L3_error)
    } else {

+0867:                   bint normalise_idft=True, bint ortho=False,

      __pyx_v_normalise_idft = ((int)1);
    }
    if (values[8]) {
      __pyx_v_ortho = __Pyx_PyObject_IsTrue(values[8]); if (unlikely((__pyx_v_ortho == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 867, __pyx_L3_error)
    } else {
      __pyx_v_ortho = ((int)0);
    }
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 9, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 864, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
  __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_34__cinit__(((struct __pyx_obj_6pyrost_3bin_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_normalise_idft, __pyx_v_ortho, __pyx_v_args, __pyx_v_kwargs);

 0868:                   *args, **kwargs):

 0869: 

+0870:         if isinstance(direction, str):

  __pyx_t_1 = PyUnicode_Check(__pyx_v_direction); 
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
/* … */
    goto __pyx_L3;
  }

+0871:             given_directions = [direction]

    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 871, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_direction);
    __Pyx_GIVEREF(__pyx_v_direction);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_direction);
    __pyx_v_given_directions = ((PyObject*)__pyx_t_3);
    __pyx_t_3 = 0;

 0872:         else:

+0873:             given_directions = list(direction)

  /*else*/ {
    __pyx_t_3 = PySequence_List(__pyx_v_direction); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 873, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_v_given_directions = ((PyObject*)__pyx_t_3);
    __pyx_t_3 = 0;
  }
  __pyx_L3:;

 0874: 

 0875:         # Initialise the pointers that need to be freed

+0876:         self._plan = NULL

  __pyx_v_self->_plan = NULL;

+0877:         self._dims = NULL

  __pyx_v_self->_dims = NULL;

+0878:         self._howmany_dims = NULL

  __pyx_v_self->_howmany_dims = NULL;

 0879: 

+0880:         self._axes = NULL

  __pyx_v_self->_axes = NULL;

+0881:         self._not_axes = NULL

  __pyx_v_self->_not_axes = NULL;

+0882:         self._direction = NULL

  __pyx_v_self->_direction = NULL;

 0883: 

+0884:         self._normalise_idft = normalise_idft

  __pyx_v_self->_normalise_idft = __pyx_v_normalise_idft;

+0885:         self._ortho = ortho

  __pyx_v_self->_ortho = __pyx_v_ortho;

+0886:         if self._ortho and self._normalise_idft:

  __pyx_t_1 = (__pyx_v_self->_ortho != 0);
  if (__pyx_t_1) {
  } else {
    __pyx_t_2 = __pyx_t_1;
    goto __pyx_L5_bool_binop_done;
  }
  __pyx_t_1 = (__pyx_v_self->_normalise_idft != 0);
  __pyx_t_2 = __pyx_t_1;
  __pyx_L5_bool_binop_done:;
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+0887:             raise ValueError('Invalid options: '

    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 887, __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_ERR(0, 887, __pyx_L1_error)
/* … */
  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Invalid_options_ortho_and_normal); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__6);
  __Pyx_GIVEREF(__pyx_tuple__6);

 0888:                 'ortho and normalise_idft cannot both be True.')

 0889: 

+0890:         flags = list(flags)

  __pyx_t_3 = PySequence_List(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF_SET(__pyx_v_flags, __pyx_t_3);
  __pyx_t_3 = 0;

 0891: 

 0892:         cdef double _planning_timelimit

+0893:         if planning_timelimit is None:

  __pyx_t_2 = (__pyx_v_planning_timelimit == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
/* … */
    goto __pyx_L7;
  }

+0894:             _planning_timelimit = FFTW_NO_TIMELIMIT

    __pyx_v__planning_timelimit = FFTW_NO_TIMELIMIT;

 0895:         else:

+0896:             try:

  /*else*/ {
    {
      /*try:*/ {
/* … */
      }
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      goto __pyx_L13_try_end;
      __pyx_L8_error:;
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
      __Pyx_XGIVEREF(__pyx_t_4);
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
      goto __pyx_L1_error;
      __pyx_L13_try_end:;
    }
  }
  __pyx_L7:;

+0897:                 _planning_timelimit = planning_timelimit

        __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_v_planning_timelimit); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 897, __pyx_L8_error)
        __pyx_v__planning_timelimit = __pyx_t_7;

+0898:             except TypeError:

      __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError);
      if (__pyx_t_8) {
        __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
        if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_9, &__pyx_t_10) < 0) __PYX_ERR(0, 898, __pyx_L10_except_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_GOTREF(__pyx_t_10);

+0899:                 raise TypeError('Invalid planning timelimit: '

        __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 899, __pyx_L10_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_ERR(0, 899, __pyx_L10_except_error)
      }
      goto __pyx_L10_except_error;
      __pyx_L10_except_error:;
/* … */
  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_Invalid_planning_timelimit_The_p); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 899, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__7);
  __Pyx_GIVEREF(__pyx_tuple__7);

 0900:                         'The planning timelimit needs to be a float.')

 0901: 

+0902:         if not isinstance(input_array, np.ndarray):

  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray); 
  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+0903:             raise ValueError('Invalid input array: '

    __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 903, __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_ERR(0, 903, __pyx_L1_error)
/* … */
  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_Invalid_input_array_The_input_ar); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__8);
  __Pyx_GIVEREF(__pyx_tuple__8);

 0904:                     'The input array needs to be an instance '

 0905:                     'of numpy.ndarray')

 0906: 

+0907:         if not isinstance(output_array, np.ndarray):

  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray); 
  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+0908:             raise ValueError('Invalid output array: '

    __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 908, __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_ERR(0, 908, __pyx_L1_error)
/* … */
  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Invalid_output_array_The_output); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 908, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__9);
  __Pyx_GIVEREF(__pyx_tuple__9);

 0909:                     'The output array needs to be an instance '

 0910:                     'of numpy.ndarray')

 0911: 

+0912:         try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L23_try_end;
    __pyx_L18_error:;
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
    __Pyx_XGIVEREF(__pyx_t_6);
    __Pyx_XGIVEREF(__pyx_t_5);
    __Pyx_XGIVEREF(__pyx_t_4);
    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_5, __pyx_t_4);
    goto __pyx_L1_error;
    __pyx_L23_try_end:;
  }

+0913:             input_dtype = input_array.dtype

      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 913, __pyx_L18_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_v_input_dtype = __pyx_t_10;
      __pyx_t_10 = 0;

+0914:             output_dtype = output_array.dtype

      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 914, __pyx_L18_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_v_output_dtype = __pyx_t_10;
      __pyx_t_10 = 0;

+0915:             scheme = fftw_schemes[(input_dtype, output_dtype)]

      __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 915, __pyx_L18_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_INCREF(__pyx_v_input_dtype);
      __Pyx_GIVEREF(__pyx_v_input_dtype);
      PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_input_dtype);
      __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 = __Pyx_PyObject_GetItem(__pyx_v_6pyrost_3bin_6pyfftw_fftw_schemes, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 915, __pyx_L18_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;

+0916:         except KeyError:

    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
    if (__pyx_t_8) {
      __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_3) < 0) __PYX_ERR(0, 916, __pyx_L20_except_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_GOTREF(__pyx_t_3);

+0917:             raise ValueError('Invalid scheme: '

      __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 917, __pyx_L20_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_ERR(0, 917, __pyx_L20_except_error)
    }
    goto __pyx_L20_except_error;
    __pyx_L20_except_error:;
/* … */
  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Invalid_scheme_The_output_array); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 917, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__10);
  __Pyx_GIVEREF(__pyx_tuple__10);

 0918:                     'The output array and input array dtypes '

 0919:                     'do not correspond to a valid fftw scheme.')

 0920: 

+0921:         self._input_dtype = input_dtype

  __Pyx_INCREF(__pyx_v_input_dtype);
  __Pyx_GIVEREF(__pyx_v_input_dtype);
  __Pyx_GOTREF(__pyx_v_self->_input_dtype);
  __Pyx_DECREF(__pyx_v_self->_input_dtype);
  __pyx_v_self->_input_dtype = __pyx_v_input_dtype;

+0922:         self._output_dtype = output_dtype

  __Pyx_INCREF(__pyx_v_output_dtype);
  __Pyx_GIVEREF(__pyx_v_output_dtype);
  __Pyx_GOTREF(__pyx_v_self->_output_dtype);
  __Pyx_DECREF(__pyx_v_self->_output_dtype);
  __pyx_v_self->_output_dtype = __pyx_v_output_dtype;

 0923: 

+0924:         functions = scheme_functions(scheme)

  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_scheme_functions); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 924, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_9 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(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_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_10, function);
    }
  }
  __pyx_t_3 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_9, __pyx_v_scheme) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_scheme);
  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 924, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_v_functions = __pyx_t_3;
  __pyx_t_3 = 0;

 0925: 

+0926:         self._fftw_planner = planners[functions['planner']]

  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_functions, __pyx_n_u_planner); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 926, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_self->_fftw_planner = (__pyx_v_6pyrost_3bin_6pyfftw_planners[__pyx_t_12]);

+0927:         self._fftw_execute = executors[functions['executor']]

  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_functions, __pyx_n_u_executor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 927, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 927, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_self->_fftw_execute = (__pyx_v_6pyrost_3bin_6pyfftw_executors[__pyx_t_12]);

+0928:         self._fftw_destroy = destroyers[functions['generic_precision']]

  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_functions, __pyx_n_u_generic_precision); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 928, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 928, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_self->_fftw_destroy = (__pyx_v_6pyrost_3bin_6pyfftw_destroyers[__pyx_t_12]);

 0929: 

+0930:         self._nthreads_plan_setter = (

  __pyx_v_self->_nthreads_plan_setter = (__pyx_v_6pyrost_3bin_6pyfftw_nthreads_plan_setters[__pyx_t_12]);

+0931:                 nthreads_plan_setters[functions['generic_precision']])

  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_functions, __pyx_n_u_generic_precision); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 931, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 931, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 0932: 

 0933:         cdef fftw_generic_set_timelimit set_timelimit_func = (

+0934:                 set_timelimit_funcs[functions['generic_precision']])

  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_functions, __pyx_n_u_generic_precision); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 934, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 934, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_set_timelimit_func = (__pyx_v_6pyrost_3bin_6pyfftw_set_timelimit_funcs[__pyx_t_12]);

 0935: 

 0936:         # We're interested in the natural alignment on the real type, not

 0937:         # necessarily on the complex type At least one bug was found where

 0938:         # numpy reported an alignment on a complex dtype that was different

 0939:         # to that on the real type.

+0940:         cdef int natural_input_alignment = input_array.real.dtype.alignment

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_real); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 940, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 940, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_alignment); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 940, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 940, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_natural_input_alignment = __pyx_t_8;

+0941:         cdef int natural_output_alignment = output_array.real.dtype.alignment

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_real); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 941, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 941, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_alignment); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 941, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 941, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_natural_output_alignment = __pyx_t_8;

 0942: 

 0943:         # If either of the arrays is not aligned on a 16-byte boundary,

 0944:         # we set the FFTW_UNALIGNED flag. This disables SIMD.

 0945:         # (16 bytes is assumed to be the minimal alignment)

+0946:         if 'FFTW_UNALIGNED' in flags:

  __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_FFTW_UNALIGNED, __pyx_v_flags, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 946, __pyx_L1_error)
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
/* … */
    goto __pyx_L26;
  }

+0947:             self._simd_allowed = False

    __pyx_v_self->_simd_allowed = 0;

+0948:             self._input_array_alignment = natural_input_alignment

    __pyx_v_self->_input_array_alignment = __pyx_v_natural_input_alignment;

+0949:             self._output_array_alignment = natural_output_alignment

    __pyx_v_self->_output_array_alignment = __pyx_v_natural_output_alignment;

 0950: 

 0951:         else:

 0952: 

+0953:             self._input_array_alignment = -1

  /*else*/ {
    __pyx_v_self->_input_array_alignment = -1;

+0954:             self._output_array_alignment = -1

    __pyx_v_self->_output_array_alignment = -1;

 0955: 

+0956:             for each_alignment in _valid_simd_alignments:

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_valid_simd_alignments); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 956, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
      __pyx_t_10 = __pyx_t_3; __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_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 956, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_13 = Py_TYPE(__pyx_t_10)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 956, __pyx_L1_error)
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 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 CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_3 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 956, __pyx_L1_error)
          #else
          __pyx_t_3 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 956, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          #endif
        } else {
          if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_10)) break;
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 956, __pyx_L1_error)
          #else
          __pyx_t_3 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 956, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          #endif
        }
      } else {
        __pyx_t_3 = __pyx_t_13(__pyx_t_10);
        if (unlikely(!__pyx_t_3)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
            else __PYX_ERR(0, 956, __pyx_L1_error)
          }
          break;
        }
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_XDECREF_SET(__pyx_v_each_alignment, __pyx_t_3);
      __pyx_t_3 = 0;
/* … */
    }
    __pyx_L28_break:;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+0957:                 if (<intptr_t>np.PyArray_DATA(input_array) %

      if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 957, __pyx_L1_error)
      __pyx_t_3 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_input_array)))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 957, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
/* … */
      __pyx_t_9 = PyNumber_Remainder(__pyx_t_3, __pyx_v_each_alignment); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 957, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
      if (__pyx_t_2) {
/* … */
      }

+0958:                         each_alignment == 0 and

      __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_t_9, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 958, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 958, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_1) {
      } else {
        __pyx_t_2 = __pyx_t_1;
        goto __pyx_L30_bool_binop_done;
      }

+0959:                         <intptr_t>np.PyArray_DATA(output_array) %

      if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 959, __pyx_L1_error)
      __pyx_t_3 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_output_array)))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 959, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
/* … */
      __pyx_t_9 = PyNumber_Remainder(__pyx_t_3, __pyx_v_each_alignment); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 959, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+0960:                         each_alignment == 0):

      __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_t_9, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 960, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 960, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_2 = __pyx_t_1;
      __pyx_L30_bool_binop_done:;

 0961: 

+0962:                     self._simd_allowed = True

        __pyx_v_self->_simd_allowed = 1;

 0963: 

+0964:                     self._input_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_ERR(0, 964, __pyx_L1_error)
        __pyx_v_self->_input_array_alignment = __pyx_t_8;

+0965:                     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_ERR(0, 965, __pyx_L1_error)
        __pyx_v_self->_output_array_alignment = __pyx_t_8;

 0966: 

+0967:                     break

        goto __pyx_L28_break;

 0968: 

+0969:             if (self._input_array_alignment == -1 or

    __pyx_t_1 = ((__pyx_v_self->_input_array_alignment == -1L) != 0);
    if (!__pyx_t_1) {
    } else {
      __pyx_t_2 = __pyx_t_1;
      goto __pyx_L33_bool_binop_done;
    }
/* … */
    if (__pyx_t_2) {
/* … */
    }
  }
  __pyx_L26:;

+0970:                     self._output_array_alignment == -1):

    __pyx_t_1 = ((__pyx_v_self->_output_array_alignment == -1L) != 0);
    __pyx_t_2 = __pyx_t_1;
    __pyx_L33_bool_binop_done:;

 0971: 

+0972:                 self._simd_allowed = False

      __pyx_v_self->_simd_allowed = 0;

 0973: 

+0974:                 self._input_array_alignment = (

      __pyx_v_self->_input_array_alignment = __pyx_v_natural_input_alignment;

 0975:                         natural_input_alignment)

+0976:                 self._output_array_alignment = (

      __pyx_v_self->_output_array_alignment = __pyx_v_natural_output_alignment;

 0977:                         natural_output_alignment)

+0978:                 flags.append('FFTW_UNALIGNED')

      __pyx_t_14 = __Pyx_PyObject_Append(__pyx_v_flags, __pyx_n_u_FFTW_UNALIGNED); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 978, __pyx_L1_error)

 0979: 

+0980:         if (not (<intptr_t>np.PyArray_DATA(input_array)

  if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 980, __pyx_L1_error)
/* … */
  __pyx_t_2 = ((!(((((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_input_array))) % __pyx_v_self->_input_array_alignment) == 0) != 0)) != 0);
/* … */
  if (unlikely(__pyx_t_2)) {
/* … */
  }

 0981:             % self._input_array_alignment == 0)):

+0982:             raise ValueError('Invalid input alignment: '

    __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 982, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_Raise(__pyx_t_10, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __PYX_ERR(0, 982, __pyx_L1_error)

 0983:                     'The input array is expected to lie on a %d '

+0984:                     'byte boundary.' % self._input_array_alignment)

    __pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_self->_input_array_alignment); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 984, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_Invalid_input_alignment_The_inpu, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 984, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 0985: 

+0986:         if (not (<intptr_t>np.PyArray_DATA(output_array)

  if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 986, __pyx_L1_error)
/* … */
  __pyx_t_2 = ((!(((((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_output_array))) % __pyx_v_self->_output_array_alignment) == 0) != 0)) != 0);
/* … */
  if (unlikely(__pyx_t_2)) {
/* … */
  }

 0987:             % self._output_array_alignment == 0)):

+0988:             raise ValueError('Invalid output alignment: '

    __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 988, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_Raise(__pyx_t_10, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __PYX_ERR(0, 988, __pyx_L1_error)

 0989:                     'The output array is expected to lie on a %d '

+0990:                     'byte boundary.' % self._output_array_alignment)

    __pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_self->_output_array_alignment); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 990, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_Invalid_output_alignment_The_out, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 990, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 0991: 

+0992:         for direction in given_directions:

  __pyx_t_10 = __pyx_v_given_directions; __Pyx_INCREF(__pyx_t_10); __pyx_t_12 = 0;
  for (;;) {
    if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_10)) break;
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    __pyx_t_3 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_12); __Pyx_INCREF(__pyx_t_3); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 992, __pyx_L1_error)
    #else
    __pyx_t_3 = PySequence_ITEM(__pyx_t_10, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 992, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    #endif
    __Pyx_DECREF_SET(__pyx_v_direction, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+0993:             if direction not in scheme_directions[scheme]:

    __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_6pyrost_3bin_6pyfftw_scheme_directions, __pyx_v_scheme); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 993, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_direction, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 993, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_1 = (__pyx_t_2 != 0);
    if (unlikely(__pyx_t_1)) {
/* … */
    }

+0994:                 raise ValueError('Invalid direction: '

      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 994, __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_ERR(0, 994, __pyx_L1_error)
/* … */
  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_Invalid_direction_The_direction); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 994, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__11);
  __Pyx_GIVEREF(__pyx_tuple__11);

 0995:                         'The direction is not valid for the scheme. '

 0996:                         'Try setting it explicitly if it is not already.')

 0997: 

+0998:         self._direction = <int *>malloc(len(axes)*sizeof(int))

  __pyx_t_12 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(0, 998, __pyx_L1_error)
  __pyx_v_self->_direction = ((int *)malloc((__pyx_t_12 * (sizeof(int)))));

 0999: 

+1000:         real_transforms = True

  __pyx_v_real_transforms = 1;

 1001:         cdef int i

+1002:         if given_directions[0] in ['FFTW_FORWARD', 'FFTW_BACKWARD']:

  __Pyx_INCREF(PyList_GET_ITEM(__pyx_v_given_directions, 0));
  __pyx_t_10 = PyList_GET_ITEM(__pyx_v_given_directions, 0);
  __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_10, __pyx_n_u_FFTW_FORWARD, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1002, __pyx_L1_error)
  if (!__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L41_bool_binop_done;
  }
  __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_10, __pyx_n_u_FFTW_BACKWARD, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1002, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_2;
  __pyx_L41_bool_binop_done:;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
/* … */
    goto __pyx_L40;
  }

+1003:             self._direction[0] = directions[given_directions[0]]

    __pyx_t_10 = __Pyx_PyObject_GetItem(__pyx_v_6pyrost_3bin_6pyfftw_directions, PyList_GET_ITEM(__pyx_v_given_directions, 0)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1003, __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_ERR(0, 1003, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    (__pyx_v_self->_direction[0]) = __pyx_t_8;

+1004:             real_transforms = False

    __pyx_v_real_transforms = 0;

 1005:         else:

+1006:             if len(axes) != len(given_directions):

  /*else*/ {
    __pyx_t_12 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1006, __pyx_L1_error)
    __pyx_t_15 = PyList_GET_SIZE(__pyx_v_given_directions); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1006, __pyx_L1_error)
    __pyx_t_2 = ((__pyx_t_12 != __pyx_t_15) != 0);
    if (unlikely(__pyx_t_2)) {
/* … */
    }

+1007:                 raise ValueError('For real-to-real transforms, there must '

      __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1007, __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_ERR(0, 1007, __pyx_L1_error)
/* … */
  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_For_real_to_real_transforms_ther); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 1007, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__12);
  __Pyx_GIVEREF(__pyx_tuple__12);

 1008:                         'be exactly one specified transform for each '

 1009:                         'transformed axis.')

+1010:             for i in range(len(axes)):

    __pyx_t_15 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1010, __pyx_L1_error)
    __pyx_t_12 = __pyx_t_15;
    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_12; __pyx_t_8+=1) {
      __pyx_v_i = __pyx_t_8;

+1011:                 if given_directions[0] in ['FFTW_FORWARD', 'FFTW_BACKWARD']:

      __Pyx_INCREF(PyList_GET_ITEM(__pyx_v_given_directions, 0));
      __pyx_t_10 = PyList_GET_ITEM(__pyx_v_given_directions, 0);
      __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_10, __pyx_n_u_FFTW_FORWARD, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1011, __pyx_L1_error)
      if (!__pyx_t_1) {
      } else {
        __pyx_t_2 = __pyx_t_1;
        goto __pyx_L47_bool_binop_done;
      }
      __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_10, __pyx_n_u_FFTW_BACKWARD, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1011, __pyx_L1_error)
      __pyx_t_2 = __pyx_t_1;
      __pyx_L47_bool_binop_done:;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_1 = (__pyx_t_2 != 0);
      if (unlikely(__pyx_t_1)) {
/* … */
      }

+1012:                     raise ValueError('Heterogeneous transforms cannot be '

        __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1012, __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_ERR(0, 1012, __pyx_L1_error)
/* … */
  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_u_Heterogeneous_transforms_cannot); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 1012, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__13);
  __Pyx_GIVEREF(__pyx_tuple__13);

 1013:                             'assigned with \'FFTW_FORWARD\' or '

 1014:                             '\'FFTW_BACKWARD\'.')

 1015:                 else:

+1016:                     self._direction[i] = directions[given_directions[i]]

      /*else*/ {
        __pyx_t_10 = __Pyx_PyObject_GetItem(__pyx_v_6pyrost_3bin_6pyfftw_directions, PyList_GET_ITEM(__pyx_v_given_directions, __pyx_v_i)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1016, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_10); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1016, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        (__pyx_v_self->_direction[__pyx_v_i]) = __pyx_t_16;
      }
    }
  }
  __pyx_L40:;

 1017: 

+1018:         self._input_shape = input_array.shape

  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1018, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_GIVEREF(__pyx_t_10);
  __Pyx_GOTREF(__pyx_v_self->_input_shape);
  __Pyx_DECREF(__pyx_v_self->_input_shape);
  __pyx_v_self->_input_shape = __pyx_t_10;
  __pyx_t_10 = 0;

+1019:         self._output_shape = output_array.shape

  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1019, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_GIVEREF(__pyx_t_10);
  __Pyx_GOTREF(__pyx_v_self->_output_shape);
  __Pyx_DECREF(__pyx_v_self->_output_shape);
  __pyx_v_self->_output_shape = __pyx_t_10;
  __pyx_t_10 = 0;

 1020: 

+1021:         self._input_array = input_array

  if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1021, __pyx_L1_error)
  __pyx_t_10 = __pyx_v_input_array;
  __Pyx_INCREF(__pyx_t_10);
  __Pyx_GIVEREF(__pyx_t_10);
  __Pyx_GOTREF(__pyx_v_self->_input_array);
  __Pyx_DECREF(((PyObject *)__pyx_v_self->_input_array));
  __pyx_v_self->_input_array = ((PyArrayObject *)__pyx_t_10);
  __pyx_t_10 = 0;

+1022:         self._output_array = output_array

  if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1022, __pyx_L1_error)
  __pyx_t_10 = __pyx_v_output_array;
  __Pyx_INCREF(__pyx_t_10);
  __Pyx_GIVEREF(__pyx_t_10);
  __Pyx_GOTREF(__pyx_v_self->_output_array);
  __Pyx_DECREF(((PyObject *)__pyx_v_self->_output_array));
  __pyx_v_self->_output_array = ((PyArrayObject *)__pyx_t_10);
  __pyx_t_10 = 0;

 1023: 

+1024:         self._axes = <int64_t *>malloc(len(axes)*sizeof(int64_t))

  __pyx_t_15 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1024, __pyx_L1_error)
  __pyx_v_self->_axes = ((int64_t *)malloc((__pyx_t_15 * (sizeof(int64_t)))));

+1025:         for n in range(len(axes)):

  __pyx_t_15 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1025, __pyx_L1_error)
  __pyx_t_12 = __pyx_t_15;
  for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_12; __pyx_t_17+=1) {
    __pyx_v_n = __pyx_t_17;

+1026:             self._axes[n] = axes[n]

    __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_axes, __pyx_v_n, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1026, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_18 = __Pyx_PyInt_As_int64_t(__pyx_t_10); if (unlikely((__pyx_t_18 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1026, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    (__pyx_v_self->_axes[__pyx_v_n]) = __pyx_t_18;
  }

 1027: 

 1028:         # Set the negative entries to their actual index (use the size

 1029:         # of the shape array for this)

+1030:         cdef int64_t array_dimension = len(self._input_shape)

  __pyx_t_10 = __pyx_v_self->_input_shape;
  __Pyx_INCREF(__pyx_t_10);
  __pyx_t_15 = PyObject_Length(__pyx_t_10); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1030, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_v_array_dimension = __pyx_t_15;

 1031: 

+1032:         for n in range(len(axes)):

  __pyx_t_15 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1032, __pyx_L1_error)
  __pyx_t_12 = __pyx_t_15;
  for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_12; __pyx_t_17+=1) {
    __pyx_v_n = __pyx_t_17;

+1033:             if self._axes[n] < 0:

    __pyx_t_1 = (((__pyx_v_self->_axes[__pyx_v_n]) < 0) != 0);
    if (__pyx_t_1) {
/* … */
    }

+1034:                 self._axes[n] = self._axes[n] + array_dimension

      (__pyx_v_self->_axes[__pyx_v_n]) = ((__pyx_v_self->_axes[__pyx_v_n]) + __pyx_v_array_dimension);

 1035: 

+1036:             if self._axes[n] >= array_dimension or self._axes[n] < 0:

    __pyx_t_2 = (((__pyx_v_self->_axes[__pyx_v_n]) >= __pyx_v_array_dimension) != 0);
    if (!__pyx_t_2) {
    } else {
      __pyx_t_1 = __pyx_t_2;
      goto __pyx_L55_bool_binop_done;
    }
    __pyx_t_2 = (((__pyx_v_self->_axes[__pyx_v_n]) < 0) != 0);
    __pyx_t_1 = __pyx_t_2;
    __pyx_L55_bool_binop_done:;
    if (unlikely(__pyx_t_1)) {
/* … */
    }
  }

+1037:                 raise IndexError('Invalid axes: '

      __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1037, __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_ERR(0, 1037, __pyx_L1_error)
/* … */
  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_u_Invalid_axes_The_axes_list_canno); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 1037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__14);
  __Pyx_GIVEREF(__pyx_tuple__14);

 1038:                     'The axes list cannot contain invalid axes.')

 1039: 

 1040:         cdef int64_t unique_axes_length

 1041:         cdef int64_t *unique_axes

 1042:         cdef int64_t *not_axes

 1043: 

+1044:         make_axes_unique(self._axes, len(axes), &unique_axes,

  __pyx_t_15 = PyObject_Length(__pyx_v_axes); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1044, __pyx_L1_error)
/* … */
  __pyx_f_6pyrost_3bin_6pyfftw_make_axes_unique(__pyx_v_self->_axes, __pyx_t_15, (&__pyx_v_unique_axes), (&__pyx_v_not_axes), __pyx_v_array_dimension, (&__pyx_v_unique_axes_length));

 1045:                 &not_axes, array_dimension, &unique_axes_length)

 1046: 

 1047:         # and assign axes and not_axes to the filled arrays

+1048:         free(self._axes)

  free(__pyx_v_self->_axes);

+1049:         self._axes = unique_axes

  __pyx_v_self->_axes = __pyx_v_unique_axes;

+1050:         self._not_axes = not_axes

  __pyx_v_self->_not_axes = __pyx_v_not_axes;

 1051: 

+1052:         total_N = 1

  __Pyx_INCREF(__pyx_int_1);
  __pyx_v_total_N = __pyx_int_1;

+1053:         for n in range(unique_axes_length):

  __pyx_t_18 = __pyx_v_unique_axes_length;
  __pyx_t_19 = __pyx_t_18;
  for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_19; __pyx_t_15+=1) {
    __pyx_v_n = __pyx_t_15;

+1054:             if self._input_shape[self._axes[n]] == 0:

    __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, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1054, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_t_10, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1054, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1054, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(__pyx_t_1)) {
/* … */
    }

+1055:                 raise ValueError('Zero length array: '

      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1055, __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_ERR(0, 1055, __pyx_L1_error)
/* … */
  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_u_Zero_length_array_The_input_arra); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 1055, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__15);
  __Pyx_GIVEREF(__pyx_tuple__15);

 1056:                     'The input array should have no zero length'

 1057:                     'axes over which the FFT is to be taken')

 1058: 

+1059:             if real_transforms:

    __pyx_t_1 = (__pyx_v_real_transforms != 0);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L60;
    }

+1060:                 if self._direction[n] == FFTW_RODFT00:

      __pyx_t_1 = (((__pyx_v_self->_direction[__pyx_v_n]) == __pyx_e_6pyrost_3bin_6pyfftw_FFTW_RODFT00) != 0);
      if (__pyx_t_1) {
/* … */
        goto __pyx_L61;
      }

+1061:                     total_N *= 2*(self._input_shape[self._axes[n]] + 1)

        __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_self->_input_shape, (__pyx_v_self->_axes[__pyx_v_n]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1061, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_10 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1061, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyNumber_Multiply(__pyx_int_2, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1061, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_10 = PyNumber_InPlaceMultiply(__pyx_v_total_N, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1061, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF_SET(__pyx_v_total_N, __pyx_t_10);
        __pyx_t_10 = 0;

+1062:                 elif self._direction[n] == FFTW_REDFT00:

      __pyx_t_1 = (((__pyx_v_self->_direction[__pyx_v_n]) == __pyx_e_6pyrost_3bin_6pyfftw_FFTW_REDFT00) != 0);
      if (__pyx_t_1) {
/* … */
        goto __pyx_L61;
      }

+1063:                     if (self._input_shape[self._axes[n]] < 2):

        __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, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1063, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_3 = PyObject_RichCompare(__pyx_t_10, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1063, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1063, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(__pyx_t_1)) {
/* … */
        }

+1064:                         raise ValueError('FFTW_REDFT00 (also known as DCT-1) is'

          __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1064, __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_ERR(0, 1064, __pyx_L1_error)
/* … */
  __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_u_FFTW_REDFT00_also_known_as_DCT_1); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 1064, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__16);
  __Pyx_GIVEREF(__pyx_tuple__16);

 1065:                                 ' not defined for inputs of length less than two.')

+1066:                     total_N *= 2*(self._input_shape[self._axes[n]] - 1)

        __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_self->_input_shape, (__pyx_v_self->_axes[__pyx_v_n]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1066, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_10 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1066, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyNumber_Multiply(__pyx_int_2, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1066, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_10 = PyNumber_InPlaceMultiply(__pyx_v_total_N, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1066, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF_SET(__pyx_v_total_N, __pyx_t_10);
        __pyx_t_10 = 0;

 1067:                 else:

+1068:                     total_N *= 2*self._input_shape[self._axes[n]]

      /*else*/ {
        __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, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1068, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_3 = PyNumber_Multiply(__pyx_int_2, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1068, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_10 = PyNumber_InPlaceMultiply(__pyx_v_total_N, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1068, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF_SET(__pyx_v_total_N, __pyx_t_10);
        __pyx_t_10 = 0;
      }
      __pyx_L61:;

 1069:             else:

+1070:                 if self._direction[0] == FFTW_FORWARD:

    /*else*/ {
      __pyx_t_1 = (((__pyx_v_self->_direction[0]) == __pyx_e_6pyrost_3bin_6pyfftw_FFTW_FORWARD) != 0);
      if (__pyx_t_1) {
/* … */
        goto __pyx_L63;
      }

+1071:                     total_N *= self._input_shape[self._axes[n]]

        __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, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1071, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_v_total_N, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1071, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF_SET(__pyx_v_total_N, __pyx_t_3);
        __pyx_t_3 = 0;

 1072:                 else:

+1073:                     total_N *= self._output_shape[self._axes[n]]

      /*else*/ {
        __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_self->_output_shape, (__pyx_v_self->_axes[__pyx_v_n]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1073, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_10 = PyNumber_InPlaceMultiply(__pyx_v_total_N, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1073, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF_SET(__pyx_v_total_N, __pyx_t_10);
        __pyx_t_10 = 0;
      }
      __pyx_L63:;
    }
    __pyx_L60:;
  }

 1074: 

+1075:         self._total_size = total_N

  __pyx_t_18 = __Pyx_PyInt_As_int64_t(__pyx_v_total_N); if (unlikely((__pyx_t_18 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1075, __pyx_L1_error)
  __pyx_v_self->_total_size = __pyx_t_18;

+1076:         self._normalisation_scaling = 1/float(self.N)

  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_N); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1076, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_7 = __Pyx_PyObject_AsDouble(__pyx_t_10); if (unlikely(__pyx_t_7 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1076, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_v_self->_normalisation_scaling = (1.0 / __pyx_t_7);

+1077:         self._sqrt_normalisation_scaling = np.sqrt(self._normalisation_scaling)

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1077, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1077, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_self->_normalisation_scaling); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1077, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_11 = NULL;
  if (CYTHON_UNPACK_METHODS && 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);
    }
  }
  __pyx_t_10 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_11, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_3);
  __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1077, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_10); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1077, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_v_self->_sqrt_normalisation_scaling = __pyx_t_7;

 1078: 

 1079:         # Now we can validate the array shapes

 1080:         cdef validator _validator

 1081: 

+1082:         if functions['validator'] == -1:

  __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_v_functions, __pyx_n_u_validator); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1082, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_t_9 = __Pyx_PyInt_EqObjC(__pyx_t_10, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1082, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1082, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__pyx_t_1) {
/* … */
    goto __pyx_L64;
  }

+1083:             if not (output_array.shape == input_array.shape):

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1083, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1083, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_9, __pyx_t_10, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1083, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1083, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_2 = ((!__pyx_t_1) != 0);
    if (unlikely(__pyx_t_2)) {
/* … */
    }

+1084:                 raise ValueError('Invalid shapes: '

      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1084, __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_ERR(0, 1084, __pyx_L1_error)
/* … */
  __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_u_Invalid_shapes_The_output_array); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 1084, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__17);
  __Pyx_GIVEREF(__pyx_tuple__17);

 1085:                         'The output array should be the same shape as the '

 1086:                         'input array for the given array dtypes.')

 1087:         else:

+1088:             _validator = validators[functions['validator']]

  /*else*/ {
    __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_functions, __pyx_n_u_validator); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1088, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_15 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_15 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1088, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v__validator = (__pyx_v_6pyrost_3bin_6pyfftw_validators[__pyx_t_15]);

+1089:             if not _validator(input_array, output_array,

    if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1089, __pyx_L1_error)
    if (!(likely(((__pyx_v_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_output_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1089, __pyx_L1_error)
/* … */
    __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);
/* … */
    if (unlikely(__pyx_t_2)) {
/* … */
    }
  }
  __pyx_L64:;

 1090:                     self._axes, self._not_axes, unique_axes_length):

+1091:                 raise ValueError('Invalid shapes: '

      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1091, __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_ERR(0, 1091, __pyx_L1_error)
/* … */
  __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_u_Invalid_shapes_The_input_array_a); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 1091, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__18);
  __Pyx_GIVEREF(__pyx_tuple__18);

 1092:                         'The input array and output array are invalid '

 1093:                         'complementary shapes for their dtypes.')

 1094: 

+1095:         self._rank = unique_axes_length

  __pyx_v_self->_rank = __pyx_v_unique_axes_length;

+1096:         self._howmany_rank = self._input_array.ndim - unique_axes_length

  __pyx_v_self->_howmany_rank = (__pyx_v_self->_input_array->nd - __pyx_v_unique_axes_length);

 1097: 

+1098:         self._flags = 0

  __pyx_v_self->_flags = 0;

+1099:         self._flags_used = []

  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1099, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_3);
  __Pyx_GOTREF(__pyx_v_self->_flags_used);
  __Pyx_DECREF(__pyx_v_self->_flags_used);
  __pyx_v_self->_flags_used = __pyx_t_3;
  __pyx_t_3 = 0;

+1100:         for each_flag in flags:

  if (likely(PyList_CheckExact(__pyx_v_flags)) || PyTuple_CheckExact(__pyx_v_flags)) {
    __pyx_t_3 = __pyx_v_flags; __Pyx_INCREF(__pyx_t_3); __pyx_t_15 = 0;
    __pyx_t_13 = NULL;
  } else {
    __pyx_t_15 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1100, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1100, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_13)) {
      if (likely(PyList_CheckExact(__pyx_t_3))) {
        if (__pyx_t_15 >= PyList_GET_SIZE(__pyx_t_3)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_10 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_15); __Pyx_INCREF(__pyx_t_10); __pyx_t_15++; if (unlikely(0 < 0)) __PYX_ERR(0, 1100, __pyx_L1_error)
        #else
        __pyx_t_10 = PySequence_ITEM(__pyx_t_3, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1100, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        #endif
      } else {
        if (__pyx_t_15 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_10 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_15); __Pyx_INCREF(__pyx_t_10); __pyx_t_15++; if (unlikely(0 < 0)) __PYX_ERR(0, 1100, __pyx_L1_error)
        #else
        __pyx_t_10 = PySequence_ITEM(__pyx_t_3, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1100, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        #endif
      }
    } else {
      __pyx_t_10 = __pyx_t_13(__pyx_t_3);
      if (unlikely(!__pyx_t_10)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 1100, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_10);
    }
    __Pyx_XDECREF_SET(__pyx_v_each_flag, __pyx_t_10);
    __pyx_t_10 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1101:             try:

    {
      /*try:*/ {
/* … */
      }
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      goto __pyx_L76_try_end;
      __pyx_L69_error:;
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
      __Pyx_XGIVEREF(__pyx_t_4);
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
      goto __pyx_L1_error;
      __pyx_L76_try_end:;
    }

+1102:                 self._flags |= flag_dict[each_flag]

        __pyx_t_10 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->_flags); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1102, __pyx_L69_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_v_6pyrost_3bin_6pyfftw_flag_dict, __pyx_v_each_flag); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1102, __pyx_L69_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_11 = PyNumber_InPlaceOr(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1102, __pyx_L69_error)
        __Pyx_GOTREF(__pyx_t_11);
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __pyx_t_20 = __Pyx_PyInt_As_unsigned_int(__pyx_t_11); if (unlikely((__pyx_t_20 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1102, __pyx_L69_error)
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __pyx_v_self->_flags = __pyx_t_20;

+1103:                 self._flags_used.append(each_flag)

        __pyx_t_14 = __Pyx_PyObject_Append(__pyx_v_self->_flags_used, __pyx_v_each_flag); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 1103, __pyx_L69_error)

+1104:             except KeyError:

      __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
      if (__pyx_t_8) {
        __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
        if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_9, &__pyx_t_10) < 0) __PYX_ERR(0, 1104, __pyx_L71_except_error)
        __Pyx_GOTREF(__pyx_t_11);
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_GOTREF(__pyx_t_10);

+1105:                 raise ValueError('Invalid flag: ' + '\'' +

        __pyx_t_21 = PyNumber_Add(__pyx_kp_u_Invalid_flag, __pyx_v_each_flag); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 1105, __pyx_L71_except_error)
        __Pyx_GOTREF(__pyx_t_21);
/* … */
        __pyx_t_21 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_22); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 1105, __pyx_L71_except_error)
        __Pyx_GOTREF(__pyx_t_21);
        __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
        __Pyx_Raise(__pyx_t_21, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
        __PYX_ERR(0, 1105, __pyx_L71_except_error)
      }
      goto __pyx_L71_except_error;
      __pyx_L71_except_error:;

+1106:                         each_flag + '\' is not a valid planner flag.')

        __pyx_t_22 = PyNumber_Add(__pyx_t_21, __pyx_kp_u_is_not_a_valid_planner_flag); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1106, __pyx_L71_except_error)
        __Pyx_GOTREF(__pyx_t_22);
        __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

 1107: 

 1108: 

+1109:         if ('FFTW_DESTROY_INPUT' not in flags) and (

  __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_FFTW_DESTROY_INPUT, __pyx_v_flags, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1109, __pyx_L1_error)
  __pyx_t_23 = (__pyx_t_1 != 0);
  if (__pyx_t_23) {
  } else {
    __pyx_t_2 = __pyx_t_23;
    goto __pyx_L80_bool_binop_done;
  }
/* … */
  if (__pyx_t_2) {
/* … */
  }

+1110:                 (scheme[0] != 'c2r') or not self._rank > 1):

  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_scheme, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1110, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_23 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_n_u_c2r, Py_NE)); if (unlikely(__pyx_t_23 < 0)) __PYX_ERR(0, 1110, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!__pyx_t_23) {
  } else {
    __pyx_t_2 = __pyx_t_23;
    goto __pyx_L80_bool_binop_done;
  }
  __pyx_t_23 = ((!((__pyx_v_self->_rank > 1) != 0)) != 0);
  __pyx_t_2 = __pyx_t_23;
  __pyx_L80_bool_binop_done:;

 1111:             # The default in all possible cases is to preserve the input

 1112:             # This is not possible for r2c arrays with rank > 1

+1113:             self._flags |= FFTW_PRESERVE_INPUT

    __pyx_v_self->_flags = (__pyx_v_self->_flags | __pyx_e_6pyrost_3bin_6pyfftw_FFTW_PRESERVE_INPUT);

 1114: 

 1115:         # Set up the arrays of structs for holding the stride shape

 1116:         # information

+1117:         self._dims = <_fftw_iodim *>malloc(

  __pyx_v_self->_dims = ((__pyx_t_6pyrost_3bin_6pyfftw__fftw_iodim *)malloc((__pyx_v_self->_rank * (sizeof(__pyx_t_6pyrost_3bin_6pyfftw__fftw_iodim)))));

 1118:                 self._rank * sizeof(_fftw_iodim))

+1119:         self._howmany_dims = <_fftw_iodim *>malloc(

  __pyx_v_self->_howmany_dims = ((__pyx_t_6pyrost_3bin_6pyfftw__fftw_iodim *)malloc((__pyx_v_self->_howmany_rank * (sizeof(__pyx_t_6pyrost_3bin_6pyfftw__fftw_iodim)))));

 1120:                 self._howmany_rank * sizeof(_fftw_iodim))

 1121: 

+1122:         if self._dims == NULL or self._howmany_dims == NULL:

  __pyx_t_23 = ((__pyx_v_self->_dims == NULL) != 0);
  if (!__pyx_t_23) {
  } else {
    __pyx_t_2 = __pyx_t_23;
    goto __pyx_L84_bool_binop_done;
  }
  __pyx_t_23 = ((__pyx_v_self->_howmany_dims == NULL) != 0);
  __pyx_t_2 = __pyx_t_23;
  __pyx_L84_bool_binop_done:;
  if (unlikely(__pyx_t_2)) {
/* … */
  }

 1123:             # Not much else to do than raise an exception

+1124:             raise MemoryError

    PyErr_NoMemory(); __PYX_ERR(0, 1124, __pyx_L1_error)

 1125: 

 1126:         # Find the strides for all the axes of both arrays in terms of the

 1127:         # number of items (as opposed to the number of bytes).

+1128:         self._input_strides = input_array.strides

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1128, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_3);
  __Pyx_GOTREF(__pyx_v_self->_input_strides);
  __Pyx_DECREF(__pyx_v_self->_input_strides);
  __pyx_v_self->_input_strides = __pyx_t_3;
  __pyx_t_3 = 0;

+1129:         self._input_item_strides = tuple([stride/input_array.itemsize

  { /* enter inner scope */
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1129, __pyx_L88_error)
    __Pyx_GOTREF(__pyx_t_3);
/* … */
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1129, __pyx_L88_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_11 = __Pyx_PyNumber_Divide(__pyx_7genexpr__pyx_v_stride, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1129, __pyx_L88_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_11))) __PYX_ERR(0, 1129, __pyx_L88_error)
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* … */
  __pyx_t_9 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 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_9;
  __pyx_t_9 = 0;

+1130:             for stride in input_array.strides])

    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1130, __pyx_L88_error)
    __Pyx_GOTREF(__pyx_t_10);
    if (likely(PyList_CheckExact(__pyx_t_10)) || PyTuple_CheckExact(__pyx_t_10)) {
      __pyx_t_9 = __pyx_t_10; __Pyx_INCREF(__pyx_t_9); __pyx_t_15 = 0;
      __pyx_t_13 = NULL;
    } else {
      __pyx_t_15 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1130, __pyx_L88_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_13 = Py_TYPE(__pyx_t_9)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1130, __pyx_L88_error)
    }
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    for (;;) {
      if (likely(!__pyx_t_13)) {
        if (likely(PyList_CheckExact(__pyx_t_9))) {
          if (__pyx_t_15 >= PyList_GET_SIZE(__pyx_t_9)) break;
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_10 = PyList_GET_ITEM(__pyx_t_9, __pyx_t_15); __Pyx_INCREF(__pyx_t_10); __pyx_t_15++; if (unlikely(0 < 0)) __PYX_ERR(0, 1130, __pyx_L88_error)
          #else
          __pyx_t_10 = PySequence_ITEM(__pyx_t_9, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1130, __pyx_L88_error)
          __Pyx_GOTREF(__pyx_t_10);
          #endif
        } else {
          if (__pyx_t_15 >= PyTuple_GET_SIZE(__pyx_t_9)) break;
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_10 = PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_15); __Pyx_INCREF(__pyx_t_10); __pyx_t_15++; if (unlikely(0 < 0)) __PYX_ERR(0, 1130, __pyx_L88_error)
          #else
          __pyx_t_10 = PySequence_ITEM(__pyx_t_9, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1130, __pyx_L88_error)
          __Pyx_GOTREF(__pyx_t_10);
          #endif
        }
      } else {
        __pyx_t_10 = __pyx_t_13(__pyx_t_9);
        if (unlikely(!__pyx_t_10)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
            else __PYX_ERR(0, 1130, __pyx_L88_error)
          }
          break;
        }
        __Pyx_GOTREF(__pyx_t_10);
      }
      __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_stride, __pyx_t_10);
      __pyx_t_10 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_XDECREF(__pyx_7genexpr__pyx_v_stride); __pyx_7genexpr__pyx_v_stride = 0;
    goto __pyx_L91_exit_scope;
    __pyx_L88_error:;
    __Pyx_XDECREF(__pyx_7genexpr__pyx_v_stride); __pyx_7genexpr__pyx_v_stride = 0;
    goto __pyx_L1_error;
    __pyx_L91_exit_scope:;
  } /* exit inner scope */

+1131:         self._output_strides = output_array.strides

  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1131, __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_9;
  __pyx_t_9 = 0;

+1132:         self._output_item_strides = tuple([stride/output_array.itemsize

  { /* enter inner scope */
    __pyx_t_9 = PyList_New(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1132, __pyx_L94_error)
    __Pyx_GOTREF(__pyx_t_9);
/* … */
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1132, __pyx_L94_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_10 = __Pyx_PyNumber_Divide(__pyx_8genexpr1__pyx_v_stride, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1132, __pyx_L94_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_9, (PyObject*)__pyx_t_10))) __PYX_ERR(0, 1132, __pyx_L94_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* … */
  __pyx_t_11 = PyList_AsTuple(((PyObject*)__pyx_t_9)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __Pyx_GIVEREF(__pyx_t_11);
  __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;

+1133:             for stride in output_array.strides])

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_output_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1133, __pyx_L94_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
      __pyx_t_11 = __pyx_t_3; __Pyx_INCREF(__pyx_t_11); __pyx_t_15 = 0;
      __pyx_t_13 = NULL;
    } else {
      __pyx_t_15 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1133, __pyx_L94_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_13 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1133, __pyx_L94_error)
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    for (;;) {
      if (likely(!__pyx_t_13)) {
        if (likely(PyList_CheckExact(__pyx_t_11))) {
          if (__pyx_t_15 >= PyList_GET_SIZE(__pyx_t_11)) break;
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_3 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_15); __Pyx_INCREF(__pyx_t_3); __pyx_t_15++; if (unlikely(0 < 0)) __PYX_ERR(0, 1133, __pyx_L94_error)
          #else
          __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1133, __pyx_L94_error)
          __Pyx_GOTREF(__pyx_t_3);
          #endif
        } else {
          if (__pyx_t_15 >= PyTuple_GET_SIZE(__pyx_t_11)) break;
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_15); __Pyx_INCREF(__pyx_t_3); __pyx_t_15++; if (unlikely(0 < 0)) __PYX_ERR(0, 1133, __pyx_L94_error)
          #else
          __pyx_t_3 = PySequence_ITEM(__pyx_t_11, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1133, __pyx_L94_error)
          __Pyx_GOTREF(__pyx_t_3);
          #endif
        }
      } else {
        __pyx_t_3 = __pyx_t_13(__pyx_t_11);
        if (unlikely(!__pyx_t_3)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
            else __PYX_ERR(0, 1133, __pyx_L94_error)
          }
          break;
        }
        __Pyx_GOTREF(__pyx_t_3);
      }
      __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_stride, __pyx_t_3);
      __pyx_t_3 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_stride); __pyx_8genexpr1__pyx_v_stride = 0;
    goto __pyx_L97_exit_scope;
    __pyx_L94_error:;
    __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_stride); __pyx_8genexpr1__pyx_v_stride = 0;
    goto __pyx_L1_error;
    __pyx_L97_exit_scope:;
  } /* exit inner scope */

 1134: 

 1135:         # Make sure that the arrays are not too big for fftw

 1136:         # This is hard to test, so we cross our fingers and hope for the

 1137:         # best (any suggestions, please get in touch).

+1138:         for i in range(0, len(self._input_shape)):

  __pyx_t_11 = __pyx_v_self->_input_shape;
  __Pyx_INCREF(__pyx_t_11);
  __pyx_t_15 = PyObject_Length(__pyx_t_11); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1138, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __pyx_t_12 = __pyx_t_15;
  for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_12; __pyx_t_8+=1) {
    __pyx_v_i = __pyx_t_8;

+1139:             if self._input_shape[i] >= <Py_ssize_t> limits.INT_MAX:

    __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_self->_input_shape, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1139, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_9 = PyInt_FromSsize_t(((Py_ssize_t)INT_MAX)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1139, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = PyObject_RichCompare(__pyx_t_11, __pyx_t_9, Py_GE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1139, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1139, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(__pyx_t_2)) {
/* … */
    }

+1140:                 raise ValueError('Dimensions of the input array must be ' +

      __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1140, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_INCREF(__pyx_kp_u_Dimensions_of_the_input_array_mu);
      __Pyx_GIVEREF(__pyx_kp_u_Dimensions_of_the_input_array_mu);
      PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_kp_u_Dimensions_of_the_input_array_mu);
      __Pyx_GIVEREF(__pyx_t_9);
      PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_9);
      __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1140, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __PYX_ERR(0, 1140, __pyx_L1_error)

+1141:                         'less than ', str(limits.INT_MAX))

      __pyx_t_10 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1141, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1141, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 1142: 

+1143:             if self._input_item_strides[i] >= <Py_ssize_t> limits.INT_MAX:

    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_self->_input_item_strides, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1143, __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_ERR(0, 1143, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_11 = PyObject_RichCompare(__pyx_t_9, __pyx_t_10, Py_GE); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1143, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1143, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    if (unlikely(__pyx_t_2)) {
/* … */
    }
  }

+1144:                 raise ValueError('Strides of the input array must be ' +

      __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1144, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_INCREF(__pyx_kp_u_Strides_of_the_input_array_must);
      __Pyx_GIVEREF(__pyx_kp_u_Strides_of_the_input_array_must);
      PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_kp_u_Strides_of_the_input_array_must);
      __Pyx_GIVEREF(__pyx_t_10);
      PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_10);
      __pyx_t_10 = 0;
      __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1144, __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_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __PYX_ERR(0, 1144, __pyx_L1_error)

+1145:                         'less than ', str(limits.INT_MAX))

      __pyx_t_11 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1145, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_10 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1145, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

 1146: 

+1147:         for i in range(0, len(self._output_shape)):

  __pyx_t_10 = __pyx_v_self->_output_shape;
  __Pyx_INCREF(__pyx_t_10);
  __pyx_t_15 = PyObject_Length(__pyx_t_10); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1147, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __pyx_t_12 = __pyx_t_15;
  for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_12; __pyx_t_8+=1) {
    __pyx_v_i = __pyx_t_8;

+1148:             if self._output_shape[i] >= <Py_ssize_t> limits.INT_MAX:

    __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_self->_output_shape, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1148, __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_ERR(0, 1148, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_9 = PyObject_RichCompare(__pyx_t_10, __pyx_t_11, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1148, __pyx_L1_error)
    __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_9); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1148, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(__pyx_t_2)) {
/* … */
    }

+1149:                 raise ValueError('Dimensions of the output array must be ' +

      __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1149, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_INCREF(__pyx_kp_u_Dimensions_of_the_output_array_m);
      __Pyx_GIVEREF(__pyx_kp_u_Dimensions_of_the_output_array_m);
      PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_kp_u_Dimensions_of_the_output_array_m);
      __Pyx_GIVEREF(__pyx_t_11);
      PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_11);
      __pyx_t_11 = 0;
      __pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1149, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_Raise(__pyx_t_11, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __PYX_ERR(0, 1149, __pyx_L1_error)

+1150:                         'less than ', str(limits.INT_MAX))

      __pyx_t_9 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1150, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_11 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1150, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

 1151: 

+1152:             if self._output_item_strides[i] >= <Py_ssize_t> limits.INT_MAX:

    __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_self->_output_item_strides, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1152, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_9 = PyInt_FromSsize_t(((Py_ssize_t)INT_MAX)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1152, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = PyObject_RichCompare(__pyx_t_11, __pyx_t_9, Py_GE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1152, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1152, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(__pyx_t_2)) {
/* … */
    }
  }

+1153:                 raise ValueError('Strides of the output array must be ' +

      __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1153, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_INCREF(__pyx_kp_u_Strides_of_the_output_array_must);
      __Pyx_GIVEREF(__pyx_kp_u_Strides_of_the_output_array_must);
      PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_kp_u_Strides_of_the_output_array_must);
      __Pyx_GIVEREF(__pyx_t_9);
      PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_9);
      __pyx_t_9 = 0;
      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1153, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __PYX_ERR(0, 1153, __pyx_L1_error)

+1154:                         'less than ', str(limits.INT_MAX))

      __pyx_t_10 = __Pyx_PyInt_From_int(INT_MAX); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1154, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1154, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

 1155: 

+1156:         fft_shape_lookup = functions['fft_shape_lookup']

  __pyx_t_9 = __Pyx_PyObject_Dict_GetItem(__pyx_v_functions, __pyx_n_u_fft_shape_lookup); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1156, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_v_fft_shape_lookup = __pyx_t_9;
  __pyx_t_9 = 0;

+1157:         if fft_shape_lookup == -1:

  __pyx_t_9 = __Pyx_PyInt_EqObjC(__pyx_v_fft_shape_lookup, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1157, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1157, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L106;
  }

+1158:             fft_shape = self._input_shape

    __pyx_t_9 = __pyx_v_self->_input_shape;
    __Pyx_INCREF(__pyx_t_9);
    __pyx_v_fft_shape = __pyx_t_9;
    __pyx_t_9 = 0;

 1159:         else:

+1160:             fft_shape = fft_shape_lookup(input_array, output_array)

  /*else*/ {
    __Pyx_INCREF(__pyx_v_fft_shape_lookup);
    __pyx_t_10 = __pyx_v_fft_shape_lookup; __pyx_t_11 = NULL;
    __pyx_t_8 = 0;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) {
      __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10);
      if (likely(__pyx_t_11)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
        __Pyx_INCREF(__pyx_t_11);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_10, function);
        __pyx_t_8 = 1;
      }
    }
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_10)) {
      PyObject *__pyx_temp[3] = {__pyx_t_11, __pyx_v_input_array, __pyx_v_output_array};
      __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1160, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_GOTREF(__pyx_t_9);
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) {
      PyObject *__pyx_temp[3] = {__pyx_t_11, __pyx_v_input_array, __pyx_v_output_array};
      __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1160, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_GOTREF(__pyx_t_9);
    } else
    #endif
    {
      __pyx_t_3 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1160, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      if (__pyx_t_11) {
        __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_11); __pyx_t_11 = NULL;
      }
      __Pyx_INCREF(__pyx_v_input_array);
      __Pyx_GIVEREF(__pyx_v_input_array);
      PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_8, __pyx_v_input_array);
      __Pyx_INCREF(__pyx_v_output_array);
      __Pyx_GIVEREF(__pyx_v_output_array);
      PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_8, __pyx_v_output_array);
      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_3, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1160, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    }
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_v_fft_shape = __pyx_t_9;
    __pyx_t_9 = 0;
  }
  __pyx_L106:;

 1161: 

 1162:         # Fill in the stride and shape information

+1163:         input_strides_array = self._input_item_strides

  __pyx_t_9 = __pyx_v_self->_input_item_strides;
  __Pyx_INCREF(__pyx_t_9);
  __pyx_v_input_strides_array = __pyx_t_9;
  __pyx_t_9 = 0;

+1164:         output_strides_array = self._output_item_strides

  __pyx_t_9 = __pyx_v_self->_output_item_strides;
  __Pyx_INCREF(__pyx_t_9);
  __pyx_v_output_strides_array = __pyx_t_9;
  __pyx_t_9 = 0;

+1165:         for i in range(0, self._rank):

  __pyx_t_8 = __pyx_v_self->_rank;
  __pyx_t_16 = __pyx_t_8;
  for (__pyx_t_24 = 0; __pyx_t_24 < __pyx_t_16; __pyx_t_24+=1) {
    __pyx_v_i = __pyx_t_24;

+1166:             self._dims[i]._n = fft_shape[self._axes[i]]

    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_fft_shape, (__pyx_v_self->_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1166, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_25 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_25 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1166, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    (__pyx_v_self->_dims[__pyx_v_i])._n = __pyx_t_25;

+1167:             self._dims[i]._is = input_strides_array[self._axes[i]]

    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_input_strides_array, (__pyx_v_self->_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1167, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_25 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_25 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1167, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    (__pyx_v_self->_dims[__pyx_v_i])._is = __pyx_t_25;

+1168:             self._dims[i]._os = output_strides_array[self._axes[i]]

    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_output_strides_array, (__pyx_v_self->_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1168, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_25 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_25 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1168, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    (__pyx_v_self->_dims[__pyx_v_i])._os = __pyx_t_25;
  }

 1169: 

+1170:         for i in range(0, self._howmany_rank):

  __pyx_t_8 = __pyx_v_self->_howmany_rank;
  __pyx_t_16 = __pyx_t_8;
  for (__pyx_t_24 = 0; __pyx_t_24 < __pyx_t_16; __pyx_t_24+=1) {
    __pyx_v_i = __pyx_t_24;

+1171:             self._howmany_dims[i]._n = fft_shape[self._not_axes[i]]

    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_fft_shape, (__pyx_v_self->_not_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1171, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_25 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_25 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1171, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    (__pyx_v_self->_howmany_dims[__pyx_v_i])._n = __pyx_t_25;

+1172:             self._howmany_dims[i]._is = input_strides_array[self._not_axes[i]]

    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_input_strides_array, (__pyx_v_self->_not_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1172, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_25 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_25 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1172, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    (__pyx_v_self->_howmany_dims[__pyx_v_i])._is = __pyx_t_25;

+1173:             self._howmany_dims[i]._os = output_strides_array[self._not_axes[i]]

    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_output_strides_array, (__pyx_v_self->_not_axes[__pyx_v_i]), int64_t, 1, __Pyx_PyInt_From_int64_t, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1173, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_25 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_25 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1173, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    (__pyx_v_self->_howmany_dims[__pyx_v_i])._os = __pyx_t_25;
  }

 1174: 

 1175:         # parallel execution

+1176:         self._use_threads = (threads > 1)

  __pyx_v_self->_use_threads = (__pyx_v_threads > 1);

 1177: 

 1178:         ## Point at which FFTW calls are made

 1179:         ## (and none should be made before this)

 1180: 

 1181:         # noop if threads library not available

+1182:         self._nthreads_plan_setter(threads)

  __pyx_v_self->_nthreads_plan_setter(__pyx_v_threads);

 1183: 

 1184:         # Set the timelimit

+1185:         set_timelimit_func(_planning_timelimit)

  __pyx_v_set_timelimit_func(__pyx_v__planning_timelimit);

 1186: 

 1187:         # Finally, construct the plan, after acquiring the global planner lock

 1188:         # (so that only one python thread can plan at a time, as the FFTW

 1189:         # planning functions are not thread-safe)

 1190: 

 1191:         # no self-lookups allowed in nogil block, so must grab all these first

 1192:         cdef void *plan

+1193:         cdef fftw_generic_plan_guru fftw_planner = self._fftw_planner

  __pyx_t_26 = __pyx_v_self->_fftw_planner;
  __pyx_v_fftw_planner = __pyx_t_26;

+1194:         cdef int rank = self._rank

  __pyx_t_8 = __pyx_v_self->_rank;
  __pyx_v_rank = __pyx_t_8;

+1195:         cdef fftw_iodim *dims = <fftw_iodim *>self._dims

  __pyx_v_dims = ((fftw_iodim *)__pyx_v_self->_dims);

+1196:         cdef int howmany_rank = self._howmany_rank

  __pyx_t_8 = __pyx_v_self->_howmany_rank;
  __pyx_v_howmany_rank = __pyx_t_8;

+1197:         cdef fftw_iodim *howmany_dims = <fftw_iodim *>self._howmany_dims

  __pyx_v_howmany_dims = ((fftw_iodim *)__pyx_v_self->_howmany_dims);

+1198:         cdef void *_in = <void *>np.PyArray_DATA(self._input_array)

  __pyx_t_9 = ((PyObject *)__pyx_v_self->_input_array);
  __Pyx_INCREF(__pyx_t_9);
  __pyx_v__in = ((void *)PyArray_DATA(((PyArrayObject *)__pyx_t_9)));
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+1199:         cdef void *_out = <void *>np.PyArray_DATA(self._output_array)

  __pyx_t_9 = ((PyObject *)__pyx_v_self->_output_array);
  __Pyx_INCREF(__pyx_t_9);
  __pyx_v__out = ((void *)PyArray_DATA(((PyArrayObject *)__pyx_t_9)));
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+1200:         cdef unsigned c_flags = self._flags

  __pyx_t_20 = __pyx_v_self->_flags;
  __pyx_v_c_flags = __pyx_t_20;

 1201: 

+1202:         with plan_lock, nogil:

  /*with:*/ {
    __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_v_6pyrost_3bin_6pyfftw_plan_lock, __pyx_n_s_exit); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1202, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_10 = __Pyx_PyObject_LookupSpecial(__pyx_v_6pyrost_3bin_6pyfftw_plan_lock, __pyx_n_s_enter); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1202, __pyx_L111_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_3 = NULL;
    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_10);
      if (likely(__pyx_t_3)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_10, function);
      }
    }
    __pyx_t_9 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_10);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1202, __pyx_L111_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    /*try:*/ {
      {
        /*try:*/ {
          {
              #ifdef WITH_THREAD
              PyThreadState *_save;
              Py_UNBLOCK_THREADS
              __Pyx_FastGIL_Remember();
              #endif
              /*try:*/ {
/* … */
              /*finally:*/ {
                /*normal exit:*/{
                  #ifdef WITH_THREAD
                  __Pyx_FastGIL_Forget();
                  Py_BLOCK_THREADS
                  #endif
                  goto __pyx_L123;
                }
                __pyx_L123:;
              }
          }
        }
      }
    }
    /*finally:*/ {
      /*normal exit:*/{
        if (__pyx_t_6) {
          __pyx_t_27 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__19, NULL);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          if (unlikely(!__pyx_t_27)) __PYX_ERR(0, 1202, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_27);
          __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0;
        }
        goto __pyx_L114;
      }
      __pyx_L114:;
    }
    goto __pyx_L124;
    __pyx_L111_error:;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L1_error;
    __pyx_L124:;
  }
/* … */
  __pyx_tuple__19 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 1202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__19);
  __Pyx_GIVEREF(__pyx_tuple__19);

+1203:             plan = fftw_planner(rank, dims, howmany_rank, howmany_dims,

                __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_self->_direction, __pyx_v_c_flags);
              }

 1204:                                 _in, _out, self._direction, c_flags)

+1205:         self._plan = plan

  __pyx_v_self->_plan = __pyx_v_plan;

 1206: 

+1207:         if self._plan == NULL:

  __pyx_t_2 = ((__pyx_v_self->_plan == NULL) != 0);
  if (__pyx_t_2) {
/* … */
  }

+1208:             if 'FFTW_WISDOM_ONLY' in flags:

    __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_FFTW_WISDOM_ONLY, __pyx_v_flags, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1208, __pyx_L1_error)
    __pyx_t_23 = (__pyx_t_2 != 0);
    if (unlikely(__pyx_t_23)) {
/* … */
    }

+1209:                 raise RuntimeError('No FFTW wisdom is known for this plan.')

      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1209, __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_ERR(0, 1209, __pyx_L1_error)
/* … */
  __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_u_No_FFTW_wisdom_is_known_for_this); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 1209, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__20);
  __Pyx_GIVEREF(__pyx_tuple__20);

 1210:             else:

+1211:                 raise RuntimeError('The data has an uncaught error that led '+

    /*else*/ {
      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1211, __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_ERR(0, 1211, __pyx_L1_error)
    }
/* … */
  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_u_The_data_has_an_uncaught_error_t); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 1211, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__21);
  __Pyx_GIVEREF(__pyx_tuple__21);

 1212:                     'to the planner returning NULL. This is a bug.')

 1213: 

+1214:     def __init__(self, input_array, output_array, axes=(-1,),

/* Python wrapper */
static int __pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_37__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_36__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. Repeated axes are\n          only transformed once. Invalid axes will raise an ``IndexError``\n          exception. This argument is equivalent to the same\n          argument in :func:`numpy.fft.fftn`, except for the fact that\n          the behaviour of repeated axes is different (``numpy.fft``\n          will happily take the fft of the same axis if it is repeated\n          in the ``axes`` argument). Rudimentary testing has suggested\n          this is down to the underlying FFTW library and so unlikely\n          to be fixed in these wrappers.\n\n        * The ``direction`` parameter describes what sort of\n          transformation the object should compute. This parameter is\n          poorly named for historical reasons: older versions of pyFFTW\n          only supported forward and backward transformations, for which\n          this name made sense. Since then pyFFTW has been expanded to\n          support real to real transforms as well and the name is not\n          quite as descriptive.\n\n          ``direction`` should either be a string, or, in the case of\n          multiple real transforms, a list of strings. The two values\n          corresponding to the DFT are\n\n          * ``'FFTW_FORWARD'``, which is the forward discrete Fourier\n            transform, and\n          * ``'FFTW_BACKWARD'``, which is the backward discrete Fourier\n            transform.\n\n          Note that, for the two above options, only the Complex schemes\n          allow a free choice for ``direction``. The direction *must*\n          agree with the"" the :ref:`table below <scheme_table>` if a Real\n          scheme is used, otherwise a ``ValueError`` is raised.\n\n\n          Alternatively, if you are interested in one of the real to real\n          transforms, then pyFFTW supports four different discrete cosine\n          transforms:\n\n          * ``'FFTW_REDFT00'``,\n          * ``'FFTW_REDFT01'``,\n          * ``'FFTW_REDFT10'``, and\n          * ``'FFTW_REDFT01'``,\n\n          and four discrete sine transforms:\n\n          * ``'FFTW_RODFT00'``,\n          * ``'FFTW_RODFT01'``,\n          * ``'FFTW_RODFT10'``, and\n          * ``'FFTW_RODFT01'``.\n\n          pyFFTW uses the same naming convention for these flags as FFTW:\n          the ``'REDFT'`` part of the name is an acronym for 'real even\n          discrete Fourier transform, and, similarly, ``'RODFT'`` stands\n          for 'real odd discrete Fourier transform'. The trailing ``'0'``\n          is notation for even data (in terms of symmetry) and the\n          trailing ``'1'`` is for odd data.\n\n          Unlike the plain discrete Fourier transform, one may specify a\n          different real to real transformation over each axis: for example,\n\n          .. code-block:: none\n             a = pyfftw.empty_aligned((128,128,128))\n             b = pyfftw.empty_aligned((128,128,128))\n             directions = ['FFTW_REDFT00', 'FFTW_RODFT11']\n             transform = pyfftw.FFTW(a, b, axes=(0, 2), direction=directions)\n\n          will create a transformation across the first and last axes\n          with a discrete cosine transform over the first and a discrete\n          sine transform over the last.\n\n          Unfortunately, since this class is ultimately just a wrapper\n          for various transforms implemented in FFTW, one cannot combine\n          real transformations with real to complex transformations in a\n          single object.\n\n        .. _FFTW_flags:\n\n        * ``flags`` is a list of strings and is a subset of the\n       ""   flags that FFTW allows for the planners:\n\n          * ``'FFTW_ESTIMATE'``, ``'FFTW_MEASURE'``, ``'FFTW_PATIENT'`` and\n            ``'FFTW_EXHAUSTIVE'`` are supported. These describe the\n            increasing amount of effort spent during the planning\n            stage to create the fastest possible transform.\n            Usually ``'FFTW_MEASURE'`` is a good compromise. If no flag\n            is passed, the default ``'FFTW_MEASURE'`` is used.\n          * ``'FFTW_UNALIGNED'`` is supported.\n            This tells FFTW not to assume anything about the\n            alignment of the data and disabling any SIMD capability\n            (see below).\n          * ``'FFTW_DESTROY_INPUT'`` is supported.\n            This tells FFTW that the input array can be destroyed during\n            the transform, sometimes allowing a faster algorithm to be\n            used. The default behaviour is, if possible, to preserve the\n            input. In the case of the 1D Backwards Real transform, this\n            may result in a performance hit. In the case of a backwards\n            real transform for greater than one dimension, it is not\n            possible to preserve the input, making this flag implicit\n            in that case. A little more on this is given\n            :ref:`below<scheme_table>`.\n          * ``'FFTW_WISDOM_ONLY'`` is supported.\n            This tells FFTW to raise an error if no plan for this transform\n            and data type is already in the wisdom. It thus provides a method\n            to determine whether planning would require additional effort or the\n            cached wisdom can be used. This flag should be combined with the\n            various planning-effort flags (``'FFTW_ESTIMATE'``,\n            ``'FFTW_MEASURE'``, etc.); if so, then an error will be raised if\n            wisdom derived from that level of planning effort (or higher) is\n            not present. If no planning-effort flag is used, the default of\n            ``""'FFTW_ESTIMATE'`` is assumed.\n            Note that wisdom is specific to all the parameters, including the\n            data alignment. That is, if wisdom was generated with input/output\n            arrays with one specific alignment, using ``'FFTW_WISDOM_ONLY'``\n            to create a plan for arrays with any different alignment will\n            cause the ``'FFTW_WISDOM_ONLY'`` planning to fail. Thus it is\n            important to specifically control the data alignment to make the\n            best use of ``'FFTW_WISDOM_ONLY'``.\n\n          The `FFTW planner flags documentation\n          <http://www.fftw.org/fftw3_doc/Planner-Flags.html#Planner-Flags>`_\n          has more information about the various flags and their impact.\n          Note that only the flags documented here are supported.\n\n        * ``threads`` tells the wrapper how many threads to use\n          when invoking FFTW, with a default of 1. If the number\n          of threads is greater than 1, then the GIL is released\n          by necessity.\n\n        * ``planning_timelimit`` is a floating point number that\n          indicates to the underlying FFTW planner the maximum number of\n          seconds it should spend planning the FFT. This is a rough\n          estimate and corresponds to calling of ``fftw_set_timelimit()``\n          (or an equivalent dependent on type) in the underlying FFTW\n          library. If ``None`` is set, the planner will run indefinitely\n          until all the planning modes allowed by the flags have been\n          tried. See the `FFTW planner flags page\n          <http://www.fftw.org/fftw3_doc/Planner-Flags.html#Planner-Flags>`_\n          for more information on this.\n\n        .. _fftw_schemes:\n\n        **Schemes**\n\n        The currently supported full (so not discrete sine or discrete\n        cosine) DFT schemes are as follows:\n\n        .. _scheme_table:\n\n        +----------------+-----------------------+------------------------+-----------+""\n        | Type           | ``input_array.dtype`` | ``output_array.dtype`` | Direction |\n        +================+=======================+========================+===========+\n        | Complex        | ``complex64``         | ``complex64``          | Both      |\n        +----------------+-----------------------+------------------------+-----------+\n        | Complex        | ``complex128``        | ``complex128``         | Both      |\n        +----------------+-----------------------+------------------------+-----------+\n        | Complex        | ``clongdouble``       | ``clongdouble``        | Both      |\n        +----------------+-----------------------+------------------------+-----------+\n        | Real           | ``float32``           | ``complex64``          | Forwards  |\n        +----------------+-----------------------+------------------------+-----------+\n        | Real           | ``float64``           | ``complex128``         | Forwards  |\n        +----------------+-----------------------+------------------------+-----------+\n        | Real           | ``longdouble``        | ``clongdouble``        | Forwards  |\n        +----------------+-----------------------+------------------------+-----------+\n        | Real\\ :sup:`1` | ``complex64``         | ``float32``            | Backwards |\n        +----------------+-----------------------+------------------------+-----------+\n        | Real\\ :sup:`1` | ``complex128``        | ``float64``            | Backwards |\n        +----------------+-----------------------+------------------------+-----------+\n        | Real\\ :sup:`1` | ``clongdouble``       | ``longdouble``         | Backwards |\n        +----------------+-----------------------+------------------------+-----------+\n\n        \\ :sup:`1`  Note that the Backwards Real transform for the case\n        in which the dimensionality of the transform is greater than 1\n        will destroy the input array. This is inherent to FFTW and ""the only\n        general work-around for this is to copy the array prior to\n        performing the transform. In the case where the dimensionality\n        of the transform is 1, the default is to preserve the input array.\n        This is different from the default in the underlying library, and\n        some speed gain may be achieved by allowing the input array to\n        be destroyed by passing the ``'FFTW_DESTROY_INPUT'``\n        :ref:`flag <FFTW_flags>`.\n\n        The discrete sine and discrete cosine transforms are supported\n        for all three real types.\n\n        ``clongdouble`` typically maps directly to ``complex256``\n        or ``complex192``, and ``longdouble`` to ``float128`` or\n        ``float96``, dependent on platform.\n\n        The relative shapes of the arrays should be as follows:\n\n        * For a Complex transform, ``output_array.shape == input_array.shape``\n        * For a Real transform in the Forwards direction, both the following\n          should be true:\n\n          * ``output_array.shape[axes][-1] == input_array.shape[axes][-1]//2 + 1``\n          * All the other axes should be equal in length.\n\n        * For a Real transform in the Backwards direction, both the following\n          should be true:\n\n          * ``input_array.shape[axes][-1] == output_array.shape[axes][-1]//2 + 1``\n          * All the other axes should be equal in length.\n\n        In the above expressions for the Real transform, the ``axes``\n        arguments denotes the unique set of axes on which we are taking\n        the FFT, in the order passed. It is the last of these axes that\n        is subject to the special case shown.\n\n        The shapes for the real transforms corresponds to those\n        stipulated by the FFTW library. Further information can be\n        found in the FFTW documentation on the `real DFT\n        <http://www.fftw.org/fftw3_doc/Guru-Real_002ddata-DFTs.html>`_.\n\n        The actual arrangement in memory is arbitrary a""nd the scheme\n        can be planned for any set of strides on either the input\n        or the output. The user should not have to worry about this\n        and any valid numpy array should work just fine.\n\n        What is calculated is exactly what FFTW calculates.\n        Notably, this is an unnormalized transform so should\n        be scaled as necessary (fft followed by ifft will scale\n        the input by N, the product of the dimensions along which\n        the DFT is taken). For further information, see the\n        `FFTW documentation\n        <http://www.fftw.org/fftw3_doc/What-FFTW-Really-Computes.html>`_.\n\n        The FFTW library benefits greatly from the beginning of each\n        DFT axes being aligned on the correct byte boundary, enabling\n        SIMD instructions. By default, if the data begins on such a\n        boundary, then FFTW will be allowed to try and enable\n        SIMD instructions. This means that all future changes to\n        the data arrays will be checked for similar alignment. SIMD\n        instructions can be explicitly disabled by setting the\n        FFTW_UNALIGNED flags, to allow for updates with unaligned\n        data.\n\n        :func:`~pyfftw.byte_align` and\n        :func:`~pyfftw.empty_aligned` are two methods\n        included with this module for producing aligned arrays.\n\n        The optimum alignment for the running platform is provided\n        by :data:`pyfftw.simd_alignment`, though a different alignment\n        may still result in some performance improvement. For example,\n        if the processor supports AVX (requiring 32-byte alignment) as\n        well as SSE (requiring 16-byte alignment), then if the array\n        is 16-byte aligned, SSE will still be used.\n\n        It's worth noting that just being aligned may not be sufficient\n        to create the fastest possible transform. For example, if the\n        array is not contiguous (i.e. certain axes are displaced in\n        memory), it may be ""faster to plan a transform for a contiguous\n        array, and then rely on the array being copied in before the\n        transform (which :class:`pyfftw.FFTW` will handle for you when\n        accessed through :meth:`~pyfftw.FFTW.__call__`).\n        ";
#if CYTHON_COMPILING_IN_CPYTHON
struct wrapperbase __pyx_wrapperbase_6pyrost_3bin_6pyfftw_4FFTW_36__init__;
#endif
static int __pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_37__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  CYTHON_UNUSED PyObject *__pyx_v_input_array = 0;
  CYTHON_UNUSED PyObject *__pyx_v_output_array = 0;
  CYTHON_UNUSED PyObject *__pyx_v_axes = 0;
  CYTHON_UNUSED PyObject *__pyx_v_direction = 0;
  CYTHON_UNUSED PyObject *__pyx_v_flags = 0;
  CYTHON_UNUSED int __pyx_v_threads;
  CYTHON_UNUSED PyObject *__pyx_v_planning_timelimit = 0;
  CYTHON_UNUSED PyObject *__pyx_v_normalise_idft = 0;
  CYTHON_UNUSED PyObject *__pyx_v_ortho = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_input_array,&__pyx_n_s_output_array,&__pyx_n_s_axes,&__pyx_n_s_direction,&__pyx_n_s_flags,&__pyx_n_s_threads,&__pyx_n_s_planning_timelimit,&__pyx_n_s_normalise_idft,&__pyx_n_s_ortho,0};
    PyObject* values[9] = {0,0,0,0,0,0,0,0,0};
    values[2] = ((PyObject *)__pyx_tuple__4);
    values[3] = ((PyObject *)__pyx_n_u_FFTW_FORWARD);
/* … */
  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_36__init__(CYTHON_UNUSED struct __pyx_obj_6pyrost_3bin_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, CYTHON_UNUSED PyObject *__pyx_v_normalise_idft, CYTHON_UNUSED PyObject *__pyx_v_ortho) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__", 0);

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1215:             direction='FFTW_FORWARD', flags=('FFTW_MEASURE',),

    values[4] = ((PyObject *)__pyx_tuple__5);

+1216:             int threads=1, planning_timelimit=None,

    values[6] = ((PyObject *)Py_None);

+1217:             normalise_idft=True, ortho=False):

    values[7] = ((PyObject *)Py_True);
    values[8] = ((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  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_array)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_output_array)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 9, 1); __PYX_ERR(0, 1214, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_axes);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_direction);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_threads);
          if (value) { values[5] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_planning_timelimit);
          if (value) { values[6] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normalise_idft);
          if (value) { values[7] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  8:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ortho);
          if (value) { values[8] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1214, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_input_array = values[0];
    __pyx_v_output_array = values[1];
    __pyx_v_axes = values[2];
    __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_ERR(0, 1216, __pyx_L3_error)
    } else {
      __pyx_v_threads = ((int)1);
    }
    __pyx_v_planning_timelimit = values[6];
    __pyx_v_normalise_idft = values[7];
    __pyx_v_ortho = values[8];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 9, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1214, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_36__init__(((struct __pyx_obj_6pyrost_3bin_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_normalise_idft, __pyx_v_ortho);

 1218:         '''

 1219:         **Arguments**:

 1220: 

 1221:         * ``input_array`` and ``output_array`` should be numpy arrays.

 1222:           The contents of these arrays will be destroyed by the planning

 1223:           process during initialisation. Information on supported

 1224:           dtypes for the arrays is :ref:`given below <scheme_table>`.

 1225: 

 1226:         * ``axes`` describes along which axes the DFT should be taken.

 1227:           This should be a valid list of axes. Repeated axes are

 1228:           only transformed once. Invalid axes will raise an ``IndexError``

 1229:           exception. This argument is equivalent to the same

 1230:           argument in :func:`numpy.fft.fftn`, except for the fact that

 1231:           the behaviour of repeated axes is different (``numpy.fft``

 1232:           will happily take the fft of the same axis if it is repeated

 1233:           in the ``axes`` argument). Rudimentary testing has suggested

 1234:           this is down to the underlying FFTW library and so unlikely

 1235:           to be fixed in these wrappers.

 1236: 

 1237:         * The ``direction`` parameter describes what sort of

 1238:           transformation the object should compute. This parameter is

 1239:           poorly named for historical reasons: older versions of pyFFTW

 1240:           only supported forward and backward transformations, for which

 1241:           this name made sense. Since then pyFFTW has been expanded to

 1242:           support real to real transforms as well and the name is not

 1243:           quite as descriptive.

 1244: 

 1245:           ``direction`` should either be a string, or, in the case of

 1246:           multiple real transforms, a list of strings. The two values

 1247:           corresponding to the DFT are

 1248: 

 1249:           * ``'FFTW_FORWARD'``, which is the forward discrete Fourier

 1250:             transform, and

 1251:           * ``'FFTW_BACKWARD'``, which is the backward discrete Fourier

 1252:             transform.

 1253: 

 1254:           Note that, for the two above options, only the Complex schemes

 1255:           allow a free choice for ``direction``. The direction *must*

 1256:           agree with the the :ref:`table below <scheme_table>` if a Real

 1257:           scheme is used, otherwise a ``ValueError`` is raised.

 1258: 

 1259: 

 1260:           Alternatively, if you are interested in one of the real to real

 1261:           transforms, then pyFFTW supports four different discrete cosine

 1262:           transforms:

 1263: 

 1264:           * ``'FFTW_REDFT00'``,

 1265:           * ``'FFTW_REDFT01'``,

 1266:           * ``'FFTW_REDFT10'``, and

 1267:           * ``'FFTW_REDFT01'``,

 1268: 

 1269:           and four discrete sine transforms:

 1270: 

 1271:           * ``'FFTW_RODFT00'``,

 1272:           * ``'FFTW_RODFT01'``,

 1273:           * ``'FFTW_RODFT10'``, and

 1274:           * ``'FFTW_RODFT01'``.

 1275: 

 1276:           pyFFTW uses the same naming convention for these flags as FFTW:

 1277:           the ``'REDFT'`` part of the name is an acronym for 'real even

 1278:           discrete Fourier transform, and, similarly, ``'RODFT'`` stands

 1279:           for 'real odd discrete Fourier transform'. The trailing ``'0'``

 1280:           is notation for even data (in terms of symmetry) and the

 1281:           trailing ``'1'`` is for odd data.

 1282: 

 1283:           Unlike the plain discrete Fourier transform, one may specify a

 1284:           different real to real transformation over each axis: for example,

 1285: 

 1286:           .. code-block:: none

 1287:              a = pyfftw.empty_aligned((128,128,128))

 1288:              b = pyfftw.empty_aligned((128,128,128))

 1289:              directions = ['FFTW_REDFT00', 'FFTW_RODFT11']

 1290:              transform = pyfftw.FFTW(a, b, axes=(0, 2), direction=directions)

 1291: 

 1292:           will create a transformation across the first and last axes

 1293:           with a discrete cosine transform over the first and a discrete

 1294:           sine transform over the last.

 1295: 

 1296:           Unfortunately, since this class is ultimately just a wrapper

 1297:           for various transforms implemented in FFTW, one cannot combine

 1298:           real transformations with real to complex transformations in a

 1299:           single object.

 1300: 

 1301:         .. _FFTW_flags:

 1302: 

 1303:         * ``flags`` is a list of strings and is a subset of the

 1304:           flags that FFTW allows for the planners:

 1305: 

 1306:           * ``'FFTW_ESTIMATE'``, ``'FFTW_MEASURE'``, ``'FFTW_PATIENT'`` and

 1307:             ``'FFTW_EXHAUSTIVE'`` are supported. These describe the

 1308:             increasing amount of effort spent during the planning

 1309:             stage to create the fastest possible transform.

 1310:             Usually ``'FFTW_MEASURE'`` is a good compromise. If no flag

 1311:             is passed, the default ``'FFTW_MEASURE'`` is used.

 1312:           * ``'FFTW_UNALIGNED'`` is supported.

 1313:             This tells FFTW not to assume anything about the

 1314:             alignment of the data and disabling any SIMD capability

 1315:             (see below).

 1316:           * ``'FFTW_DESTROY_INPUT'`` is supported.

 1317:             This tells FFTW that the input array can be destroyed during

 1318:             the transform, sometimes allowing a faster algorithm to be

 1319:             used. The default behaviour is, if possible, to preserve the

 1320:             input. In the case of the 1D Backwards Real transform, this

 1321:             may result in a performance hit. In the case of a backwards

 1322:             real transform for greater than one dimension, it is not

 1323:             possible to preserve the input, making this flag implicit

 1324:             in that case. A little more on this is given

 1325:             :ref:`below<scheme_table>`.

 1326:           * ``'FFTW_WISDOM_ONLY'`` is supported.

 1327:             This tells FFTW to raise an error if no plan for this transform

 1328:             and data type is already in the wisdom. It thus provides a method

 1329:             to determine whether planning would require additional effort or the

 1330:             cached wisdom can be used. This flag should be combined with the

 1331:             various planning-effort flags (``'FFTW_ESTIMATE'``,

 1332:             ``'FFTW_MEASURE'``, etc.); if so, then an error will be raised if

 1333:             wisdom derived from that level of planning effort (or higher) is

 1334:             not present. If no planning-effort flag is used, the default of

 1335:             ``'FFTW_ESTIMATE'`` is assumed.

 1336:             Note that wisdom is specific to all the parameters, including the

 1337:             data alignment. That is, if wisdom was generated with input/output

 1338:             arrays with one specific alignment, using ``'FFTW_WISDOM_ONLY'``

 1339:             to create a plan for arrays with any different alignment will

 1340:             cause the ``'FFTW_WISDOM_ONLY'`` planning to fail. Thus it is

 1341:             important to specifically control the data alignment to make the

 1342:             best use of ``'FFTW_WISDOM_ONLY'``.

 1343: 

 1344:           The `FFTW planner flags documentation

 1345:           <http://www.fftw.org/fftw3_doc/Planner-Flags.html#Planner-Flags>`_

 1346:           has more information about the various flags and their impact.

 1347:           Note that only the flags documented here are supported.

 1348: 

 1349:         * ``threads`` tells the wrapper how many threads to use

 1350:           when invoking FFTW, with a default of 1. If the number

 1351:           of threads is greater than 1, then the GIL is released

 1352:           by necessity.

 1353: 

 1354:         * ``planning_timelimit`` is a floating point number that

 1355:           indicates to the underlying FFTW planner the maximum number of

 1356:           seconds it should spend planning the FFT. This is a rough

 1357:           estimate and corresponds to calling of ``fftw_set_timelimit()``

 1358:           (or an equivalent dependent on type) in the underlying FFTW

 1359:           library. If ``None`` is set, the planner will run indefinitely

 1360:           until all the planning modes allowed by the flags have been

 1361:           tried. See the `FFTW planner flags page

 1362:           <http://www.fftw.org/fftw3_doc/Planner-Flags.html#Planner-Flags>`_

 1363:           for more information on this.

 1364: 

 1365:         .. _fftw_schemes:

 1366: 

 1367:         **Schemes**

 1368: 

 1369:         The currently supported full (so not discrete sine or discrete

 1370:         cosine) DFT schemes are as follows:

 1371: 

 1372:         .. _scheme_table:

 1373: 

 1374:         +----------------+-----------------------+------------------------+-----------+

 1375:         | Type           | ``input_array.dtype`` | ``output_array.dtype`` | Direction |

 1376:         +================+=======================+========================+===========+

 1377:         | Complex        | ``complex64``         | ``complex64``          | Both      |

 1378:         +----------------+-----------------------+------------------------+-----------+

 1379:         | Complex        | ``complex128``        | ``complex128``         | Both      |

 1380:         +----------------+-----------------------+------------------------+-----------+

 1381:         | Complex        | ``clongdouble``       | ``clongdouble``        | Both      |

 1382:         +----------------+-----------------------+------------------------+-----------+

 1383:         | Real           | ``float32``           | ``complex64``          | Forwards  |

 1384:         +----------------+-----------------------+------------------------+-----------+

 1385:         | Real           | ``float64``           | ``complex128``         | Forwards  |

 1386:         +----------------+-----------------------+------------------------+-----------+

 1387:         | Real           | ``longdouble``        | ``clongdouble``        | Forwards  |

 1388:         +----------------+-----------------------+------------------------+-----------+

 1389:         | Real\ :sup:`1` | ``complex64``         | ``float32``            | Backwards |

 1390:         +----------------+-----------------------+------------------------+-----------+

 1391:         | Real\ :sup:`1` | ``complex128``        | ``float64``            | Backwards |

 1392:         +----------------+-----------------------+------------------------+-----------+

 1393:         | Real\ :sup:`1` | ``clongdouble``       | ``longdouble``         | Backwards |

 1394:         +----------------+-----------------------+------------------------+-----------+

 1395: 

 1396:         \ :sup:`1`  Note that the Backwards Real transform for the case

 1397:         in which the dimensionality of the transform is greater than 1

 1398:         will destroy the input array. This is inherent to FFTW and the only

 1399:         general work-around for this is to copy the array prior to

 1400:         performing the transform. In the case where the dimensionality

 1401:         of the transform is 1, the default is to preserve the input array.

 1402:         This is different from the default in the underlying library, and

 1403:         some speed gain may be achieved by allowing the input array to

 1404:         be destroyed by passing the ``'FFTW_DESTROY_INPUT'``

 1405:         :ref:`flag <FFTW_flags>`.

 1406: 

 1407:         The discrete sine and discrete cosine transforms are supported

 1408:         for all three real types.

 1409: 

 1410:         ``clongdouble`` typically maps directly to ``complex256``

 1411:         or ``complex192``, and ``longdouble`` to ``float128`` or

 1412:         ``float96``, dependent on platform.

 1413: 

 1414:         The relative shapes of the arrays should be as follows:

 1415: 

 1416:         * For a Complex transform, ``output_array.shape == input_array.shape``

 1417:         * For a Real transform in the Forwards direction, both the following

 1418:           should be true:

 1419: 

 1420:           * ``output_array.shape[axes][-1] == input_array.shape[axes][-1]//2 + 1``

 1421:           * All the other axes should be equal in length.

 1422: 

 1423:         * For a Real transform in the Backwards direction, both the following

 1424:           should be true:

 1425: 

 1426:           * ``input_array.shape[axes][-1] == output_array.shape[axes][-1]//2 + 1``

 1427:           * All the other axes should be equal in length.

 1428: 

 1429:         In the above expressions for the Real transform, the ``axes``

 1430:         arguments denotes the unique set of axes on which we are taking

 1431:         the FFT, in the order passed. It is the last of these axes that

 1432:         is subject to the special case shown.

 1433: 

 1434:         The shapes for the real transforms corresponds to those

 1435:         stipulated by the FFTW library. Further information can be

 1436:         found in the FFTW documentation on the `real DFT

 1437:         <http://www.fftw.org/fftw3_doc/Guru-Real_002ddata-DFTs.html>`_.

 1438: 

 1439:         The actual arrangement in memory is arbitrary and the scheme

 1440:         can be planned for any set of strides on either the input

 1441:         or the output. The user should not have to worry about this

 1442:         and any valid numpy array should work just fine.

 1443: 

 1444:         What is calculated is exactly what FFTW calculates.

 1445:         Notably, this is an unnormalized transform so should

 1446:         be scaled as necessary (fft followed by ifft will scale

 1447:         the input by N, the product of the dimensions along which

 1448:         the DFT is taken). For further information, see the

 1449:         `FFTW documentation

 1450:         <http://www.fftw.org/fftw3_doc/What-FFTW-Really-Computes.html>`_.

 1451: 

 1452:         The FFTW library benefits greatly from the beginning of each

 1453:         DFT axes being aligned on the correct byte boundary, enabling

 1454:         SIMD instructions. By default, if the data begins on such a

 1455:         boundary, then FFTW will be allowed to try and enable

 1456:         SIMD instructions. This means that all future changes to

 1457:         the data arrays will be checked for similar alignment. SIMD

 1458:         instructions can be explicitly disabled by setting the

 1459:         FFTW_UNALIGNED flags, to allow for updates with unaligned

 1460:         data.

 1461: 

 1462:         :func:`~pyfftw.byte_align` and

 1463:         :func:`~pyfftw.empty_aligned` are two methods

 1464:         included with this module for producing aligned arrays.

 1465: 

 1466:         The optimum alignment for the running platform is provided

 1467:         by :data:`pyfftw.simd_alignment`, though a different alignment

 1468:         may still result in some performance improvement. For example,

 1469:         if the processor supports AVX (requiring 32-byte alignment) as

 1470:         well as SSE (requiring 16-byte alignment), then if the array

 1471:         is 16-byte aligned, SSE will still be used.

 1472: 

 1473:         It's worth noting that just being aligned may not be sufficient

 1474:         to create the fastest possible transform. For example, if the

 1475:         array is not contiguous (i.e. certain axes are displaced in

 1476:         memory), it may be faster to plan a transform for a contiguous

 1477:         array, and then rely on the array being copied in before the

 1478:         transform (which :class:`pyfftw.FFTW` will handle for you when

 1479:         accessed through :meth:`~pyfftw.FFTW.__call__`).

 1480:         '''

 1481: 

+1482:     def __dealloc__(self):

/* Python wrapper */
static void __pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_39__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_39__dealloc__(PyObject *__pyx_v_self) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
  __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_38__dealloc__(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_38__dealloc__(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__", 0);
/* … */
  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

 1483: 

+1484:         if not self._axes == NULL:

  __pyx_t_1 = ((!((__pyx_v_self->_axes == NULL) != 0)) != 0);
  if (__pyx_t_1) {
/* … */
  }

+1485:             free(self._axes)

    free(__pyx_v_self->_axes);

 1486: 

+1487:         if not self._not_axes == NULL:

  __pyx_t_1 = ((!((__pyx_v_self->_not_axes == NULL) != 0)) != 0);
  if (__pyx_t_1) {
/* … */
  }

+1488:             free(self._not_axes)

    free(__pyx_v_self->_not_axes);

 1489: 

+1490:         if not self._plan == NULL:

  __pyx_t_1 = ((!((__pyx_v_self->_plan == NULL) != 0)) != 0);
  if (__pyx_t_1) {
/* … */
  }

+1491:             self._fftw_destroy(self._plan)

    __pyx_v_self->_fftw_destroy(__pyx_v_self->_plan);

 1492: 

+1493:         if not self._dims == NULL:

  __pyx_t_1 = ((!((__pyx_v_self->_dims == NULL) != 0)) != 0);
  if (__pyx_t_1) {
/* … */
  }

+1494:             free(self._dims)

    free(__pyx_v_self->_dims);

 1495: 

+1496:         if not self._howmany_dims == NULL:

  __pyx_t_1 = ((!((__pyx_v_self->_howmany_dims == NULL) != 0)) != 0);
  if (__pyx_t_1) {
/* … */
  }

+1497:             free(self._howmany_dims)

    free(__pyx_v_self->_howmany_dims);

 1498: 

+1499:         if not self._direction == NULL:

  __pyx_t_1 = ((!((__pyx_v_self->_direction == NULL) != 0)) != 0);
  if (__pyx_t_1) {
/* … */
  }

+1500:             free(self._direction)

    free(__pyx_v_self->_direction);

 1501: 

+1502:     def __call__(self, input_array=None, output_array=None,

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_41__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_40__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 updating the arrays and\n        calling :meth:`~pyfftw.FFTW.execute`).\n\n        If ``normalise_idft`` is ``True`` (the default), then the output from\n        an inverse DFT (i.e. when the direction flag is ``'FFTW_BACKWARD'``) is\n        scaled by 1/N, where N is the product of the lengths of input array on\n        which the FFT is taken. If the direction is ``'FFTW_FORWARD'``, this\n        flag makes no difference to the output array.\n\n        If ``ortho`` is ``True``, then the output of both forward\n        and inverse DFT operations is scaled by 1/sqrt(N), where N is the\n        product of the lengths of input array on which the FFT is taken.  This\n        ensures that the DFT is a unitary operation, meaning that it satisfies\n        Parseval's theorem (the sum of the squared values of the transform\n        output is equal to the sum of the squared values of the input).  In\n        other words, the energy of the signal is preserved.\n\n        If either ``normalise_idft`` or ``ortho`` are ``True``, then\n        ifft(fft(A)) = A.\n\n        When ``input_array`` is something other than None, then the passed in\n        array is coerced to be the same dtype as the input array used when the\n        class was instantiated, the byte-alignment of the passed in array is\n        made consistent with the expected byte-alignment and the striding is\n        made consistent with the expected striding. All this may, but not\n        necessarily, require a copy to be made.\n\n        As noted in the :ref:`scheme table<scheme_table>`, if the"" FFTW\n        instance describes a backwards real transform of more than one\n        dimension, the contents of the input array will be destroyed. It is\n        up to the calling function to make a copy if it is necessary to\n        maintain the input array.\n\n        ``output_array`` is always used as-is if possible. If the dtype, the\n        alignment or the striding is incorrect for the FFTW object, then a\n        ``ValueError`` is raised.\n\n        The coerced input array and the output array (as appropriate) are\n        then passed as arguments to\n        :meth:`~pyfftw.FFTW.update_arrays`, after which\n        :meth:`~pyfftw.FFTW.execute` is called, and then normalisation\n        is applied to the output array if that is desired.\n\n        Note that it is possible to pass some data structure that can be\n        converted to an array, such as a list, so long as it fits the data\n        requirements of the class instance, such as array shape.\n\n        Other than the dtype and the alignment of the passed in arrays, the\n        rest of the requirements on the arrays mandated by\n        :meth:`~pyfftw.FFTW.update_arrays` are enforced.\n\n        A ``None`` argument to either keyword means that that array is not\n        updated.\n\n        The result of the FFT is returned. This is the same array that is used\n        internally and will be overwritten again on subsequent calls. If you\n        need the data to persist longer than a subsequent call, you should\n        copy the returned array.\n        ";
#if CYTHON_COMPILING_IN_CPYTHON
struct wrapperbase __pyx_wrapperbase_6pyrost_3bin_6pyfftw_4FFTW_40__call__;
#endif
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_41__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_input_array = 0;
  PyObject *__pyx_v_output_array = 0;
  PyObject *__pyx_v_normalise_idft = 0;
  PyObject *__pyx_v_ortho = 0;
  PyObject *__pyx_r = 0;
  __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,&__pyx_n_s_ortho,0};
    PyObject* values[4] = {0,0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
/* … */
  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_40__call__(struct __pyx_obj_6pyrost_3bin_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
  __Pyx_RefNannySetupContext("__call__", 0);
  __Pyx_INCREF(__pyx_v_input_array);
  __Pyx_INCREF(__pyx_v_output_array);
  __Pyx_INCREF(__pyx_v_normalise_idft);
  __Pyx_INCREF(__pyx_v_ortho);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_input_array);
  __Pyx_XDECREF(__pyx_v_output_array);
  __Pyx_XDECREF(__pyx_v_normalise_idft);
  __Pyx_XDECREF(__pyx_v_ortho);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1503:             normalise_idft=None, ortho=None):

    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    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);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_array);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_output_array);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normalise_idft);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__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_ERR(0, 1502, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __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, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1502, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_40__call__(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self), __pyx_v_input_array, __pyx_v_output_array, __pyx_v_normalise_idft, __pyx_v_ortho);

 1504:         '''__call__(input_array=None, output_array=None, normalise_idft=True,

 1505:                     ortho=False)

 1506: 

 1507:         Calling the class instance (optionally) updates the arrays, then

 1508:         calls :meth:`~pyfftw.FFTW.execute`, before optionally normalising

 1509:         the output and returning the output array.

 1510: 

 1511:         It has some built-in helpers to make life simpler for the calling

 1512:         functions (as distinct from manually updating the arrays and

 1513:         calling :meth:`~pyfftw.FFTW.execute`).

 1514: 

 1515:         If ``normalise_idft`` is ``True`` (the default), then the output from

 1516:         an inverse DFT (i.e. when the direction flag is ``'FFTW_BACKWARD'``) is

 1517:         scaled by 1/N, where N is the product of the lengths of input array on

 1518:         which the FFT is taken. If the direction is ``'FFTW_FORWARD'``, this

 1519:         flag makes no difference to the output array.

 1520: 

 1521:         If ``ortho`` is ``True``, then the output of both forward

 1522:         and inverse DFT operations is scaled by 1/sqrt(N), where N is the

 1523:         product of the lengths of input array on which the FFT is taken.  This

 1524:         ensures that the DFT is a unitary operation, meaning that it satisfies

 1525:         Parseval's theorem (the sum of the squared values of the transform

 1526:         output is equal to the sum of the squared values of the input).  In

 1527:         other words, the energy of the signal is preserved.

 1528: 

 1529:         If either ``normalise_idft`` or ``ortho`` are ``True``, then

 1530:         ifft(fft(A)) = A.

 1531: 

 1532:         When ``input_array`` is something other than None, then the passed in

 1533:         array is coerced to be the same dtype as the input array used when the

 1534:         class was instantiated, the byte-alignment of the passed in array is

 1535:         made consistent with the expected byte-alignment and the striding is

 1536:         made consistent with the expected striding. All this may, but not

 1537:         necessarily, require a copy to be made.

 1538: 

 1539:         As noted in the :ref:`scheme table<scheme_table>`, if the FFTW

 1540:         instance describes a backwards real transform of more than one

 1541:         dimension, the contents of the input array will be destroyed. It is

 1542:         up to the calling function to make a copy if it is necessary to

 1543:         maintain the input array.

 1544: 

 1545:         ``output_array`` is always used as-is if possible. If the dtype, the

 1546:         alignment or the striding is incorrect for the FFTW object, then a

 1547:         ``ValueError`` is raised.

 1548: 

 1549:         The coerced input array and the output array (as appropriate) are

 1550:         then passed as arguments to

 1551:         :meth:`~pyfftw.FFTW.update_arrays`, after which

 1552:         :meth:`~pyfftw.FFTW.execute` is called, and then normalisation

 1553:         is applied to the output array if that is desired.

 1554: 

 1555:         Note that it is possible to pass some data structure that can be

 1556:         converted to an array, such as a list, so long as it fits the data

 1557:         requirements of the class instance, such as array shape.

 1558: 

 1559:         Other than the dtype and the alignment of the passed in arrays, the

 1560:         rest of the requirements on the arrays mandated by

 1561:         :meth:`~pyfftw.FFTW.update_arrays` are enforced.

 1562: 

 1563:         A ``None`` argument to either keyword means that that array is not

 1564:         updated.

 1565: 

 1566:         The result of the FFT is returned. This is the same array that is used

 1567:         internally and will be overwritten again on subsequent calls. If you

 1568:         need the data to persist longer than a subsequent call, you should

 1569:         copy the returned array.

 1570:         '''

 1571: 

+1572:         if ortho is None:

  __pyx_t_1 = (__pyx_v_ortho == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
/* … */
  }

+1573:             ortho = self._ortho

    __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_self->_ortho); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1573, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_ortho, __pyx_t_3);
    __pyx_t_3 = 0;

+1574:         if normalise_idft is None:

  __pyx_t_2 = (__pyx_v_normalise_idft == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
/* … */
  }

+1575:             normalise_idft = self._normalise_idft

    __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_self->_normalise_idft); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1575, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_normalise_idft, __pyx_t_3);
    __pyx_t_3 = 0;

 1576: 

+1577:         if ortho and normalise_idft:

  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_ortho); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1577, __pyx_L1_error)
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L6_bool_binop_done;
  }
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_normalise_idft); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1577, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_2;
  __pyx_L6_bool_binop_done:;
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+1578:             raise ValueError('Invalid options: ortho and normalise_idft cannot'

    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1578, __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_ERR(0, 1578, __pyx_L1_error)

 1579:                              ' both be True.')

 1580: 

+1581:         if input_array is not None or output_array is not None:

  __pyx_t_2 = (__pyx_v_input_array != Py_None);
  __pyx_t_4 = (__pyx_t_2 != 0);
  if (!__pyx_t_4) {
  } else {
    __pyx_t_1 = __pyx_t_4;
    goto __pyx_L9_bool_binop_done;
  }
  __pyx_t_4 = (__pyx_v_output_array != Py_None);
  __pyx_t_2 = (__pyx_t_4 != 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L9_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

 1582: 

+1583:             if input_array is None:

    __pyx_t_1 = (__pyx_v_input_array == Py_None);
    __pyx_t_2 = (__pyx_t_1 != 0);
    if (__pyx_t_2) {
/* … */
    }

+1584:                 input_array = self._input_array

      __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;

 1585: 

+1586:             if output_array is None:

    __pyx_t_2 = (__pyx_v_output_array == Py_None);
    __pyx_t_1 = (__pyx_t_2 != 0);
    if (__pyx_t_1) {
/* … */
    }

+1587:                 output_array = self._output_array

      __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;

 1588: 

+1589:             if not isinstance(input_array, np.ndarray):

    __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray); 
    __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
    if (__pyx_t_2) {
/* … */
      goto __pyx_L13;
    }

+1590:                 copy_needed = True

      __pyx_v_copy_needed = 1;

+1591:             elif (not input_array.dtype == self._input_dtype):

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1591, __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_ERR(0, 1591, __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_ERR(0, 1591, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_1 = ((!__pyx_t_2) != 0);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L13;
    }

+1592:                 copy_needed = True

      __pyx_v_copy_needed = 1;

+1593:             elif (not input_array.strides == self._input_strides):

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1593, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __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_ERR(0, 1593, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1593, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_2 = ((!__pyx_t_1) != 0);
    if (__pyx_t_2) {
/* … */
      goto __pyx_L13;
    }

+1594:                 copy_needed = True

      __pyx_v_copy_needed = 1;

+1595:             elif not (<intptr_t>np.PyArray_DATA(input_array)

    if (!(likely(((__pyx_v_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1595, __pyx_L1_error)
    __pyx_t_3 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_input_array)))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1595, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
/* … */
    __pyx_t_1 = ((!__pyx_t_2) != 0);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L13;
    }

+1596:                     % self.input_alignment == 0):

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_alignment); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1596, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PyNumber_Remainder(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1596, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __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_ERR(0, 1596, __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_ERR(0, 1596, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1597:                 copy_needed = True

      __pyx_v_copy_needed = 1;

 1598:             else:

+1599:                 copy_needed = False

    /*else*/ {
      __pyx_v_copy_needed = 0;
    }
    __pyx_L13:;

 1600: 

+1601:             if copy_needed:

    __pyx_t_1 = (__pyx_v_copy_needed != 0);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L14;
    }

 1602: 

+1603:                 if not isinstance(input_array, np.ndarray):

      __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_input_array, __pyx_ptype_5numpy_ndarray); 
      __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
      if (__pyx_t_2) {
/* … */
      }

+1604:                     input_array = np.asanyarray(input_array)

        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1604, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_asanyarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1604, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_6 = NULL;
        if (CYTHON_UNPACK_METHODS && 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_3);
            __Pyx_INCREF(__pyx_t_6);
            __Pyx_INCREF(function);
            __Pyx_DECREF_SET(__pyx_t_3, function);
          }
        }
        __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_6, __pyx_v_input_array) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_input_array);
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1604, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF_SET(__pyx_v_input_array, __pyx_t_5);
        __pyx_t_5 = 0;

 1605: 

+1606:                 if not input_array.shape == self._input_shape:

      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1606, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __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_ERR(0, 1606, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1606, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_1 = ((!__pyx_t_2) != 0);
      if (unlikely(__pyx_t_1)) {
/* … */
      }

+1607:                     raise ValueError('Invalid input shape: '

        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1607, __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_ERR(0, 1607, __pyx_L1_error)
/* … */
  __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_u_Invalid_input_shape_The_new_inpu); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 1607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__22);
  __Pyx_GIVEREF(__pyx_tuple__22);

 1608:                             'The new input array should be the same shape '

 1609:                             'as the input array used to instantiate the '

 1610:                             'object.')

 1611: 

+1612:                 self._input_array[:] = input_array

      if (__Pyx_PyObject_SetSlice(((PyObject *)__pyx_v_self->_input_array), __pyx_v_input_array, 0, 0, NULL, NULL, &__pyx_slice__2, 0, 0, 0) < 0) __PYX_ERR(0, 1612, __pyx_L1_error)

 1613: 

+1614:                 if output_array is not None:

      __pyx_t_1 = (__pyx_v_output_array != Py_None);
      __pyx_t_2 = (__pyx_t_1 != 0);
      if (__pyx_t_2) {
/* … */
      }

 1615:                     # No point wasting time if no update is necessary

 1616:                     # (which the copy above may have avoided)

+1617:                     input_array = self._input_array

        __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;

+1618:                     self.update_arrays(input_array, output_array)

        __pyx_t_3 = ((struct __pyx_vtabstruct_6pyrost_3bin_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_ERR(0, 1618, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1619: 

 1620:             else:

+1621:                 self.update_arrays(input_array, output_array)

    /*else*/ {
      __pyx_t_3 = ((struct __pyx_vtabstruct_6pyrost_3bin_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_ERR(0, 1621, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    }
    __pyx_L14:;

 1622: 

+1623:         self.execute()

  __pyx_t_3 = ((struct __pyx_vtabstruct_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self->__pyx_vtab)->execute(__pyx_v_self, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1623, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1624: 

+1625:         if ortho == True:

  __pyx_t_3 = PyObject_RichCompare(__pyx_v_ortho, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1625, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1625, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_2) {
/* … */
  }

+1626:             self._output_array *= self._sqrt_normalisation_scaling

    __pyx_t_3 = PyFloat_FromDouble(__pyx_v_self->_sqrt_normalisation_scaling); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1626, __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_ERR(0, 1626, __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_ERR(0, 1626, __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;

 1627: 

+1628:         if self._direction[0] == FFTW_BACKWARD and normalise_idft:

  __pyx_t_1 = (((__pyx_v_self->_direction[0]) == __pyx_e_6pyrost_3bin_6pyfftw_FFTW_BACKWARD) != 0);
  if (__pyx_t_1) {
  } else {
    __pyx_t_2 = __pyx_t_1;
    goto __pyx_L20_bool_binop_done;
  }
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_normalise_idft); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1628, __pyx_L1_error)
  __pyx_t_2 = __pyx_t_1;
  __pyx_L20_bool_binop_done:;
  if (__pyx_t_2) {
/* … */
  }

+1629:             self._output_array *= self._normalisation_scaling

    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_self->_normalisation_scaling); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1629, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = PyNumber_InPlaceMultiply(((PyObject *)__pyx_v_self->_output_array), __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1629, __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_ERR(0, 1629, __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_3);
    __pyx_t_3 = 0;

 1630: 

+1631:         return self._output_array

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self->_output_array));
  __pyx_r = ((PyObject *)__pyx_v_self->_output_array);
  goto __pyx_L0;

 1632: 

+1633:     cpdef update_arrays(self, new_input_array, new_output_array):

static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_43update_arrays(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_6pyrost_3bin_6pyfftw_4FFTW_update_arrays(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self, PyObject *__pyx_v_new_input_array, PyObject *__pyx_v_new_output_array, int __pyx_skip_dispatch) {
  PyObject *__pyx_v_new_input_shape = NULL;
  PyObject *__pyx_v_new_output_shape = NULL;
  PyObject *__pyx_v_new_input_strides = NULL;
  PyObject *__pyx_v_new_output_strides = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("update_arrays", 0);
  /* Check if called by wrapper */
  if (unlikely(__pyx_skip_dispatch)) ;
  /* Check if overridden in Python */
  else if (unlikely((Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) {
    #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
    if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) {
      PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      #endif
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_update_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1633, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_43update_arrays)) {
        __Pyx_XDECREF(__pyx_r);
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
        __pyx_t_5 = 0;
        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
          __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
          if (likely(__pyx_t_4)) {
            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(function);
            __Pyx_DECREF_SET(__pyx_t_3, function);
            __pyx_t_5 = 1;
          }
        }
        #if CYTHON_FAST_PYCALL
        if (PyFunction_Check(__pyx_t_3)) {
          PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_new_input_array, __pyx_v_new_output_array};
          __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1633, __pyx_L1_error)
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_GOTREF(__pyx_t_2);
        } else
        #endif
        #if CYTHON_FAST_PYCCALL
        if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
          PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_new_input_array, __pyx_v_new_output_array};
          __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1633, __pyx_L1_error)
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_GOTREF(__pyx_t_2);
        } else
        #endif
        {
          __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1633, __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;
          }
          __Pyx_INCREF(__pyx_v_new_input_array);
          __Pyx_GIVEREF(__pyx_v_new_input_array);
          PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_new_input_array);
          __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_ERR(0, 1633, __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;
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
      __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self));
      if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) {
        __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
      }
      #endif
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    }
    #endif
  }
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.update_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_new_input_shape);
  __Pyx_XDECREF(__pyx_v_new_output_shape);
  __Pyx_XDECREF(__pyx_v_new_input_strides);
  __Pyx_XDECREF(__pyx_v_new_output_strides);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_43update_arrays(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_42update_arrays[] = "FFTW.update_arrays(self, new_input_array, new_output_array)\nupdate_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        also be aligned so as to allow SIMD instructions (assuming, of\n        course, that the ``FFTW_UNALIGNED`` flag was not enabled).\n\n        The byte alignment requirement extends to requiring natural\n        alignment in the non-SIMD cases as well, but this is much less\n        stringent as it simply means avoiding arrays shifted by, say,\n        a single byte (which invariably takes some effort to\n        achieve!).\n\n        If all these conditions are not met, a ``ValueError`` will\n        be raised and the data will *not* be updated (though the\n        object will still be in a sane state).\n        ";
static PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_43update_arrays = {"update_arrays", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_43update_arrays, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_42update_arrays};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_43update_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;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("update_arrays (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_new_input_array,&__pyx_n_s_new_output_array,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_new_input_array)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_new_output_array)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("update_arrays", 1, 2, 2, 1); __PYX_ERR(0, 1633, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "update_arrays") < 0)) __PYX_ERR(0, 1633, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_new_input_array = values[0];
    __pyx_v_new_output_array = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("update_arrays", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1633, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.update_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_42update_arrays(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self), __pyx_v_new_input_array, __pyx_v_new_output_array);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_42update_arrays(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self, PyObject *__pyx_v_new_input_array, PyObject *__pyx_v_new_output_array) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("update_arrays", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_4FFTW_update_arrays(__pyx_v_self, __pyx_v_new_input_array, __pyx_v_new_output_array, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1633, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.update_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__96 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_new_input_array, __pyx_n_s_new_output_array); if (unlikely(!__pyx_tuple__96)) __PYX_ERR(0, 1633, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__96);
  __Pyx_GIVEREF(__pyx_tuple__96);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_43update_arrays, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW_update_arrays, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__97)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1633, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_update_arrays, __pyx_t_4) < 0) __PYX_ERR(0, 1633, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__97 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__96, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_update_arrays, 1633, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__97)) __PYX_ERR(0, 1633, __pyx_L1_error)

 1634:         '''update_arrays(new_input_array, new_output_array)

 1635: 

 1636:         Update the arrays upon which the DFT is taken.

 1637: 

 1638:         The new arrays should be of the same dtypes as the originals, the same

 1639:         shapes as the originals and should have the same strides between axes.

 1640:         If the original data was aligned so as to allow SIMD instructions

 1641:         (e.g. by being aligned on a 16-byte boundary), then the new array must

 1642:         also be aligned so as to allow SIMD instructions (assuming, of

 1643:         course, that the ``FFTW_UNALIGNED`` flag was not enabled).

 1644: 

 1645:         The byte alignment requirement extends to requiring natural

 1646:         alignment in the non-SIMD cases as well, but this is much less

 1647:         stringent as it simply means avoiding arrays shifted by, say,

 1648:         a single byte (which invariably takes some effort to

 1649:         achieve!).

 1650: 

 1651:         If all these conditions are not met, a ``ValueError`` will

 1652:         be raised and the data will *not* be updated (though the

 1653:         object will still be in a sane state).

 1654:         '''

+1655:         if not isinstance(new_input_array, np.ndarray):

  __pyx_t_7 = __Pyx_TypeCheck(__pyx_v_new_input_array, __pyx_ptype_5numpy_ndarray); 
  __pyx_t_8 = ((!(__pyx_t_7 != 0)) != 0);
  if (unlikely(__pyx_t_8)) {
/* … */
  }

+1656:             raise ValueError('Invalid input array: '

    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1656, __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_ERR(0, 1656, __pyx_L1_error)
/* … */
  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_u_Invalid_input_array_The_new_inpu); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 1656, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__23);
  __Pyx_GIVEREF(__pyx_tuple__23);

 1657:                     'The new input array needs to be an instance '

 1658:                     'of numpy.ndarray')

 1659: 

+1660:         if not isinstance(new_output_array, np.ndarray):

  __pyx_t_8 = __Pyx_TypeCheck(__pyx_v_new_output_array, __pyx_ptype_5numpy_ndarray); 
  __pyx_t_7 = ((!(__pyx_t_8 != 0)) != 0);
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+1661:             raise ValueError('Invalid output array '

    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1661, __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_ERR(0, 1661, __pyx_L1_error)
/* … */
  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_u_Invalid_output_array_The_new_out); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 1661, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__24);
  __Pyx_GIVEREF(__pyx_tuple__24);

 1662:                     'The new output array needs to be an instance '

 1663:                     'of numpy.ndarray')

 1664: 

+1665:         if not (<intptr_t>np.PyArray_DATA(new_input_array) %

  if (!(likely(((__pyx_v_new_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_input_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1665, __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_ERR(0, 1665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
/* … */
  __pyx_t_3 = PyNumber_Remainder(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1665, __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;
/* … */
  __pyx_t_8 = ((!__pyx_t_7) != 0);
  if (unlikely(__pyx_t_8)) {
/* … */
  }

+1666:                 self.input_alignment == 0):

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_alignment); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1666, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
/* … */
  __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1666, __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_ERR(0, 1666, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1667:             raise ValueError('Invalid input alignment: '

    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1667, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(0, 1667, __pyx_L1_error)

 1668:                     'The original arrays were %d-byte aligned. It is '

 1669:                     'necessary that the update input array is similarly '

+1670:                     'aligned.' % self.input_alignment)

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_alignment); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1670, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_Invalid_input_alignment_The_orig, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1670, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1671: 

+1672:         if not (<intptr_t>np.PyArray_DATA(new_output_array) %

  if (!(likely(((__pyx_v_new_output_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_output_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1672, __pyx_L1_error)
  __pyx_t_2 = PyInt_FromSsize_t(((intptr_t)PyArray_DATA(((PyArrayObject *)__pyx_v_new_output_array)))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
/* … */
  __pyx_t_1 = PyNumber_Remainder(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_t_7 = ((!__pyx_t_8) != 0);
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+1673:                 self.output_alignment == 0):

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_alignment); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
/* … */
  __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1673, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1674:             raise ValueError('Invalid output alignment: '

    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1674, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 1674, __pyx_L1_error)

 1675:                     'The original arrays were %d-byte aligned. It is '

 1676:                     'necessary that the update output array is similarly '

+1677:                     'aligned.' % self.output_alignment)

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_alignment); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1677, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_Invalid_output_alignment_The_ori, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1677, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1678: 

+1679:         if not new_input_array.dtype == self._input_dtype:

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_input_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1679, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_v_self->_input_dtype, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1679, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1679, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_8 = ((!__pyx_t_7) != 0);
  if (unlikely(__pyx_t_8)) {
/* … */
  }

+1680:             raise ValueError('Invalid input dtype: '

    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1680, __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_ERR(0, 1680, __pyx_L1_error)
/* … */
  __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_u_Invalid_input_dtype_The_new_inpu); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 1680, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__25);
  __Pyx_GIVEREF(__pyx_tuple__25);

 1681:                     'The new input array is not of the same '

 1682:                     'dtype as was originally planned for.')

 1683: 

+1684:         if not new_output_array.dtype == self._output_dtype:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_output_array, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1684, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_v_self->_output_dtype, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1684, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1684, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_7 = ((!__pyx_t_8) != 0);
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+1685:             raise ValueError('Invalid output dtype: '

    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1685, __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_ERR(0, 1685, __pyx_L1_error)
/* … */
  __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_u_Invalid_output_dtype_The_new_out); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 1685, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__26);
  __Pyx_GIVEREF(__pyx_tuple__26);

 1686:                     'The new output array is not of the same '

 1687:                     'dtype as was originally planned for.')

 1688: 

+1689:         new_input_shape = new_input_array.shape

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_input_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1689, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_new_input_shape = __pyx_t_3;
  __pyx_t_3 = 0;

+1690:         new_output_shape = new_output_array.shape

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_output_array, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1690, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_new_output_shape = __pyx_t_3;
  __pyx_t_3 = 0;

 1691: 

+1692:         new_input_strides = new_input_array.strides

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_input_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1692, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_new_input_strides = __pyx_t_3;
  __pyx_t_3 = 0;

+1693:         new_output_strides = new_output_array.strides

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_output_array, __pyx_n_s_strides); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1693, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_new_output_strides = __pyx_t_3;
  __pyx_t_3 = 0;

 1694: 

+1695:         if not new_input_shape == self._input_shape:

  __pyx_t_3 = PyObject_RichCompare(__pyx_v_new_input_shape, __pyx_v_self->_input_shape, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1695, __pyx_L1_error)
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1695, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_8 = ((!__pyx_t_7) != 0);
  if (unlikely(__pyx_t_8)) {
/* … */
  }

+1696:             raise ValueError('Invalid input shape: '

    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1696, __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_ERR(0, 1696, __pyx_L1_error)

 1697:                     'The new input array should be the same shape as '

 1698:                     'the input array used to instantiate the object.')

 1699: 

+1700:         if not new_output_shape == self._output_shape:

  __pyx_t_3 = PyObject_RichCompare(__pyx_v_new_output_shape, __pyx_v_self->_output_shape, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1700, __pyx_L1_error)
  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1700, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_7 = ((!__pyx_t_8) != 0);
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+1701:             raise ValueError('Invalid output shape: '

    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1701, __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_ERR(0, 1701, __pyx_L1_error)
/* … */
  __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_u_Invalid_output_shape_The_new_out); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 1701, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__27);
  __Pyx_GIVEREF(__pyx_tuple__27);

 1702:                     'The new output array should be the same shape as '

 1703:                     'the output array used to instantiate the object.')

 1704: 

+1705:         if not new_input_strides == self._input_strides:

  __pyx_t_3 = PyObject_RichCompare(__pyx_v_new_input_strides, __pyx_v_self->_input_strides, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1705, __pyx_L1_error)
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1705, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_8 = ((!__pyx_t_7) != 0);
  if (unlikely(__pyx_t_8)) {
/* … */
  }

+1706:             raise ValueError('Invalid input striding: '

    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1706, __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_ERR(0, 1706, __pyx_L1_error)
/* … */
  __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_u_Invalid_input_striding_The_strid); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 1706, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__28);
  __Pyx_GIVEREF(__pyx_tuple__28);

 1707:                     'The strides should be identical for the new '

 1708:                     'input array as for the old.')

 1709: 

+1710:         if not new_output_strides == self._output_strides:

  __pyx_t_3 = PyObject_RichCompare(__pyx_v_new_output_strides, __pyx_v_self->_output_strides, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1710, __pyx_L1_error)
  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1710, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_7 = ((!__pyx_t_8) != 0);
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+1711:             raise ValueError('Invalid output striding: '

    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1711, __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_ERR(0, 1711, __pyx_L1_error)
/* … */
  __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_u_Invalid_output_striding_The_stri); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 1711, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__29);
  __Pyx_GIVEREF(__pyx_tuple__29);

 1712:                     'The strides should be identical for the new '

 1713:                     'output array as for the old.')

 1714: 

+1715:         self._update_arrays(new_input_array, new_output_array)

  if (!(likely(((__pyx_v_new_input_array) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_new_input_array, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1715, __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_ERR(0, 1715, __pyx_L1_error)
  __pyx_t_3 = ((struct __pyx_vtabstruct_6pyrost_3bin_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_3)) __PYX_ERR(0, 1715, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1716: 

+1717:     cdef _update_arrays(self, np.ndarray new_input_array,

static PyObject *__pyx_f_6pyrost_3bin_6pyfftw_4FFTW__update_arrays(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self, PyArrayObject *__pyx_v_new_input_array, PyArrayObject *__pyx_v_new_output_array) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_update_arrays", 0);
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1718:                         np.ndarray new_output_array):

 1719:         ''' A C interface to the update_arrays method that does not

 1720:         perform any checks on strides being correct and so on.

 1721:         '''

+1722:         self._input_array = new_input_array

  __Pyx_INCREF(((PyObject *)__pyx_v_new_input_array));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_new_input_array));
  __Pyx_GOTREF(__pyx_v_self->_input_array);
  __Pyx_DECREF(((PyObject *)__pyx_v_self->_input_array));
  __pyx_v_self->_input_array = __pyx_v_new_input_array;

+1723:         self._output_array = new_output_array

  __Pyx_INCREF(((PyObject *)__pyx_v_new_output_array));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_new_output_array));
  __Pyx_GOTREF(__pyx_v_self->_output_array);
  __Pyx_DECREF(((PyObject *)__pyx_v_self->_output_array));
  __pyx_v_self->_output_array = __pyx_v_new_output_array;

 1724: 

+1725:     def get_input_array(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_45get_input_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_44get_input_array[] = "FFTW.get_input_array(self)\nget_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 PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_45get_input_array = {"get_input_array", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_45get_input_array, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_44get_input_array};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_45get_input_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_input_array (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_44get_input_array(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_44get_input_array(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_input_array", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.get_input_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__98 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__98)) __PYX_ERR(0, 1725, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__98);
  __Pyx_GIVEREF(__pyx_tuple__98);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_45get_input_array, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW_get_input_array, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__99)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1725, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_input_array_2, __pyx_t_4) < 0) __PYX_ERR(0, 1725, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__99 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__98, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_input_array_2, 1725, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__99)) __PYX_ERR(0, 1725, __pyx_L1_error)

 1726:         '''get_input_array()

 1727: 

 1728:         Return the input array that is associated with the FFTW

 1729:         instance.

 1730: 

 1731:         *Deprecated since 0.10. Consider using the* :attr:`FFTW.input_array`

 1732:         *property instead.*

 1733:         '''

+1734:         warnings.warn('get_input_array is deprecated. '

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_warnings); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_warn); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_tuple__30 = PyTuple_Pack(2, __pyx_kp_u_get_input_array_is_deprecated_Co, __pyx_builtin_DeprecationWarning); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 1734, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__30);
  __Pyx_GIVEREF(__pyx_tuple__30);

 1735:                 'Consider using the input_array property instead.',

 1736:                 DeprecationWarning)

 1737: 

+1738:         return self._input_array

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self->_input_array));
  __pyx_r = ((PyObject *)__pyx_v_self->_input_array);
  goto __pyx_L0;

 1739: 

+1740:     def get_output_array(self):

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_47get_output_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_46get_output_array[] = "FFTW.get_output_array(self)\nget_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 PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_47get_output_array = {"get_output_array", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_47get_output_array, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_46get_output_array};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_47get_output_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_output_array (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_46get_output_array(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_46get_output_array(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_output_array", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.get_output_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__100 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__100)) __PYX_ERR(0, 1740, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__100);
  __Pyx_GIVEREF(__pyx_tuple__100);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_47get_output_array, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW_get_output_array, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__101)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1740, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_get_output_array_2, __pyx_t_4) < 0) __PYX_ERR(0, 1740, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__101 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__100, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_get_output_array_2, 1740, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__101)) __PYX_ERR(0, 1740, __pyx_L1_error)

 1741:         '''get_output_array()

 1742: 

 1743:         Return the output array that is associated with the FFTW

 1744:         instance.

 1745: 

 1746:         *Deprecated since 0.10. Consider using the* :attr:`FFTW.output_array`

 1747:         *property instead.*

 1748:         '''

+1749:         warnings.warn('get_output_array is deprecated. '

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_warnings); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1749, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_warn); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1749, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1749, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_tuple__31 = PyTuple_Pack(2, __pyx_kp_u_get_output_array_is_deprecated_C, __pyx_builtin_DeprecationWarning); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 1749, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__31);
  __Pyx_GIVEREF(__pyx_tuple__31);

 1750:                 'Consider using the output_array property instead.',

 1751:                 DeprecationWarning)

 1752: 

+1753:         return self._output_array

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self->_output_array));
  __pyx_r = ((PyObject *)__pyx_v_self->_output_array);
  goto __pyx_L0;

 1754: 

+1755:     cpdef execute(self):

static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_49execute(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_f_6pyrost_3bin_6pyfftw_4FFTW_execute(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self, int __pyx_skip_dispatch) {
  void *__pyx_v_input_pointer;
  void *__pyx_v_output_pointer;
  void *__pyx_v_plan;
  __pyx_t_6pyrost_3bin_6pyfftw_fftw_generic_execute __pyx_v_fftw_execute;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("execute", 0);
  /* Check if called by wrapper */
  if (unlikely(__pyx_skip_dispatch)) ;
  /* Check if overridden in Python */
  else if (unlikely((Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) {
    #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
    if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) {
      PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      #endif
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_execute); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1755, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_49execute)) {
        __Pyx_XDECREF(__pyx_r);
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
          __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
          if (likely(__pyx_t_4)) {
            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(function);
            __Pyx_DECREF_SET(__pyx_t_3, function);
          }
        }
        __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1755, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
      __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self));
      if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) {
        __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
      }
      #endif
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    }
    #endif
  }
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.execute", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_49execute(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_48execute[] = "FFTW.execute(self)\nexecute()\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 PyMethodDef __pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_49execute = {"execute", (PyCFunction)__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_49execute, METH_NOARGS, __pyx_doc_6pyrost_3bin_6pyfftw_4FFTW_48execute};
static PyObject *__pyx_pw_6pyrost_3bin_6pyfftw_4FFTW_49execute(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("execute (wrapper)", 0);
  __pyx_r = __pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_48execute(((struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6pyrost_3bin_6pyfftw_4FFTW_48execute(struct __pyx_obj_6pyrost_3bin_6pyfftw_FFTW *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("execute", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6pyrost_3bin_6pyfftw_4FFTW_execute(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("pyrost.bin.pyfftw.FFTW.execute", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__102 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__102)) __PYX_ERR(0, 1755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__102);
  __Pyx_GIVEREF(__pyx_tuple__102);
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_6pyrost_3bin_6pyfftw_4FFTW_49execute, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FFTW_execute, NULL, __pyx_n_s_pyrost_bin_pyfftw, __pyx_d, ((PyObject *)__pyx_codeobj__103)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW->tp_dict, __pyx_n_s_execute, __pyx_t_4) < 0) __PYX_ERR(0, 1755, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_6pyrost_3bin_6pyfftw_FFTW);
  __pyx_codeobj__103 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__102, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyrost_bin_pyfftw_pyx, __pyx_n_s_execute, 1755, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__103)) __PYX_ERR(0, 1755, __pyx_L1_error)

 1756:         '''execute()

 1757: 

 1758:         Execute the planned operation, taking the correct kind of FFT of

 1759:         the input array (i.e. :attr:`FFTW.input_array`),

 1760:         and putting the result in the output array (i.e.

 1761:         :attr:`FFTW.output_array`).

 1762:         '''

 1763:         cdef void *input_pointer = (

+1764:                 <void *>np.PyArray_DATA(self._input_array))

  __pyx_t_1 = ((PyObject *)__pyx_v_self->_input_array);
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_input_pointer = ((void *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1765:         cdef void *output_pointer = (

+1766:                 <void *>np.PyArray_DATA(self._output_array))

  __pyx_t_1 = ((PyObject *)__pyx_v_self->_output_array);
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_output_pointer = ((void *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1767: 

+1768:         cdef void *plan = self._plan

  __pyx_t_5 = __pyx_v_self->_plan;
  __pyx_v_plan = __pyx_t_5;

+1769:         cdef fftw_generic_execute fftw_execute = self._fftw_execute

  __pyx_t_6 = __pyx_v_self->_fftw_execute;
  __pyx_v_fftw_execute = __pyx_t_6;

+1770:         with nogil:

  {
      #ifdef WITH_THREAD
      PyThreadState *_save;
      Py_UNBLOCK_THREADS
      __Pyx_FastGIL_Remember();
      #endif
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          #ifdef WITH_THREAD
          __Pyx_FastGIL_Forget();
          Py_BLOCK_THREADS
          #endif
          goto __pyx_L5;
        }
        __pyx_L5:;
      }
  }

+1771:             fftw_execute(plan, input_pointer, output_pointer)

        __pyx_v_fftw_execute(__pyx_v_plan, __pyx_v_input_pointer, __pyx_v_output_pointer);
      }