| Sottoclassi indirette conosciute AbstractDenseNdArray <T, U estende NdArray <T>>, AbstractNdArray <T, U estende NdArray <T>>, BooleanDenseNdArray , BooleanNdArray , ByteDenseNdArray , ByteNdArray , DenseNdArray <T>, DoubleDenseNdArray , DoubleNdArray , FloatDenseNdArray , FloatNdArray , IntDenseNdArray , IntNdArray , LongDenseNdArray , LongNdArray e altri 11. |
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> | |
| 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> | |
| NdArray astratto <T> | setObject (valore T, coordinate lunghe...) Assegna il valore dello scalare trovato alle coordinate indicate. |
| NdArray astratto <T> | |
| 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
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
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 |
|---|