NdArray

interfaccia pubblica NdArray
Sottoclassi indirette conosciute

Una struttura dati di N-dimensioni.

L'interfaccia `NdArray` crea un'astrazione tra l'archiviazione fisica di un record di dati, che può essere lineare o segmentato, e la sua rappresentazione logica. In generale, ottengono prestazioni migliori rispetto agli array multidimensionali standard in Java mappando direttamente segmenti di dati lineari in memoria.

Come DataBuffer , le istanze NdArray supportano l'indicizzazione a 64 bit in modo che possano essere utilizzate per mappare record di dati di grandi dimensioni. Supportano anche coordinate speciali che consentono di attraversare i loro valori in qualsiasi direzione o di selezionarne solo un sottoinsieme.

Esempio di utilizzo:

// Creates a 2x3x2 matrix (of rank 3)
    FloatNdArray matrix3d = NdArrays.ofFloats(shape(2, 3, 2));

    // Initialize sub-matrices data with vectors
    matrix.set(NdArrays.vectorOf(1.0f, 2.0f), 0, 0)
          .set(NdArrays.vectorOf(3.0f, 4.0f), 0, 1)
          .set(NdArrays.vectorOf(5.0f, 6.0f), 0, 2)
          .set(NdArrays.vectorOf(7.0f, 8.0f), 1, 0)
          .set(NdArrays.vectorOf(9.0f, 10.0f), 1, 1)
          .set(NdArrays.vectorOf(11.0f, 12.0f), 1, 2);

    // Access the second 3x2 matrix (of rank 2)
    FloatNdArray matrix = matrix3d.get(1);

    // Access directly the float value at (1, 0) from the second matrix
    assertEquals(9.0f, matrix.getFloat(1, 0));
 

Metodi pubblici

NdArray astratto <T>
copyTo ( NdArray <T> dst)
Copia il contenuto di questo array nell'array di destinazione.
astratto NdArraySequence <? estende NdArray <T>>
elementi (int dimensionIdx)
Restituisce una sequenza di tutti gli elementi in una determinata dimensione.
booleano astratto
è uguale a (Oggetto oggetto)
Verifica l'uguaglianza tra array n-dimensionali.
NdArray astratto <T>
get (coordinate lunghe...)
Restituisce l'elemento N-dimensionale di questo array alle coordinate specificate.
astratto T
getObject (coordinate lunghe...)
Restituisce il valore dello scalare trovato alle coordinate specificate.
NdArray astratto <T>
lettura ( Buffer dati <T> dst)
Leggere il contenuto di questo array N-dimensionale nel buffer di destinazione.
astratto NdArraySequence <? estende NdArray <T>>
scalari ()
Restituisce una sequenza di tutti gli scalari in questo array.
NdArray astratto <T>
set ( NdArray <T> src, long... coordinate)
Assegna il valore dell'elemento N-dimensionale trovato alle coordinate indicate.
NdArray astratto <T>
setObject (valore T, coordinate lunghe...)
Assegna il valore dello scalare trovato alle coordinate indicate.
NdArray astratto <T>
fetta ( Indice... indici)
Crea una vista (o sezione) multidimensionale di questo array mappando una o più dimensioni ai selettori di indice specificati.
NdArray astratto <T>
scrivere ( DataBuffer <T> origine)
Scrivi il contenuto di questo array N-dimensionale dal buffer di origine.

Metodi ereditati

Metodi pubblici

public abstract NdArray <T> copyTo ( NdArray <T> dst)

Copia il contenuto di questo array nell'array di destinazione.

La shape() dell'array di destinazione deve essere uguale alla forma di questo array, altrimenti verrà generata un'eccezione. Dopo la copia, il contenuto di entrambi gli array può essere modificato indipendentemente, senza influenzarsi a vicenda.

Parametri
dst array per ricevere una copia del contenuto di questo array
Ritorni
  • questa matrice
Lancia
IllegalArgumentException se la forma di dst non è uguale alla forma di questo array

estratto pubblico NdArraySequence <? estende NdArray <T>> elementi (int dimensionIdx)

Restituisce una sequenza di tutti gli elementi in una determinata dimensione.

Logicamente, l'array N-dimensionale può essere appiattito in un singolo vettore, dove gli scalari dell' (n - 1) esimo elemento precedono quelli dell' (n) esimo elemento, per un totale di valori size() .

Ad esempio, data una matrice nxm sugli assi [x, y] , gli elementi vengono iterati nel seguente ordine:

x 0 y 0 , x 0 y 1 , ..., x 0 y m-1 , x 1 y 0 , x 1 y 1 , ..., x n-1 y m-1

La sequenza restituita può quindi essere ripetuta per visitare ciascun elemento, chiamando forEach(Consumer) o forEachIndexed(BiConsumer) .

