Function execute_real_forward

numpy/fft/_pocketfft.c:2230–2282

}

static PyObject *
execute_real_forward(PyObject *a1, double fct)
{
    rfft_plan plan=NULL;
    int fail = 0;
    npy_intp tdim[NPY_MAXDIMS];

    PyArrayObject *data = (PyArrayObject *)PyArray_FromAny(a1,
            PyArray_DescrFromType(NPY_DOUBLE), 1, 0,
            NPY_ARRAY_DEFAULT | NPY_ARRAY_ENSUREARRAY | NPY_ARRAY_FORCECAST,
            NULL);
    if (!data) return NULL;

    int ndim = PyArray_NDIM(data);
    const npy_intp *odim = PyArray_DIMS(data);
    int npts = odim[ndim - 1];
    for (int d=0; d<ndim-1; ++d)
      tdim[d] = odim[d];
    tdim[ndim-1] = npts/2 + 1;
    PyArrayObject *ret = (PyArrayObject *)PyArray_Empty(ndim,
            tdim, PyArray_DescrFromType(NPY_CDOUBLE), 0);
    if (!ret) fail=1;
    if (!fail) {
      int rstep = PyArray_DIM(ret, PyArray_NDIM(ret) - 1)*2;

      int nrepeats = PyArray_SIZE(data)/npts;
      double *rptr = (double *)PyArray_DATA(ret),
             *dptr = (double *)PyArray_DATA(data);

      Py_BEGIN_ALLOW_THREADS;
      plan = make_rfft_plan(npts);
      if (!plan) fail=1;
      if (!fail)
        for (int i = 0; i < nrepeats; i++) {
            rptr[rstep-1] = 0.0;
            memcpy((char *)(rptr+1), dptr, npts*sizeof(double));
            if (rfft_forward(plan, rptr+1, fct)!=0) {fail=1; break;}
            rptr[0] = rptr[1];
            rptr[1] = 0.0;
            rptr += rstep;
            dptr += npts;
      }
      if (plan) destroy_rfft_plan(plan);
      Py_END_ALLOW_THREADS;
    }
    if (fail) {
      Py_XDECREF(data);
      Py_XDECREF(ret);
      return PyErr_NoMemory();
    }
    Py_DECREF(data);
    return (PyObject *)ret;
}
static PyObject *
execute_real_backward(PyObject *a1, double fct)
{