C++ to Java

[Macgiglio]

Mi aiutate a tradurre in java questo codice visto che non so come sostituire alcune funzioni?

float **dsload(char* fname, int *cols, int *rows) {

FILE* fp;

float **ds;

int i;

fp = fopen(fname, "rb");

fread(cols, sizeof(int), 1, fp);

fread(rows, sizeof(int), 1, fp);

ds = malloc(*rows * sizeof(float*));

for (i = 0; i < *rows; i++) {

ds[i] = malloc(*cols * sizeof(float));

fread(ds[i], sizeof(float), *cols, fp);

}

fclose(fp);

return(ds);

}

[andbin]

Originariamente inviato da Macgiglio
Mi aiutate a tradurre in java questo codice visto che non so come sostituire alcune funzioni?

Potrei anche tradurtelo ma dovrei sapere meglio una cosa sul formato dei dati. Va bene lo stesso se te lo spiego a parole??

Innanzitutto la funzione che hai postato è parecchio misera .... nel senso che non fa nemmeno alcun controllo degli errori. Ma a parte questo, si capisce che cosa fa.

Gestisce la lettura di un file binario che ha la seguente struttura: un int per il numero di colonne, poi un int per il numero di righe e quindi NxM valori float. La matrice bidimensionale la crea come "array di puntatori ad array". Concettualmente la stessa cosa che succede in Java. Alla fine restituisce il puntatore all'array principale. E inoltre, visto che in C/C++ è possibile, restituisce il numero di righe e colonne attraverso i puntatori passati come parametri.

Vediamo la traduzione in Java: innanzitutto devi istanziare un FileInputStream. Esso ti permette però solo di leggere byte "crudi" e quindi risulta molto utile, nel tuo caso, metterlo dentro un DataInputStream, che ha metodi es. readInt(), readFloat() ecc...

A quel punto leggi numeri di colonne e di righe ed istanzi un array. In Java è molto più facile, perché puoi fare new float[righe][colonne] e sei a posto!!!
Quindi fai un doppio ciclo for annidato per leggere NxM float. Nota una cosa: nel codice che hai postato fa 1 solo ciclo for e invece del for annidato fa una cosa resa possibile dalla fread, ovvero legge un blocco di N byte lungo dimensione_float*numero_colonne. In Java no, devi proprio fare il doppio ciclo annidato.

Alla fine fai ritornare il reference di tipo float[][] dell'array. Dato un reference di quel tipo, è possibile ottenere tranquillamente il numero di righe e pure il numero di colonne (prendendo per buono che la matrice sia rettangolare!). Quindi non sarebbe necessario restituire numero di righe/colonne. Se vuoi puoi farlo, ma non come in C/C++. O crei una classe apposita e restituisci questo oggetto oppure ti fai passare un oggetto e su quello invochi dei setQualcosa per assegnare i valori.

Nota finale, quello che dicevo all'inizio sul formato dei dati: l' "endian" dei dati quale è?? Perché in C/C++ dipende dalla piattaforma. Un valore 0x12345678 (int 32 bit) si può scrivere in memoria (ma anche su un file) come sequenza di byte 0x12 0x34 0x56 0x78 (Big Endian) oppure 0x78 0x56 0x34 0x12 (Little Endian).
La classe DataInputStream legge i dati in Big Endian, indipendentemente dalla piattaforma.

[Macgiglio]

Grazie, sei un grande.....

[Macgiglio]

Anche se non sono bravissimo nella programmazione ho scritto qualcosa del genere :

public static float[][] dsload( String fname, int cols, int rows){
float[][]output = new float[rows][cols];
{ try{
FileInputStream fis = new FileInputStream(fname);
DataInputStream dis = new DataInputStream(fis);

for (int i = 0; i < rows; i++){
for (int j = 0; j < cols; j++)
{
output[i][j]=dis.readFloat();
}}

dis.close();
}catch (IOException ioe)
{
ioe.printStackTrace();
}

return output;

}
}


Il problema è che non funziona come dovrebbe.Quando vado a leggere i file che dovrei visualizzare mi scrive una serie di 0.0
Altri suggerimenti?

[andbin]

Originariamente inviato da Macgiglio
Il problema è che non funziona come dovrebbe.Quando vado a leggere i file che dovrei visualizzare mi scrive una serie di 0.0

Innanzitutto una cosa: nel tuo codice non leggi numero di righe e colonne dal file!!! Cioè non hai fatto una cosa equivalente a quella che fa il codice postato all'inizio.

A parte questo, non hai risposto alla mia domanda sul "endian". Se i dati nel file sono in Little Endian, il tuo codice Java comunque non basta (e non funziona)!! Perché devi "rovesciare" gli int e i float!!!

[Macgiglio]

Non so l'"endian" del file ma ho fatto un passo in avanti riuscendo a stampare una serie di double.Mi spieghi meglio la storia sul non leggere il numero di righe e colonne? dove devo modificare il codice? grazie

[andbin]

Originariamente inviato da Macgiglio
Non so l'"endian" del file

Beh, può essere o BE o LE. DataInputStream si aspetta uno stream di byte esclusivamente in BE (e non dipende dalla piattaforma). Se il file è in LE e lo leggi con DataInputStream ottieni dati sballati.

Originariamente inviato da Macgiglio
Mi spieghi meglio la storia sul non leggere il numero di righe e colonne?

Il codice originale fa:

fread(cols, sizeof(int), 1, fp);
fread(rows, sizeof(int), 1, fp);

Tu con DataInputStream puoi usare 2 readInt() per leggere i due dati.

Il tuo metodo Java potrebbe essere, come signature:

public static float[][] dsload(String fname) throws IOException { ... }

Se c'è una eccezione, sarebbe più corretto farla "uscire" fuori, curandosi però di chiudere lo stream ... in ogni caso!

Comunque leggi i due dati (num righe/colonne) e stampali, se vedi che i valori sono parecchio "strampalati" (rispetto a quelli che presumi/ti aspetti), allora è in LE e devi "rovesciarli".

[Macgiglio]

con i due readint ottengo questi due numeri 536870912,-938934016 che non credo possano essere le dimensioni da me cercati...quindi? che faccio?

[Macgiglio]

se invece di

cols = dis.readInt();
rows = dis.readInt();

che mi dava i risultati postati prima
faccio

cols = dis.read();
rows = dis.readInt();

ottego 32,200

che è migliore come risultato anche se penso sia sbagliato....

[Macgiglio]

il 32 è giusto....le righe dovrebbero essere 68040