Everything related to the use of the C++ language
Sometimes, a C or C++ array structure must be used in Python, and it’s always better to be able to use the underlying array to do some Numpy computations. To that purpose, Numpy proposes the array interface.
I will now expose an efficient way to use SWIG to generate the array interface and exposing the __array_struct__ property.
Contrary to what the title may hint to, this book is an introduction to C++ and the Qt library. And in the process, the authors tried to teach some good practices through design patterns. So if you’re a good C++ or Qt programer, this book is not for you. If you’re a beginner, the answer is in my review.
After some general books on grid computation, I needed to change the subject of my readings a little bit. As Intel Threading Building Blocks always intrigued me, I chose the associated book.
In March 2008 issue, IEEE Computers published a case study on large-scale parallel scientific code development. I’d like to comment this article, a very good one in my mind.
Five research centers were analyzed, or more precisely their development tool and process. Each center did a research in a peculiar domain, but they seem share some Computational Fluid Dynamics basis.
This question was asked on the Scipy mailing-list last year (well, one week ago). Nathan Bell proposed a skeleton that I used to create an out typemap for SWIG.
%typemap(out) std::vector<double> {
int length = $1.size();
$result = PyArray_FromDims(1, &length, NPY_DOUBLE);
memcpy(PyArray_DATA((PyArrayObject*)$result),&((*(&$1))[0]),sizeof(double)*length);
}
This typemap uses obviously Numpy, so don’t forget to initialize the module and to import it. Then there is a strange instruction in memcpy. &((*(&$1))[0]) takes the address of the array of the vector, but as it is wrapped by SWIG, one has to get to the std::vector by dereferencing the SWIG wrapper. Then one can get the first element in the vector and take the address.
Edit on May 2017: This is my most recent trials with this.
%typemap(out) std::vector<float> {
npy_intp length = $1.size();
$result = PyArray_SimpleNew(1, &length, NPY_FLOAT);
memcpy(PyArray_DATA((PyArrayObject*)$result),$1.data(),sizeof(float)*length);
}
Some times ago, I proposed an optional build for SWIG if the SWIG binary was not found on the system. Here I propose an enhancement, a new library builder that will be registered in the environment env as PythonModule. It takes the same arguments as a classical SharedLibrary, but it does some additional steps :
When moving to Python, the real big problem that arises is the transformation of a Python array into the C++ container the team used for years.
Let’s set some hypothesis :
The first hypothesis is derived from the responsibility principle, the two classes have two distinct responsibilities, the first allocates the data space and allows simple access to it, the second allows usual operations (assignation, comparison tests or iterations for instance).
The second one will be the heart of the wrapper. It allows to change the way data is stored and accessed in a simple way.
I now regularly use Scons as a cross-platform software construction tool. It is easy, written in Python, and I know Python, so no problem learning a new language as for CMake. In some cases when I use SWIG, the target platform does not have the SWIG executable. But when compiling a module, Scons must use this executable, whatever you try to do. In this case, one need to create a new SharedLibrary builder, so that this attribute will determine if SWIG is present or if the generated .c or .cpp files must be used instead.