Newsgroup: it.comp.lang.c
Titolo: array a + dimensioni

Buongiorno a tutti.
E' la prima volta che scrivo qua.
Sto scrivendo un programma R che richiama una funzione C.
--
Il problema fondamentale sta in questo array a 4 dimensioni.
double cov[t][s][t1][s1];
fino ad una certa dimensione (diciamo t=t1=22 e s=s1=49) il programma fa
cio' che deve fare.
Passati questi limiti C mi da segmentation fault.
La domanda e': ci sono dei limiti nella dimensione degli array?
Il tutto richiede troppa memoria?
Tenete conto che sono quasi agli inizi con C.
Vi ringrazio in anticipo e un saluto affettuoso dalla Spagna:)
 
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Il tutto richiede troppa memoria?
Non credo che sia questo il problema, visti i numeri che indichi. Più 
probabilmente hai allocato l'array come variabile automatica superando 
il limite di crescita dello stack.

 
Concordo. 22*22*49*49*8 = 9.296.672 basta che lo stack sia sui 10M ed il 
gioco è fatto :)
Segui il consiglio di AnalogFile!
My 0.002c
Remo


Nota che il limite a cui mi riferivo è il limite di crescita, non di 
dimensione. Nei sistemi windows lo stack "parte" di una dimensione x e 
può crescere anche di molto, ma la crescita è sicura solo entro un 
massimo di Y per ogni "colpo" (corrispondente ad uno stack frame, ovvero 
ad una funzione). Se una data funzione alloca variabili locali 
automatiche per un totale superiore ad Y non è garantito che il 
programma funzioni. Lo stack cresce a blocchi di tot pagine, se lo stack 
è appena cresciuto magari funziona, ma se le tot pagine sono già quasi 
impegnate ... segfault. Il valore Y è lo spazio "sentinella" usato da 
windows e potrebbe essere anche molto meno di 10 mega.
Non programmo windows da quasi 10 anni. Ma consiglio di dare un'occhiata 
ai vari parametri del compilatore C della microsoft. Da qulache parte 
questa cosa era spiegata abbastanza bene.


 


 bene) dipende dal sistema operativo o dal compilatore?
potrebbe dipendere da entrambi :)
*sotto win* (xp?) la dimensione di default massima per lo stack di una 
applicazione è di 1MB (il compilatore MS decide così... non so quale sia 
il max di mingw).
questa dimensione massima può essere alterata tramite opzioni di 
compilazione:
http://msdn2.microsoft.com/en-us/library/tdkhxaks(VS.80).aspx
http://msdn2.microsoft.com/en-us/library/8cxs58a6(VS.80).aspx
ed è una cosa che è propria dell'applicazione.
con gcc sotto win dovresti usare una sintassi del genere:
gcc -Wl,--stack=<STACK_SIZE>
*sotto linux* la cosa dovrebbe essere diversa poiché la dimensione max 
dello stack non è stabilita dall'applicaizone, ma è modificabile 
liberamente come risorsa messa a dipsosizione dell'app. dalla shell che 
la lancia tramite il comando: ulimit [-s]
prendi con le molle quest'ultima digressione su linux perché non sono 
affatto certo che sia corretta :)
ciao.

Mi avete dato un bel podi roba da guardare:). Grazie mille.
Ho due soluzioni:
la prima è cercare di aumentare lo stack di memoria in maniera da evitare
questo tipo di errore, la seconda è riscrivire il codice in modo da
abbassare la dimensionalità (credo che con array a 3 o 2 dimensioni non
dovrei avere questo tipo di problemi)
Speriamo bene:)
Grazie atutti



 inferiore al massimo supportato dal sistema operativo).
ciao.


