Matrice seghettata contro un grande array?

Question

Non è così sicuro di come fare questa domanda, ma ho 2 modi (finora) per una matrice di ricerca

Opzione 1 è:

bool[][][] myJaggegArray; 

myJaggegArray = new bool[120][][]; 
for (int i = 0; i < 120; ++i) 
{ 
    if ((i & 0x88) == 0) 
    { 
    //only 64 will be set 
    myJaggegArray[i] = new bool[120][]; 
    for (int j = 0; j < 120; ++j) 
    { 
     if ((j & 0x88) == 0) 
     { 
     //only 64 will be set 
     myJaggegArray[i][j] = new bool[60]; 
     } 
    } 
    } 
} 

Opzione 2 è:

bool[] myArray; 
//    [998520] 
myArray = new bool[(120 | (120 << 7) | (60 << 14))]; 

Entrambe le modalità funzionano bene, ma c'è un altro (migliore) modo di fare una ricerca veloce e quale scegliereste se la velocità/prestazioni è ciò che importa?

Questo sarebbe utilizzato in un chessboard implementation (0x88) e soprattutto è

[from][to][dataX] per opzione 1

[(from | (to << 7) | (dataX << 14))] per opzione 2

Answer 1

suggerirei utilizza uno vasta gamma, a causa dei vantaggi di avere una grande blocco di memoria, ma vorrei anche incoraggiare la scrittura di un accessorio speciale per quella matrice.

class MyCustomDataStore 
{ 
    bool[] array; 
    int sizex, sizey, sizez; 

    MyCustomDataStore(int x, int y, int z) { 
    array=new bool[x*y*z]; 
    this.sizex = x; 
    this.sizey = y; 
    this.sizez = z; 
    } 

    bool get(int px, int py, int pz) { 
    // change the order in whatever way you iterate 
    return array [ px*sizex*sizey + py*sizey + pz ]; 
    } 

} 

Answer 2

Ho appena aggiorno soluzione dariusz con una serie di lunghi per z-dimensione < = 64

EDIT2: aggiornato per '< <' versione, dimensione fissa per 128x128x64

class MyCustomDataStore 
{ 
    long[] array; 

    MyCustomDataStore() 
    { 
      array = new long[128 | 128 << 7]; 
    } 

    bool get(int px, int py, int pz) 
    { 
      return (array[px | (py << 7)] & (1 << pz)) == 0; 
    } 

    void set(int px, int py, int pz, bool val) 
    { 
      long mask = (1 << pz); 
      int index = px | (py << 7); 
      if (val) 
      { 
       array[index] |= mask; 
      } 
      else 
      { 
       array[index] &= ~mask; 
      } 
    } 
} 

modifica : test delle prestazioni: utilizzato 100 volte 128x128x64 riempire e leggere

long: 9885ms, 132096B 
bool: 9740ms, 1065088B