Restituire array numpy da un'estensione C

Question

Per motivi di apprendimento di qualcosa di nuovo, sto attualmente cercando di reimplementare la funzione numpy.mean() in C. Dovrebbe richiedere un array 3D e restituire un array 2D con la media del elementi lungo l'asse 0. Riesco a calcolare la media di tutti i valori, ma non so davvero come restituirei un nuovo array a Python. Dalle fonti che ho letto, penso che ciò comporti un serio gioco di destrezza con i puntatori e cose del genere, che non ho molta familiarità con (ma sono disposto a farlo).

Il mio codice finora:

#include <Python.h> 
#include <numpy/arrayobject.h> 

// Actual magic here: 
static PyObject* 
myexts_std(PyObject *self, PyObject *args) 
{ 
    PyArrayObject *input=NULL; 
    int i, j, k, x, y, z, dims[2]; 
    double out = 0.0; 

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

    x = input->dimensions[0]; 
    y = input->dimensions[1]; 
    z = input->dimensions[2]; 

    for(k=0;k<z;k++){ 
     for(j=0;j<y;j++){ 
      for(i=0;i < x; i++){ 
       out += *(double*)(input->data + i*input->strides[0] 
+j*input->strides[1] + k*input->strides[2]); 
      } 
     } 
    } 
    out /= x*y*z; 
    return Py_BuildValue("f", out); 
} 

// Methods table - this defines the interface to python by mapping names to 
// c-functions  
static PyMethodDef myextsMethods[] = { 
    {"std", myexts_std, METH_VARARGS, 
     "Calculate the standard deviation pixelwise."}, 
    {NULL, NULL, 0, NULL} 
}; 

PyMODINIT_FUNC initmyexts(void) 
{ 
    (void) Py_InitModule("myexts", myextsMethods); 
    import_array(); 
} 

Quello che ho capito finora (e vi prego di correggermi se sbaglio) è che ho bisogno di creare un nuovo PyArrayObject, che sarà la mia uscita (magari con PyArray_FromDims?). Poi ho bisogno di una serie di indirizzi per la memoria di questo array e riempirlo con i dati. Come andrei su questo?

EDIT:

Dopo aver fatto un po 'di lettura su puntatori (qui: http://pw1.netcom.com/~tjensen/ptr/pointers.htm), ho raggiunto quello che stavo puntando a. Ora sorge un'altra domanda: dove troverei l'implementazione originale di numpy.mean()? Mi piacerebbe vedere come è, che l'operazione Python è molto più veloce della mia versione. Presumo che eviti il ​​brutto looping.

Ecco la mia soluzione:

static PyObject* 
myexts_std(PyObject *self, PyObject *args) 
{ 
    PyArrayObject *input=NULL, *output=NULL; // will be pointer to actual numpy array ? 
    int i, j, k, x, y, z, dims[2]; // array dimensions ? 
    double *out = NULL; 
    if (!PyArg_ParseTuple(args, "O!", &PyArray_Type, &input)) 
     return NULL; 

    x = input->dimensions[0]; 
    y = dims[0] = input->dimensions[1]; 
    z = dims[1] = input->dimensions[2]; 
    output = PyArray_FromDims(2, dims, PyArray_DOUBLE);  
    for(k=0;k<z;k++){ 
     for(j=0;j<y;j++){ 
      out = output->data + j*output->strides[0] + k*output->strides[1]; 
      *out = 0; 
      for(i=0;i < x; i++){ 
       *out += *(double*)(input->data + i*input->strides[0] +j*input->strides[1] + k*input->strides[2]); 
      } 
      *out /= x; 
     } 
    } 
    return PyArray_Return(output); 
} 

Answer 1

L'API Numpy ha una funzione PyArray_Mean che compie ciò che si sta cercando di fare a meno del "brutto looping";).