Concordo.
Se il problema lo hai su entrambe i sistemi è anche possibile che ci sia 
un baco nel codice che per qualche motivo si manifesta solo con certe 
dimensioni.
Se poi hai deciso di rivedere il codice, tanto vale che allochi 
l'oggetto dinamicamente e ti togli dalle palle il problema dello stack.
Non avrai nessuna perdita di velocità o altro (a meno che di oggetti 
come quelli tu non ne stia usando centinaia o migliaia.

Certo se non fosse che non sono cosi pratico di C e quindi di allocare
dinamicamente la memoria.
Ma mi sembra una buona occasione per imparare:)



 Ma mi sembra una buona occasione per imparare:)
giusto per puntarti in una direzione più o meno corretta: apri il 
manuale della libreria standard alla voce malloc (ma pure calloc) :)
l'allocazione di un array multidimensionale però potrebbe essere non 
semplice se si è alle prime armi. per info: 
http://c-faq.com/aryptr/dynmuldimary.html
ciao.

Muchas gracias, credo partiro' proprio da questo link:)



Sono ancora io e le mie 4 dimensioni:)
Per allocare dimamicamente un array tipo double di 4 dimensioni ho scritto
questo:
(le dimensioni sono (tempi,siti,tempi, siti) )dove:
tempi =nr osservazioni temporali,
siti =nr osservazioni spaziali.
(Mi occupo di modelli statistici spazio temporali l'avrete capito:))
double ****a4d = (double ****)malloc((tempi +1)* sizeof(double ***));
	for(i = 0; i < tempi+1; i++) {
		a4d[i] = (double ***)malloc((siti+1)* sizeof(double **));
		for(j = 0; j < siti+1; j++)
			a4d[i][j] = (double **)malloc((tempi+1) * sizeof(double *));
			  	for(k = 0; k < tempi+1; j++)
			  	a4d[i][j][k] = (double *)malloc((*siti+1)* sizeof(double));
	}
 .......
lavoro con ilmio array a 4 dimensioni.
Posso accedere agli elementi dell'array tramite:
a3d[t,s,t1,s1]=0.3; /*ad esempio*/
.....
 
finito il lavoro, libero la memoria in questo modo:
for(i = 0; i < *tempi+1; i++){
      	free(a4d[i]);
             for(j = 0; i < *siti+1; i++)
        	free(a4d[i][j]);
              for(k = 0; i < *tempi+1; i++)
		      free(a4d[i][j][k]);
	          	}
free(a4d);
Qualcuno dei miei gentili interlocutori mi da qualche segnale se sono sulla
strada giusta?
Grazie mille
Dimenticavo ovviamente il programma da segmentation fault:)


 Dimenticavo ovviamente il programma da segmentation fault:)
così com'è anche a me :)
ti riporto il tuo codice riscritto in maniera più corretta e con qualche 
abbozzo di controllo sul risultato dell'allocazione (la gestione in caso 
di errore stabiliscila tu):
#include <stdlib.h>
#include <stdio.h>
void f(int tempi, int siti) {
    int i,j,k;
    double ****a4d;
    if ( (a4d=(double ****)malloc((tempi +1)* sizeof(double ***))) != NULL )
    	for(i = 0; i < tempi+1; i++)
          if ( (a4d[i] = (double ***)malloc((siti+1)* sizeof(double 
**))) != NULL )
             for(j = 0; j < siti+1; j++)
			      if ( (a4d[i][j] = (double **)malloc((tempi+1) * sizeof(double 
*))) != NULL )
			  	      for(k = 0; k < tempi+1; k++)
			  	         if ( (a4d[i][j][k] = (double *)malloc((siti+1)* 
sizeof(double))) == NULL )
                         printf("Allocazione fallita");
    printf("Allocati %d byte\n", 
(tempi+1)*(tempi+1)*(siti+1)*(siti+1)*sizeof(double));
    //getc(stdin);
    for(i = 0; i < tempi+1; i++){
       for(j = 0; j < siti+1; j++){
          for(k = 0; k < tempi+1; k++)
             free(a4d[i][j][k]);
          free(a4d[i][j]);
       }
       free (a4d[i]);
    }
    free(a4d);
}
int main() {
    f(30,60);
    return 0;
}
ciao.

 ti riporto il tuo codice riscritto in maniera piů corretta e con qualche