// Iterate matrix for initializing each of its vectors
    matrixOfFloats.elements(0).forEach(v -> {
      v.set(vector(1.0f, 2.0f, 3.0f));
    );

    // Iterate a vector for reading each of its scalar
    vectorOfFloats.scalars().forEachIdx((coords, s) -> {
      System.out.println("Value " + s.getFloat() + " found at " + coords);
    });
 }

Parametri
dimensioneIdx indice della dimensione
Ritorni
  • una sequenza NdArray
Lancia
IllegalArgumentException se dimensionIdx è maggiore o uguale al numero totale di dimensioni di questa matrice

Booleano astratto pubblico è uguale a (Oggetto obj)

Verifica l'uguaglianza tra array n-dimensionali.

Un array è uguale a un altro oggetto se questo oggetto è un altro NdArray della stessa forma, tipo e gli elementi sono uguali e nello stesso ordine. Per esempio:

IntNdArray array = NdArrays.ofInts(Shape.of(2, 2))
    .set(NdArrays.vectorOf(1, 2), 0)
    .set(NdArrays.vectorOf(3, 4), 1);

 assertEquals(array, StdArrays.ndCopyOf(new int[][] { {1, 2, {3, 4} }));  // true
 assertEquals(array, StdArrays.ndCopyOf(new Integer[][] { {1, 2}, {3, 4} }));  // true, as Integers are equal to ints
 assertNotEquals(array, NdArrays.vectorOf(1, 2, 3, 4));  // false, different shapes
 assertNotEquals(array, StdArrays.ndCopyOf(new int[][] { {3, 4}, {1, 2} }));  // false, different order
 assertNotEquals(array, StdArrays.ndCopyOf(new long[][] { {1L, 2L}, {3L, 4L} }));  // false, different types
 }

Si noti che il calcolo richiesto per verificare l'uguaglianza tra due array può essere costoso in alcuni casi e pertanto si consiglia di non utilizzare questo metodo in un percorso critico in cui le prestazioni contano.

Parametri
ogg oggetto con cui confrontare questo array
Ritorni
  • true se questa matrice è uguale all'oggetto fornito

public abstract NdArray <T> get (coordinate lunghe...)

Restituisce l'elemento N-dimensionale di questo array alle coordinate specificate.

È possibile recuperare elementi di qualsiasi dimensione di questo array. Ad esempio, se il numero di coordinate è uguale al numero di dimensioni di questo array, viene restituito un array di rango 0 (scalare), il cui valore può quindi essere ottenuto chiamando `array.getObject()`.

Qualsiasi modifica applicata agli elementi restituiti influisce anche sui dati di questo array, poiché non è coinvolta alcuna copia.

Tieni presente che invocare questo metodo è un modo equivalente e più efficiente per suddividere questo array su un singolo scalare, ovvero array.get(x, y, z) è uguale a array.slice(at(x), at(y), at(z))

Parametri
coordinate coordinate dell'elemento a cui accedere, nessuno restituirà questo array
Ritorni
  • l'elemento in questo indice
Lancia
IndexOutOfBoundsException se alcune coordinate sono fuori dai limiti della loro rispettiva dimensione

public abstract T getObject (coordinate lunghe...)

Restituisce il valore dello scalare trovato alle coordinate specificate.

Per accedere all'elemento scalare, il numero di coordinate fornite deve essere uguale al numero di dimensioni di questo array (cioè al suo rango). Per esempio:

FloatNdArray matrix = NdArrays.ofFloats(shape(2, 2));  // matrix rank = 2
  matrix.getObject(0, 1);  // succeeds, returns 0.0f
  matrix.getObject(0);  // throws IllegalRankException

  FloatNdArray scalar = matrix.get(0, 1);  // scalar rank = 0
  scalar.getObject();  // succeeds, returns 0.0f
 
Nota: se questo array memorizza valori di tipo primitivo, è preferibile l'utilizzo del metodo specializzato nella sottoclasse per quel tipo. Ad esempio, floatArray.getFloat(0); .

Parametri
coordinate coordinate dello scalare da risolvere
Ritorni
  • valore di quello scalare
Lancia
IndexOutOfBoundsException se alcune coordinate sono fuori dai limiti della loro rispettiva dimensione
IllegalRankException se il numero di coordinate non è sufficiente per accedere a un elemento scalare

public abstract NdArray <T> lettura ( DataBuffer <T> dst)

Leggere il contenuto di questo array N-dimensionale nel buffer di destinazione.

La dimensione del buffer deve essere uguale o maggiore alla size() di questo array, altrimenti verrà generata un'eccezione. Dopo la copia, il contenuto del buffer e dell'array può essere modificato indipendentemente, senza influenzarsi a vicenda.

Parametri
dst il buffer di destinazione
Ritorni
  • questa matrice
