Mehrdimensionale Arrays ins Unterprogramm

Hallo C-Programmierer

Ich möchte gerne eine Berechnung von mehreren mehrdimensionalen Arrays in einem Unterprogramm durchführen, allerdings ist mir der Knoten noch nicht aufgegangen - bzw habe ich schon etliche Methoden erfolglos ausprobiert.

Grundsätzlich gehts um ein Binding mit Python, was auch funktioniert.

Im folgenden Code steht die Berechnung

/* Do the calculation.    
    for ( i=0; i<n; i++)  {
        for ( j=0; j<m; j++)  {
	  cout[i][j] = cin[i][j];
	} 
    } */

Wenn ich diese auskommentiere funktioniert der Code einwandfrei - die Berechnung ist ja noch nicht allzu aufwändig

Nun stellt sich mir die Frage wie ich denn dieses cin der Subroutine compute übergebe und mir das cout retournieren lassen kann..
die größe des arrays ist derzeit noch fix zugeteilt, im Endeffekt werde ich eine Dimension auch noch mitübergeben müssen!

static PyObject *arr(PyObject *self, PyObject *args)
{
  PyArrayObject *values, *result;
  double **cin, **cout;
    int i,j,n,m, dims[2];

    /* Parse tuples */
    if (!PyArg_ParseTuple(args, "O!", 
			  &PyArray_Type, &values))  return NULL;
    if (NULL == values)  return NULL;

    /* Check that object input is 'double' type and a matrix */
    if (not_doublematrix(values)) return NULL;

    /* Get the dimensions of the input */
    n=dims[0]=values->dimensions[0];
    m=dims[1]=values->dimensions[1];

    /* Make a new double matrix of same dims */
    result=(PyArrayObject *) PyArray_SimpleNew(2,dims,NPY_DOUBLE);

    /* Change contiguous arrays into C ** arrays (Memory is Allocated!) */
    cin=pymatrix_to_Carrayptrs(values);
    cout=pymatrix_to_Carrayptrs(result);   

    /* Do the calculation.    
    for ( i=0; i<n; i++)  {
        for ( j=0; j<m; j++)  {
	  cout[i][j] = cin[i][j];
	} 
    } */

    cout = compute(cin);

    /* Free memory, close file and return */
    free_Carrayptrs(cin);
    free_Carrayptrs(cout);
    return PyArray_Return(result);
}

double **compute(double cin[][3]) {
  double **c;
  int i,j;

  for ( i=0; i<4; i++)  {
    for ( j=0; j<3; j++)  {
      c[i][j] = cin[i][j];
    } 
  }
  return c;

}

was mache ich hier bei der Übergabe falsch?

also der erste fehler der mir jetzt mal ins auge gesprungen ist, ist in der function compute() da solltest du double **c; iwie speicher geben bevor du da was zuweisen willst.

das passt auch nicht so super in ansi c aber naja evtl. taugen einem schlangen...

da sind sicher noch mehr fehler drin, z.b. passt der rückgabetyp von PyArray_SimpleNew() nicht denn das gibt laut doc ein (PyObject*) zurück, evtl. einfach mal hier bischen schnüffeln http://docs.scipy.org/doc/numpy/reference/c-api.array.html#creating-arrays

kann mich aber auch täuschen, bin afaik kein schlangen fan;)

auch wenn ich mir den speicher mit malloc reserviere, ändert das im moment noch nix...

die berechnung an sich funktioniert, nur das auslagern ins unterprogramm nicht!

/* Do the calculation.    
    for ( i=0; i<n; i++)  {
        for ( j=0; j<m; j++)  {
	  cout[i][j] = cin[i][j];
	} 
    } */

solang das nicht geht würd ich nicht weitermachen, bzw. den block in eine funktion auslagern...

ich will jetzt nicht anmaßend wirken... aber ich habe oben geschrieben, dass der Block funktioniert und ich den eben auslagern will

void compute(double **cout, double **cin, int n, int m){
  int i,j;
  for(i=0; i<n; i++){
    for(j=0; j<m; j++){
      cout[i][j] = cin[i][j];
    } 
  }
}

wenn das klappt dann schaut das auslagern so aus...

brennsuppa schrieb:

ich will jetzt nicht anmaßend wirken... aber ich habe oben geschrieben, dass der Block funktioniert und ich den eben auslagern will

willst du mich für blöd verkaufen oder was

brennsuppa schrieb:

...
Im folgenden Code steht die Berechnung
/* Do the calculation.    
    for ( i=0; i<n; i++)  {
        for ( j=0; j<m; j++)  {
	  cout[i][j] = cin[i][j];
	} 
    } */
Wenn ich diese auskommentiere funktioniert der Code einwandfrei - die Berechnung ist ja noch nicht allzu aufwändig
...

nein, ich will dich nicht für blöd verkaufen... missverständnis würd ich sagen!

aber ich danke dir für den C-Auffrischungskurs!
auf dem kann ich aufbauen - perfekt