Introduzione alle matrici in R
Come sappiamo, le matrici sono gli oggetti che possono memorizzare due o più dati bidimensionali. In R, Array ha lo stesso concetto, che viene creato utilizzando la funzione array (). Qui i dati vengono archiviati in matrici, righe e colonne. Per accedere a un elemento specifico dall'array, è necessario specificare l'indice di riga, l'indice di colonna e il livello della matrice.
Le matrici usate frequentemente in R, è un tipo speciale di array 2-D.
Rappresentazione pittorica: Vector, Matrix, Array
- Matrice unidimensionale definita vettore.
- Matrice bidimensionale definita matrice.
Sintassi:
Ecco la sintassi dell'array:
Array_NAME <- array (data, dim = (row_Size, column_Size, matrices, dimnames)
- dati: i dati sono un vettore di input che viene inviato all'array.
- matrici: si riferisce alla dimensionalità delle matrici. La matrice in R può essere matrici multidimensionali.
- row_Size - row_Size descrive il numero di righe che sarà composto da un array.
- column_Size - column_Size descrive il numero di colonne che comprende un array.
- dimnames: questo campo se si desidera modificare i nomi predefiniti di righe e colonne in base alle preferenze / ai desideri dell'utente.
Proprietà:
- È omogeneo. Ciò significa che può memorizzare lo stesso tipo di dati.
- Memorizza i dati in memoria contigua
- È possibile accedere agli elementi dell'array conoscendo il numero indice.
Come creare un array in R?
Di seguito sono riportati diversi scenari su come creare un array in r come segue:
Scenario 1:
Creiamo un array che sarebbe matrici 3 × 4. Qui 3 remeranno e 4 saranno colonne, le matrici saranno una. Come passi iniziali, manteniamo dimnames = NULL (che è un valore predefinito, se non specificato nulla).
Questa è una matrice unidimensionale
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 1)))
Produzione:
Per verificare se l'array creato alla fine è stato creato o meno.
Una volta creata la matrice:
Risultato
La funzione "class" può aiutarti in questo.
Classe (Risultato)
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 1)))
Result <- array(c(vector1, vector2), dim = c(3, 4, 1))
class(Result)
Produzione:
Per verificare il prodotto della dimensione dell'array, è possibile utilizzare la funzione: lunghezza.
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 1)))
Result <- array(c(vector1, vector2), dim = c(3, 4, 1))
length(Result)
Produzione:
Scenario 2:
Creiamo lo stesso array che sarebbe matrici 3 × 4. Anche in questo caso, 3 sarà una riga e 4 saranno colonne, ma le matrici saranno due. Manteniamo dimnames = NULL (che è un valore predefinito, se non specificato nulla).
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 2)))
Produzione:
Scenario 3:
Creiamo lo stesso array che sarebbe matrici 3 × 4. Anche in questo caso, 3 saranno righe e 4 saranno colonne, ma le matrici saranno due. Vediamo per i valori assegnati ai dimnames.
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names ))
Produzione:
Ora siamo bravi a creare una matrice di qualsiasi dimensionalità. Ora concentriamoci sul modo di accedere a qualsiasi elemento in un array.
Come creare un array di Access Elements in R?
Di seguito sono riportati diversi elementi di accesso su come creare un array in r come segue:
Scenario 1:
Diciamo che abbiamo lo stesso array in R:
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
Produzione:
Ora, dobbiamo accedere alla 3a riga, 3a colonna della seconda matric nell'array.
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(3, 3, 2)
Produzione:
Per riassumere, vengono utilizzate parentesi quadre per indicare un indice. Per specificare l'indice negli array, sono disponibili quattro opzioni: numeri interi positivi, numeri interi negativi, valori logici, nomi di elementi
Scenario 2:
È necessario accedere a un'intera matrice 1a matrice:
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1)
Produzione:
Diverse operazioni di array con esempi
Questa sezione ti fornirà controllo su varie operazioni eseguite su array per ottenere vari risultati.
1. Aggiunta e sottrazione:
La matrice multidimensionale deve essere convertita nella matrice unidimensionale, per essere aggiunta o sottratta.
- aggiunta:
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) print(result(,, 1) + result(,, 2))
Produzione:
- Sottrazione:
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) print(result(,, 1) - result(,, 2))
Produzione:
2. Calcoli sull'elemento array
Un nome di funzione apply (), aiuta ad applicare qualsiasi operazione tra gli elementi dell'array.
Sintassi:
apply(x, margin, fun)
Qui x è un array, il margine qui si riferisce a righe o colonne.
- MARGINE = 1 per operazioni a livello di riga
- MARGINE = 2 per operazioni a colonna
- MARGINE = c (1, 2) per entrambi.
Fun è la funzione applicata agli elementi dell'array del frame di dati. Queste potrebbero essere le funzioni standard che fanno parte di R o funzioni personalizzate (definite dall'utente)
Esempio 1:
Codice Row Wise R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) apply(result(,, 1), 1, sum)
Produzione:
Colonna Wise - Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) apply(result(,, 1), 2, sum)
Produzione:
Ciò fornisce un output in forma vettoriale che contiene la somma delle singole colonne. Qui "somma" è la funzione R standard.
Esempio 2:
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) apply(result(,, 1), 1, function(x) x+10)
Produzione:
Questo dà l'output della stessa dimensione. La cosa da notare qui è che abbiamo applicato la funzione definita dall'utente. Questa funzione è molto utile e potente mentre risolve i problemi del mondo reale. La funzione applicata è anche base per altre funzioni complesse come lapply (), rapply (), ecc.
3. Verificare la presenza di array
Verificare la presenza di array se l'oggetto è un array o no. Il nome della funzione is.array () è una funzione primitiva che ti consente di farlo. Fornisce un output in termini Vero o Falso
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) is.array(result)
Produzione:
4. Verificare le dimensioni dell'array
Conoscere la dimensionalità, un numero di righe, colonne di array aiuta a tagliare e tagliare i dati. Ecco alcune funzioni per farlo: dim, nrow, ncol
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
result <- array(c(vector1, vector2), dim = c(3, 4, 2))
print(result)
dim(result)
nrow(result)
ncol(result)
Produzione:
5. Controlla i nomi di righe e colonne
Per conoscere i nomi di righe, colonne e nomi di dimensioni di un array. Di seguito sono illustrate le relative implementazioni.
Codice R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
rownames(result)
colnames(result)
dimnames(result)
Produzione:
Conclusione:
Passare attraverso il contenuto sopra ti avrebbe dato una chiara comprensione delle matrici in R. R è un linguaggio statistico e le matrici sono oggetti dati usati frequentemente. Ciò significa che lavorare con una varietà di operazioni come aggiungere, sottrarre, applicare, ecc. Con un array in qualsiasi applicazione sarà ora una passeggiata per te.
Articoli consigliati
Questa è stata una guida all'array in R. Qui discutiamo un'introduzione agli array in R, le proprietà di R, come creare un array in R e alcuni esempi di esempio. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più -
- Installa R
- Array VBA
- Tipi di dati in MATLAB
- Elenco array VBA
- Matrici in PHP