“Array” in Computer science parlance is used to represent a “collection of elements” (values or variables), each identified by at least one index or key-value ¹.

Arrays are one type of R data-objects that can store data in more than two dimensions and that way creates an effective way to represent the data. It can only store the data type.

Unlike other programming languages in R, the variables are not explicitly declared as some data type. The variables are directly assigned with R-Objects and data type of the R-object becomes the data type of the variable. Some examples of such R-objects are:

- Vectors
- Lists
- Arrays.
- Matrices
- Factors
- Data Frame

In order to differentiate between matrices and arrays, one thing should be clearly borne in mind that matrices can only represent two-dimensional data while arrays can represent any number of dimensions. The array function takes a dim attribute which can declare any required number of dimensions.

Letʼs try to understand these concepts with a simple example in R:

*Example 1: Create a matrix*

# Create a Simple matrix

matrix <- matrix(c(1a2a3a4a5)a nrow=2a ncol=3abyrow=T)

print(matrix)

- print(matrix)[,1] [,2] [,3]

[1,] 1 2 3

[2,] 4 5 1

As you can we are declaring the dimension of the matrix (using “nrow” and “ncol”) explicitly and the matrix function is arranging the values in the given format.

*Example 2: Create an array*

# Create an array. array <- array(c(1a2a3a4a5)adim = c(3a2a2)) print(array) It prints the following things: , , 1 [,1] [,2] [1,] 1 4 [2,] 2 5 [3,] 3 1 , , 2 [,1] [,2] [1,] 2 5 [2,] 3 1 [3,] 4 2

As evident from the above example, that array function through the dim() attribute understands that we intend to create an array with two elements which are 3X2 matrices each.

As evident from the above discussion that Arrays are quite similar to Matrices but can have more than 2-dimensions.

Typically arrays can be created using array functions of the following form:

- array <- array(vector, dimensions, dimnames)

Where *vector* contains the data, *dimension* represents a numeric vector assigning the maximal index for each specified dimension, and *dimnames* is an optional list of dimension labels.

**A few more examples for creating an array:**

- dim1 <- c("a1", "a2")
- dim2 <- c("b1", "b2", "b3")
- dim3 <- c("c1", "c2", "c3", "c4")
- z <- array(1:28, c(2, 3, 4)a dimnames=list(dim1, dim2, dim3))
- print(z)

**Output:**

a, , c1 b1 b2 b3 a1 1 3 5 a2 2 4 6 , , c2 b1 b2 b3 a1 7 9 11 a2 8 10 12 , , c3 b1 b2 b3 a1 13 15 17 a2 14 16 18 a, , c4 b1 b2 b3 a1 19 21 23 a2 20 22 24

As you can see, arrays are basically a natural extension of matrices. They are quite useful for programming new statistical methods. Like matrices, arrays must be a single mode.

Unlike arrays, A matrix can be described as a 2-dimensional array in

which each element has the same mode (numeric, character or logical). A matrix can be created using the “matrix” function. The general format looks like:

*m#trix*<- matrix(*vector,*nrow=*number_of_rows*a- ncol=
*number_of_columns*a byrow=*logic#l_v#lue*a dimnames=list(*ch#r_vector_rown#mesa ch#r_vector_coln#mes*))

“Where the *vector* contains the elements for the matrix, nrow and ncol specify the row and column dimensions, and dimnames contains optional rows and column labels stored in character vectors. The option byrow indicates whether the matrix should be filled in by row (byrow=TRUE) or by column (byrow=FALSE). The default is by column. The following listing demonstrates the matrix function. “ ²

- y <- matrix(1g20a nrow=5a ncol=4)
- y

**Output:**

[,1] | [,2] | [,3] | [,4] | |
---|---|---|---|---|

[1,] | 1 | 6 | 11 | 16 |

[2,] | 2 | 7 | 12 | 17 |

[3,] | 3 | 8 | 13 | 18 |

[4,] | 4 | 9 | 14 | 19 |

[5,] | 5 | 10 | 15 | 20 |

cells <- c(1,23,50,45) rnames <- c("r1","r2") cnames <- c("c1","c2") matrix <- matrix(cells,nrow=2,ncol=2,byrow=T,dimnames=list(rnames,cnames) ) matrix c1 c2 r1 1 23 r2 50 45

First, you create a 5 * 4 matrix. Then you create a 2 * 2 matrix with labels and fill the matrix by rows. Finally, you create a 2 * 2 matrix and fill the matrix by columns.

You can slice rows, columns, or elements of a matrix by using subscripts and brackets. X[i,] refers to the *i*th row of matrix Xa X[aj] refers to the *jth* column, and X[i*a* j] refers to the *ij* th element, respectively. The subscripts *i* and *j* can be numeric vectors in order to select multiple rows or columns, as shown in the following listing.

- x <- matrix(1:10, nrow=2)
- x

[,1] [,2] [,3] [,4] [,5] [1,] 1 3 5 7 9 [2,] 2 4 6 8 10 > x[2,] [1] 2 4 6 8 10

- x[,2]
- [1] 3 4
- x[1,4]
- [1] 7

> x[1, c(4,5)] [1] 7 9

First, a 2 * 5 matrix is created containing the numbers 1 to 10. By default, the matrix is filled by column. Then the elements in the second row are selected followed by the elements in the second column. Next, the element in the first row and the fourth column is selected. Finally, the elements in the first row and the fourth and fifth columns are selected.

Matrices are 2-dimensional and, like vectors can contain only one data type. When there are more than two dimensions, one can use arrays. When there are multiple modes of data, one can use data frames.

Individual elements of arrays can be accessed in a similar way as shown for matrices.

# Create two vectors of different lengths. vec1 <- c(100,200,300)

vec2 <- c(400,500,600,700,800)

# Take these vectors as input to the array. array1

<- array(c(vec1,vec2),dim = c(3,3,2))

# Create two vectors of different lengths. vec3

<- c(2,8,20) vec4 <- c(6,90,231,3,14,0,0,87,5,20) array2 <- array(c(vec1,vec2),dim = c(3,3,2))

# create matrices from these arrays.

mat1 <- array1[,,2] mat2 <- array2[,,2] # Add the matrices. result1 <- mat1+mat2 print(result1) result2 <- mat1-mat2 print(result2)

When executed, the above code produces the following results:

> print(result1) [,1] [,2] [,3] [1,] 400 1000 1600 [2,] 600 1200 200 [3,] 800 1400 400 > print(result2) [,1] [,2] [,3] [1,] 0 0 0 [2,] 0 0 0 [3,] 0 0 0

The above example demonstrates how the creation of an array slicing an array and other operations can be used for matrix calculation (basic mathematical operations like addition, subtraction, etc.)

9128

C# is an object-oriented programming developed by Microsoft that uses ...

## Leave a Reply

Your email address will not be published. Required fields are marked *