How to use a C function with complex types in Python?

Question

I decided to port some of my Python functions to C, mostly following this simple tutorial. Problem is that my C function returns a complex float, and there's no corresponding type in ctypes's documentation. This is is a problem I couldn't solve myself with my limited knowledge on cross-language coding and C, even extended by Google.

My C function works like this:

#include <tgmath.h>
float _Complex integrand(float _Complex theta1, double r, double z){
    //[code] }

So, based on the tutorial, the corresponding Python wrapper (probably) should be something like this:

complextype = '??????'

_integr = ctypes.CDLL('libintegrand.so')
_integr.integrand.argtypes = (complextype, ctypes.c_double, ctypes.c_double)

def integrand(theta1, r, z):
    global _integr
    result = _integr.integrand(complextype(theta1), ctypes.c_double(r), ctypes.c_double(z))
    return float(result)

But what should this type be? How should I do this?

If the fact that the function also has a complex argument makes it significantly more complicated, please ignore the complex argument.

Answer 1

Create a small C wrapper function:

void integrand_wrapper(float *re, float *im, double r, double z)
{
    float _Complex  result;
    float _Complex  theta = (*re) + I*(*im);
    result = integrand(theta, r, z);
    (*re) = creal(result);
    (*im) = cimag(result);
}

The re and im pointers hold the real and imaginary parts of theta when called, and the real and imaginary parts of the result afterwards.

In your Python code, call integrand_wrapper() using e.g.

def integrand(theta, r, z):
    global _integr
    theta = complex(theta)
    re = c_float(theta.real)
    im = c_float(theta.imag)
    _integr.integrand_wrapper(byref(re), byref(im), c_double(r), c_double(z))
    return complex(float(re), float(im))

Note that if integrand() is defined in a binary library you cannot modify, you can always create another dynamic library containing only integrand_wrapper, that is dynamically linked (in C) to the original binary library.

Overall, I don't think the added overhead is significant at all. It is certainly worth testing.