Add support for C99 complex type (_Complex) as ctypes.c_complex

[rutsky]

BPO	16899
Nosy	@arigo, @amauryfa, @mdickinson, @meadori

^{Note: these values reflect the state of the issue at the time it was migrated and might not reflect the current state.}

Show more details

GitHub fields:

assignee = None
closed_at = None
created_at = <Date 2013-01-08.22:06:03.435>
labels = ['ctypes', 'type-feature', '3.7']
title = 'Add support for C99 complex type (_Complex) as ctypes.c_complex'
updated_at = <Date 2018-07-04.15:01:25.648>
user = 'https://bugs.python.org/rutsky'

bugs.python.org fields:

activity = <Date 2018-07-04.15:01:25.648>
actor = 'arigo'
assignee = 'none'
closed = False
closed_date = None
closer = None
components = ['ctypes']
creation = <Date 2013-01-08.22:06:03.435>
creator = 'rutsky'
dependencies = []
files = []
hgrepos = []
issue_num = 16899
keywords = []
message_count = 10.0
messages = ['179378', '179459', '179609', '179646', '180759', '285961', '285998', '286453', '321046', '321049']
nosy_count = 8.0
nosy_names = ['arigo', 'amaury.forgeotdarc', 'mark.dickinson', 'Arfrever', 'meador.inge', 'rutsky', 'Tom Krauss', 'rkmountainguy']
pr_nums = []
priority = 'normal'
resolution = None
stage = 'test needed'
status = 'open'
superseder = None
type = 'enhancement'
url = 'https://bugs.python.org/issue16899'
versions = ['Python 3.7']

Linked PRs

• gh-61103: support double complex (_Complex) type in ctypes #120894
• gh-61103: Support float and long double complex types in ctypes module #121248

[rutsky]

It would be nice if Python will be able to access variables with C99 complex types through ctypes module.

[amauryfa]

libffi still has no support for _Complex.

Did you try with a pure Python solution, like the one suggested in http://objectmix.com/python/112374-re-ctypes-c99-complex-numbers.html

[rutsky]

Yes, I managed to pass and operate with matrices of complex numbers to pure C and Fortran programs by using Numpy and their ctype adapters (only for whole matrices, they don't provide c_complex type; in general see http://www.scipy.org/Cookbook/Ctypes for details).

I suppose pure python solution that suggested in provided by you link works too:

class Complex64(Structure):
    _fields_ = [("real", c_float), ("imag", c_float)]

But I'm unsure is this is expected behavior or luck, and on some platform this code will not work due to different complex numbers internal representation.

Any way this should be implemented in libffi first, and then in ctypes, so this feature request should be postponed, IMO.

[mdickinson]

But I'm unsure is this is expected behavior or luck, and on some
platform this code will not work due to different complex numbers
internal representation.

What platform? Isn't the complex number representation standard? E.g., C99 6.2.5p13 says: "Each complex type has the same representation and alignment requirements as an array type containing exactly two elements of the corresponding real type; the first element is equal to the real part, and the second element to the imaginary part, of the complex number."

[mdickinson]

Postponing as suggested.

[TomKrauss]

I'm trying to add support for this in cffi, which uses ctypes... apparently this is now supported in libffi (https://github.com/libffi/libffi, v3.2 Nov 2014).
It would be nice if this issue could be re-opened, or another one created for the same purpose.

[mdickinson]

Thanks, Tom. Re-opening.

[arigo]

• Tom: the issue is unrelated to cffi, but both ctypes and cffi could proceed to support C complexes, now that libffi support has been added.

• Mark: the problem is that the text you quote from the C standard fixes the representation of a complex in memory, but doesn't say anything about directly passing a complex as argument or return value to a function call. Platforms use custom ways to do that. The text you quote says a complex is an array of two real numbers; but passing an array as argument to a function works by passing a pointer to the first element. Typically, this is not how complexes are passed: instead, some pointerless form of "passing two real numbers" is used.

[rkmountainguy]

I concur with rutsky. Complex numbers are essential in the physical sciences, and the complex type is part of the c99 standard. Trying to shoehorn complex support by a user-defined type makes use of the builtin methods for the standard complex type clunky.

[arigo]

cffi supports complex numbers since release 1.11---for direct calls using the API mode. That means that neither CFFI's ABI mode, nor ctypes, can possibly work yet. The problem is still libffi's own support, which is still not implemented (apart on a very uncommon CPU architecture, the s390).

[skirpichev]

Pure python approach works for me so far (recent gcc/clang with glibc):

>>> import ctypes
>>> libm = ctypes.CDLL('libm.so.6')
>>> class c_complex(ctypes.Structure):
...     _fields_ = [("real", ctypes.c_double),
...                 ("imag", ctypes.c_double)]
...     @property
...     def value(self):
...         return complex(self.real, self.imag)
...
>>> libm.clog.argtypes = [c_complex]
>>> libm.clog.restype = c_complex
>>> libm.clog(c_complex(1, 1)).value
(0.34657359027997264+0.7853981633974483j)

But I'm working on adding primitive data types for C complexes in the ctypes. Naming: c_float_complex, c_double_complex (or just c_complex?) and c_longdouble_complex.

[picnixz]

My 2 cents: I'd go for c_double_complex instead of c_complex because it's the name used in Fortran (and it could be useful to have mapping names like that). In addition, since we use c_float_complex, using c_double_complex really stresses that we are using a double _Complex. Also, while GCC/clang assumes _Complex to be double _Complex, they raise a warning (assuming -Wpedantic and -Wsystem-headers for GCC).

[skirpichev]

PR ready for review: #120894

[vstinner]

Implemented by change 6988ff0.

[skirpichev]

Hmm, @vstinner, should this be closed? At least support for double _Complex was added, but there are float _Complex and long double _Complex, C standards specify three types. Adding these should be more or less mechanical, but maybe we should reconsider 1-char names for new types (see #120894 (comment)).

Also, the struct module can include an interface to _Complex (that part was removed from pr).

[vstinner]

I would prefer to only support double _Complex for now. I'm not sure that float and long double are popular enough.

[skirpichev]

I'm not sure that is about popularity. It's not why there are float and long double types, not just double.

[vstinner]

It's up to you. I reopen the issue.

[skirpichev]

PR is ready for review: #121248

Edit: and see also #121249