Las arrays son estructuras esenciales de almacenamiento de datos definidas por un número fijo de dimensiones. Las arrays se utilizan para la asignación de espacio en ubicaciones de memoria contiguas. Las arrays unidimensionales se denominan vectores y la longitud es su única dimensión. Los arreglos bidimensionales se llaman arrays y consisten en números fijos de filas y columnas. Los arreglos consisten en todos los elementos del mismo tipo de datos. Los vectores se proporcionan como entrada a la función y luego crean una array basada en el número de dimensiones.
Crear una array
Se puede crear una array en R con el uso de la array()función. La lista de elementos se pasa a las funciones array() junto con las dimensiones según sea necesario.
Sintaxis:
array(data, dim = (nrow, ncol, nmat), dimnames=names)
dónde,
nrow : Número de filas
ncol : Número de columnas
nmat : Número de arrays de dimensiones nrow * ncol
dimnames : Valor por defecto = NULL.
De lo contrario, se debe especificar una lista que tenga un nombre para cada componente de la dimensión. Cada componente es un nulo o un vector de longitud igual al valor dim de esa dimensión correspondiente.
Array unidimensional
Un vector es una array unidimensional, que se especifica mediante una sola dimensión, la longitud. Se puede crear un vector usando c()la función ‘ ‘. Se pasa una lista de valores a la función c() para crear un vector.
Ejemplo:
vec1 <- c(1, 2, 3, 4, 5, 6, 7, 8, 9)
print (vec1)
# cat is used to concatenate
# strings and print it.
cat ("Length of vector : ", length(vec1))
Producción:
[1] 1 2 3 4 5 6 7 8 9 Length of vector : 9
Array multidimensional
Una array bidimensional es una array especificada por un número fijo de filas y columnas, cada una de las cuales contiene el mismo tipo de datos. Se crea una array utilizando la función array() a la que se pasan los valores y las dimensiones.
Ejemplo:
# arranges data from 2 to 13 # in two matrices of dimensions 2x3 arr = array(2:13, dim = c(2, 3, 2)) print(arr)
Producción:
, , 1
[,1] [,2] [,3]
[1,] 2 4 6
[2,] 3 5 7
, , 2
[,1] [,2] [,3]
[1,] 8 10 12
[2,] 9 11 13
También se pueden introducir vectores de diferentes longitudes como entrada en la array()función. Sin embargo, el número total de elementos en todos los vectores combinados debe ser igual al número de elementos en las arrays. Los elementos se organizan en el orden en que se especifican en la función.
Ejemplo:
vec1 <- c(1, 2, 3, 4, 5, 6, 7, 8, 9) vec2 <- c(10, 11, 12) # elements are combined into a single vector, # vec1 elements followed by vec2 elements. arr = array(c(vec1, vec2), dim = c(2, 3, 2)) print (arr)
Producción:
,, 1
[, 1] [, 2] [, 3]
[1, ] 1 3 5
[2, ] 2 4 6
,, 2
[, 1] [, 2] [, 3]
[1, ] 7 9 11
[2, ] 8 10 12
Nomenclatura de arrays
Los nombres de filas, columnas y arrays se especifican como un vector del número de filas, el número de columnas y el número de arrays, respectivamente. De forma predeterminada, las filas, columnas y arrays se nombran por sus valores de índice.
row_names <- c("row1", "row2")
col_names <- c("col1", "col2", "col3")
mat_names <- c("Mat1", "Mat2")
# the naming of the various elements
# is specified in a list and
# fed to the function
arr = array(2:14, dim = c(2, 3, 2),
dimnames = list(row_names,
col_names, mat_names))
print (arr)
Producción:
,, Mat1
col1 col2 col3
row1 2 4 6
row2 3 5 7
,, Mat2
col1 col2 col3
row1 8 10 12
row2 9 11 13
Accediendo a arreglos
Se puede acceder a las arrays mediante el uso de índices para diferentes dimensiones separados por comas. Se pueden especificar diferentes componentes mediante cualquier combinación de nombres o posiciones de elementos.
Acceso a la array unidimensional
Se puede acceder a los elementos mediante el uso de índices de los elementos correspondientes.
vec <- c(1:10)
# accessing entire vector
cat ("Vector is : ", vec)
# accessing elements
cat ("Third element of vector is : ", vec[3])
<
Salida:
Vector is : 1 2 3 4 5 6 7 8 9 10 Third element of vector is : 3
Acceso a arrays enteras
vec1 <- c(1, 2, 3, 4, 5, 6, 7, 8, 9)
vec2 <- c(10, 11, 12)
row_names <- c("row1", "row2")
col_names <- c("col1", "col2", "col3")
mat_names <- c("Mat1", "Mat2")
arr = array(c(vec1, vec2), dim = c(2, 3, 2),
dimnames = list(row_names,
col_names, mat_names))
# accessing matrix 1 by index value
print ("Matrix 1")
print (arr[,,1])
# accessing matrix 2 by its name
print ("Matrix 2")
print(arr[,,"Mat2"])
Producción:
[1] "Matrix 1"
col1 col2 col3
row1 1 3 5
row2 2 4 6
[1] "Matrix 2"
col1 col2 col3
row1 7 9 11
row2 8 10 12
Acceso a filas y columnas específicas de arrays
También se puede acceder a filas y columnas tanto por nombres como por índices.
vec1 <- c(1, 2, 3, 4, 5, 6, 7, 8, 9)
vec2 <- c(10, 11, 12)
row_names <- c("row1", "row2")
col_names <- c("col1", "col2", "col3")
mat_names <- c("Mat1", "Mat2")
arr = array(c(vec1, vec2), dim = c(2, 3, 2),
dimnames = list(row_names,
col_names, mat_names))
# accessing matrix 1 by index value
print ("1st column of matrix 1")
print (arr[, 1, 1])
# accessing matrix 2 by its name
print ("2nd row of matrix 2")
print(arr["row2",,"Mat2"])
Producción:
[1] "1st column of matrix 1" row1 row2 1 2 [1] "2nd row of matrix 2" col1 col2 col3 8 10 12
Acceder a elementos individualmente
Se puede acceder a los elementos utilizando los números o nombres de fila y columna.
vec1 <- c(1, 2, 3, 4, 5, 6, 7, 8, 9)
vec2 <- c(10, 11, 12)
row_names <- c("row1", "row2")
col_names <- c("col1", "col2", "col3")
mat_names <- c("Mat1", "Mat2")
arr = array(c(vec1, vec2), dim = c(2, 3, 2),
dimnames = list(row_names, col_names, mat_names))
# accessing matrix 1 by index value
print ("2nd row 3rd column matrix 1 element")
print (arr[2, "col3", 1])
# accessing matrix 2 by its name
print ("2nd row 1st column element of matrix 2")
print(arr["row2", "col1", "Mat2"])
Producción:
[1] "2nd row 3rd column matrix 1 element" [1] 6 [1] "2nd row 1st column element of matrix 2" [1] 8
Acceso al subconjunto de elementos de array
Se puede acceder a un subconjunto más pequeño de los elementos de la array definiendo un rango de límites de fila o columna.
row_names <- c("row1", "row2")
col_names <- c("col1", "col2", "col3", "col4")
mat_names <- c("Mat1", "Mat2")
arr = array(1:15, dim = c(2, 4, 2),
dimnames = list(row_names, col_names, mat_names))
# print elements of both the rows and columns 2 and 3 of matrix 1
print (arr[, c(2, 3), 1])
Producción:
col2 col3
row1 3 5
row2 4 6
Agregar elementos a la array
Los elementos se pueden agregar en las diferentes posiciones de la array. La secuencia de elementos se conserva en el orden en que se agregaron a la array. La complejidad de tiempo requerida para agregar nuevos elementos es O(n) donde n es la longitud de la array. La longitud de la array aumenta según el número de adiciones de elementos. Hay varias funciones integradas disponibles en R para agregar nuevos valores:
- c(vector, valores): la función c() nos permite agregar valores al final de la array. También se pueden sumar varios valores.
- append(vector, valores): Este método permite agregar los valores en cualquier posición en el vector. De forma predeterminada, esta función agrega el elemento al final.
append(vector, valores, after=length(vector)) agrega nuevos valores después de la longitud especificada de la array especificada en el último argumento de la función.
- Usando la función de longitud de la array: los
elementos se pueden agregar en índices de longitud + x donde x> 0.# creating a uni-dimensional arrayx <-c(1,2,3,4,5)# addition of element using c() functionx <-c(x,6)print("Array after 1st modification ")print(x)# addition of element using append functionx <-append(x,7)print("Array after 2nd modification ")print(x)# adding elements after computing the lengthlen<-length(x)x[len+1] <-8print("Array after 3rd modification ")print(x)# adding on length + 3 indexx[len+3]<-9print("Array after 4th modification ")print(x)# append a vector of values to the array after length + 3 of arrayprint("Array after 5th modification")x <-append(x, c(10,11,12), after=length(x)+3)print(x)# adds new elements after 3rd indexprint("Array after 6th modification")x <-append(x, c(-1,-1), after=3)print(x)
Producción:[1] "Array after 1st modification " [1] 1 2 3 4 5 6 [1] "Array after 2nd modification " [1] 1 2 3 4 5 6 7 [1] "Array after 3rd modification " [1] 1 2 3 4 5 6 7 8 [1] "Array after 4th modification " [1] 1 2 3 4 5 6 7 8 NA 9 [1] "Array after 5th modification" [1] 1 2 3 4 5 6 7 8 NA 9 10 11 12 [1] "Array after 6th modification" [1] 1 2 3 -1 -1 4 5 6 7 8 NA 9 10 11 12
La longitud original de la array era 7, y después de la tercera modificación, los elementos están presentes hasta el octavo valor de índice. Ahora, en la cuarta modificación, cuando agregamos el elemento 9 en el décimo valor del índice, la función incorporada de R agrega automáticamente NA en las posiciones de los valores que faltan.
En la quinta modificación, la array de elementos [10, 11, 12] se agrega a partir del índice 11.
En la sexta modificación, la array [-1, -1] se agrega después de la tercera posición en la array.
Eliminación de elementos de la array
Los elementos se pueden eliminar de las arrays en R, ya sea uno a la vez o varios juntos. Estos elementos se especifican como índices de la array, donde los valores de la array que satisfacen las condiciones se conservan y el resto se elimina. La comparación para la eliminación se basa en valores de array. También se pueden combinar varias condiciones para eliminar una variedad de elementos. Otra forma de eliminar elementos es mediante el uso del operador %in% en el que el conjunto de valores de los elementos que pertenecen a los valores VERDADEROS del operador se muestran como resultado y el resto se elimina.
# creating an array of length 9
m <- c(1, 2, 3, 4, 5, 6, 7, 8, 9)
print ("Original Array")
print (m)
# remove a single value element:3 from array
m <- m[m != 3]
print ("After 1st modification")
print (m)
# removing elements based on condition
# where either element should be
# greater than 2 and less than equal to 8
m <- m[m>2 & m<= 8]
print ("After 2nd modification")
print (m)
# remove sequence of elements using another array
remove <- c(4, 6, 8)
# check which element satisfies the remove property
print (m % in % remove)
print ("After 3rd modification")
print (m [! m % in % remove])
Producción:
[1] "Original Array" [1] 1 2 3 4 5 6 7 8 9 [1] "After 1st modification" [1] 1 2 4 5 6 7 8 9 [1] "After 2nd modification" [1] 4 5 6 7 8 [1] TRUE FALSE TRUE FALSE TRUE [1] "After 3rd modification" [1] 5 7
En la 1ª modificación, se conservan todos los valores de los elementos que no sean iguales a 3. En la 2ª modificación se conserva la gama de elementos que están entre 2 y 8, se eliminan el resto. En la 3ª modificación, se imprimen los elementos que cumplen el valor FALSO, ya que la condición involucra al operador NOT.
Actualización de elementos existentes de array
Los elementos de la array se pueden actualizar con nuevos valores mediante la asignación del índice deseado de la array con el valor modificado. Los cambios se conservan en la array original. Si el valor del índice que se va a actualizar está dentro de la longitud de la array, entonces se cambia el valor; de lo contrario, el nuevo elemento se agrega en el índice especificado. También se pueden actualizar varios elementos a la vez, ya sea con el mismo valor de elemento o con varios valores en caso de que los nuevos valores se especifiquen como un vector.
# creating an array of length 9
m <- c(1, 2, 3, 4, 5, 6, 7, 8, 9)
print ("Original Array")
print (m)
# updating single element
m[1] <- 0
print ("After 1st modification")
print (m)
# updating sequence of elements
m[7:9] <- -1
print ("After 2nd modification")
print (m)
# updating two indices with two different values
m[c(2, 5)] <- c(-1, -2)
print ("After 3rd modification")
print (m)
# this add new element to the array
m[10] <- 10
print ("After 4th modification")
print (m)
Producción:
[1] "Original Array" [1] 1 2 3 4 5 6 7 8 9 [1] "After 1st modification" [1] 0 2 3 4 5 6 7 8 9 [1] "After 2nd modification" [1] 0 2 3 4 5 6 -1 -1 -1 [1] "After 3rd modification" [1] 0 -1 3 4 -2 6 -1 -1 -1 [1] "After 4th modification" [1] 0 -1 3 4 -2 6 -1 -1 -1 10
En la segunda modificación, los elementos de los índices 7 a 9 se actualizan con -1 cada uno. En la tercera modificación, el segundo elemento se reemplaza por -1 y el quinto elemento por -2 respectivamente. En la cuarta modificación, se agrega un nuevo elemento ya que el décimo índice es mayor que la longitud de la array.