Module using Numeric array: strange behaviour

[Phil]

Hi,

I don't understand this strange behaviour:

I compile this code :

   #include <Python.h>
   #include"Numeric/arrayobject.h"
   
   static PyObject *
   return_vector(PyObject *self, PyObject *args)
   {
   PyObject *input1;
   PyArrayObject  *vector;

   if (!PyArg_ParseTuple(args, "O", &input1))
   return NULL;

   vector = (PyArrayObject *)PyArray_ContiguousFromObject(input1,
PyArray_DOUBLE, 1, 1);

   if (vector == NULL)
   return NULL;

   return PyArray_Return(vector);

   }

   /* registration table  */
   static struct PyMethodDef testMethods[] = {
      {"return_vector", return_vector, 1},       /* method name, C func
ptr, always-tuple */
      {NULL, NULL}                   /* end of table marker */
   };
   
   /* module initializer */
   void inittest()                       /* called on first import */
   {                                      /* name matters if loaded
dynamically */
       (void) Py_InitModule("test",testMethods);   /* mod name, table ptr */
       import_array();        /* indispensable pour utiliser les arrays */
   }

Very simple: this module takes a Numeric array (vector) as argument and
send this array back to python...

If I compile it under macOSX, the result in python is:

>>> import test
>>> from Numeric import *
>>> v=array([1.0,2.0,3.0,4.0],Float)
>>> v
array([ 1.,  2.,  3.,  4.])
>>> test.return_vector(v)
array([ 1.,  2.,  3.,  4.])

but in linux the result is:

>>> import test
>>> from Numeric import *
>>> v=array([1.0,2.0,3.0,4.0],Float)
>>> v
array([ 1.,  2.,  3.,  4.])
>>> test.return_vector(v)
array([ 1.+0.j,  2.+0.j,  3.+0.j,  4.+0.j])

Strange !!! the result is a complex array.
The C vector is really complex because if I try to use it in the C module,
the result is...incomplete.
For example, if I try to multiply each item of the vector array by a
scalar ( pi for example) in a loop, I get this result in python:


>>> import test
>>> from Numeric import *
>>> v=array([1.0,2.0,3.0,4.0],Float)
>>> v
array([ 1.,  2.,  3.,  4.])
>>> test.return_vector(v)
array([ 3.14159265+0.j, 0.+0.j,  6.28318531+0.j,  0.+0.j])

It's the result of pi* 1.0, 0.0, 2.0, 0.0 ( the four first elements of the
internal representation of the complex array ([ 1.+0.j,  2.+0.j,  3.+0.j, 
4.+0.j]).

Anyone any idea where I'm going wrong?
Thank you for any help.

Philippe