Powracająca tablica numpy z rozszerzenia C

Question

Aby dowiedzieć się czegoś nowego, obecnie próbuję ponownie zaimplementować funkcję numpy.mean() w C. Powinno to zająć macierz 3D i zwrócić tablicę 2D ze średnią elementy wzdłuż osi 0. Udaje mi się obliczyć średnią wszystkich wartości, ale tak naprawdę nie wiem, w jaki sposób zwróciłbym nową tablicę do Pythona. Ze źródeł, które czytam, myślę, że wiąże się to z poważnym żonglowaniem ze wskazówkami i takimi, których nie znam (ale chcę się nimi stać).

Mój kod do tej pory:

#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(); 
} 

Co rozumiem tej pory (i proszę mnie poprawić, jeśli się mylę) jest to, że trzeba utworzyć nową PyArrayObject, który będzie moim wyjście (może z PyArray_FromDims?). Następnie potrzebuję tablicy adresów do pamięci tej tablicy i wypełnienia jej danymi. Jak bym to zrobił?

EDIT:

Po wykonaniu niektórych więcej czytania na wskaźnikach (tu: http://pw1.netcom.com/~tjensen/ptr/pointers.htm), osiągnąłem to, czego celem jest. Powstaje teraz inne pytanie: Gdzie znajdę oryginalną implementację numpy.mean()? Chciałbym zobaczyć, jak to jest, że operacja Pythona jest znacznie szybsza niż moja wersja. Zakładam, że unika brzydkiej pętli.

Oto moje rozwiązanie:

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

Numpy API posiada funkcję PyArray_Mean który realizuje to, co starasz się zrobić bez „brzydkich pętli”).