Lancia
BufferOverflowException se il buffer non può contenere il contenuto di questo array
Vedi anche

estratto pubblico NdArraySequence <? estende NdArray <T>> scalari ()

Restituisce una sequenza di tutti gli scalari in questo array.

Ciò equivale a chiamare elements(shape().numDimensions() - 1)

Ritorni
  • una sequenza NdArray

public abstract NdArray <T> set ( NdArray <T> src, long... coordinate)

Assegna il valore dell'elemento N-dimensionale trovato alle coordinate indicate.

Il numero di coordinate fornite può essere compreso tra 0 e rango - 1. Ad esempio:

FloatNdArray matrix = NdArrays.ofFloats(shape(2, 2));  // matrix rank = 2
  matrix.set(vector(10.0f, 20.0f), 0);  // success
  matrix.set(scalar(10.0f), 1, 0); // success
 

Parametri
src un array dei valori da assegnare
coordinate coordinate dell'elemento da assegnare
Ritorni
  • questa matrice
Lancia
IndexOutOfBoundsException se alcune coordinate sono fuori dai limiti della loro rispettiva dimensione

public abstract NdArray <T> setObject (valore T, long... coordinate)

Assegna il valore dello scalare trovato alle coordinate indicate.

Per accedere all'elemento scalare, il numero di coordinate fornite deve essere uguale al numero di dimensioni di questo array (cioè al suo rango). Per esempio:

FloatNdArray matrix = NdArrays.ofFloats(shape(2, 2));  // matrix rank = 2
  matrix.setObject(10.0f, 0, 1);  // succeeds
  matrix.setObject(10.0f, 0);  // throws IllegalRankException

  FloatNdArray scalar = matrix.get(0, 1);  // scalar rank = 0
  scalar.setObject(10.0f);  // succeeds
 
Nota: se questo array memorizza valori di tipo primitivo, è preferibile l'utilizzo del metodo specializzato nella sottoclasse per quel tipo. Ad esempio, floatArray.setFloat(10.0f, 0);

Parametri
valore il valore da assegnare
coordinate coordinate dello scalare da assegnare
Ritorni
  • questa matrice
Lancia
IndexOutOfBoundsException se alcune coordinate sono fuori dai limiti della loro rispettiva dimensione
IllegalRankException se il numero di coordinate non è sufficiente per accedere a un elemento scalare

public abstract NdArray <T> porzione ( Indice... indici)

Crea una vista (o sezione) multidimensionale di questo array mappando una o più dimensioni ai selettori di indice specificati.

Le fette consentono di attraversare un array N-dimensionale in uno qualsiasi dei suoi assi e/o di filtrare solo gli elementi di interesse. Ad esempio, per una determinata matrice sugli assi [x, y] , è possibile iterare gli elementi in y=0 per tutti x .

Qualsiasi modifica applicata alla sezione restituita influisce anche sui dati di questo array, poiché non è coinvolta alcuna copia.

Esempio di utilizzo:

FloatNdArray matrix3d = NdArrays.ofFloats(shape(3, 2, 4));  // with [x, y, z] axes

    // Iterates elements on the x axis by preserving only the 3rd value on the z axis,
    // (i.e. [x, y, 2])
    matrix3d.slice(all(), all(), at(2)).elements(0).forEach(m -> {
      assertEquals(shape(2), m); // y=2, z=0 (scalar)
    );

    // Creates a slice that contains only the last element of the y axis and elements with an
    // odd `z` coordinate.
    FloatNdArray slice = matrix3d.slice(all(), at(1), odd());
    assertEquals(shape(3, 2), slice.shape());  // x=3, y=0 (scalar), z=2 (odd coordinates)

    // Iterates backward the elements on the x axis
    matrix3d.slice(flip()).elements(0).forEach(m -> {
      assertEquals(shape(2, 4), m);  // y=2, z=4
    });
 }

Parametri
indici selettori di indice per dimensione, a partire dalla dimensione 0 di questo array.
Ritorni
  • l'elemento risultante dalla selezione dell'indice
Lancia
IndexOutOfBoundsException se alcune coordinate sono fuori dai limiti della loro rispettiva dimensione

public abstract NdArray <T> scrittura ( DataBuffer <T> src)

Scrivi il contenuto di questo array N-dimensionale dal buffer di origine.

La dimensione del buffer deve essere uguale o maggiore alla size() di questo array, altrimenti verrà generata un'eccezione. Dopo la copia, il contenuto del buffer e dell'array può essere modificato indipendentemente, senza influenzarsi a vicenda.

Parametri
src il buffer di origine
Ritorni
  • questa matrice
Lancia
BufferUnderflowException se il buffer non ha abbastanza dati rimanenti da scrivere in questo array
Vedi anche