Instead of using __init__/__cinit__ (which always expects Python objects as arguments), you can use a custom @staticmethod cdef to create instances: cdef class Tree: cdef glp_tree* ptr def __init__(self, *args): raise TypeError(‘Cannot create instance from Python’) @staticmethod cdef Tree create(glp_tree* ptr): obj = <Tree>Tree.__new__(Tree) # create instance without calling __init__ obj.ptr = ptr return obj
As discussed in the comments, the issue you’re having is because Cython doesn’t really support non-type template arguments. A workround (hacky and probably fragile) is to trick Cython into thinking it’s providing a type template argument: cdef extern from “<array>” namespace “std” nogil : cdef cppclass two “2”: pass cdef cppclass array[T, U]: T& operator[](size_t) … Read more
A good way is to have the main array beeing alocated ouside the threads. Then you give to each thread the pointer to the part of the main array that should be computed by the thread. The following example is an implementation of a matrix multiplication (similar to dot for 2-D arrays) where: c = … Read more
Using cython-module in a dll is not unlike using a cython-module in an embeded python interpreter. The first step would be to mark cdef-function which should be used from external C-code with public, for example: #cyfun.pyx: #doesn’t need python interpreter cdef public int double_me(int me): return 2*me; #needs initialized python interpreter cdef public void print_me(int … Read more
Starting from 18.0 release of setuptools (released on 2015-06-23) it is possible to specify Cython in setup_requires and pass *.pyx modules sources for regular setuptools.Extension: from setuptools import setup, Extension setup( # … setup_requires=[ # Setuptools 18.0 properly handles Cython extensions. ‘setuptools>=18.0’, ‘cython’, ], ext_modules=[ Extension( ‘mylib’, sources=[‘src/mylib.pyx’], ), ], )
Sure ! (In the following, I assume that you already know how to deal with cimport and the interactions between .pxd and .pyx. If this is not completely the case, just ask and I will develop that part as well) The sample (grabbed from a C++ project of mine, but a C project would work … Read more
The key difference is in where the function can be called from: def functions can be called from Python and Cython while cdef function can be called from Cython and C. Both types of functions can be declared with any mixture of typed and untyped arguments, and in both cases the internals are compiled to … Read more
It’s a bit complicated because the names have different meanings depending on the context. int In Python The int is normally just a Python type, it’s of arbitrary precision, meaning that you can store any conceivable integer inside it (as long as you have enough memory). >>> int(10**50) 100000000000000000000000000000000000000000000000000 However, when you use it as … Read more
Here’s a minimum working example. I used gfortran and wrote the compile commands directly into the setup file. gfunc.f90 module gfunc_module implicit none contains subroutine gfunc(x, n, m, a, b, c) double precision, intent(in) :: x integer, intent(in) :: n, m double precision, dimension(n), intent(in) :: a double precision, dimension(m), intent(in) :: b double precision, … Read more
I think the problem is your misconception, that distutils will build the executable for you. That is not the case. Out goal is to use some python functionality from a C-program. Let’s do the necessary steps by ourselves: Using cython to produce hello.h and hello.c from the given pyx-file. Using the created hello.h for importing … Read more