Essential R objects

In order to analyse data, store data or even program in R language knowledge of R objects is essential. R objects are basically the variables we define.

Atomic vectors

The most basic type of R objects are the atomic vectors, which can store data of a single class.

Atomic vectors are of several types:

• Double
• Integer
• Character
• Logical
• Complex
• Raw

From which double, integer, character, and logical are the most important.

These atomic vectors are defined by characteristics called “attributes”, which does not affect the value of the vector.

The most important attributes of an atomic vector include:

• Names

The names by which the elements of the vector are been identified with include in the ‘names’ attribute.

Names can be defined when defining the variable and the names can be viewed in a vector by using names() function in base R.

# Define a variable 'example', with  left hand side of the = sign containing the names, while those on the right hand side are the values
example <- c(a=1, b=3, c=5)

#to view the values and names of the variable 'example'
print(example)
## output
  a b c 
  1 3 5 

#to view only the names of the values of the variable 'example'
names(example)
## output
  [1] "a" "b" "c"

• Dimensions

Dimensions of the vector is in this attribute and can be viewed using dim() function.

The names associated with the dimensions, usually column and row names can be explored by dimnames() function

# Let's create an example data frame with two columns and three rows

  ##Variable 01
example <- c(a=1, b=3, c=5) 
  ##Variable 02
value_example <- c(6,8,10)
  ##Data frame
example_dimensions <- data.frame(example,value_example)

# Check dimensions
dim(example_dimensions)

[1] 3 2  ## this means the data frame has 3 rows and 2 columns

## check for dimension names

dimnames(example_dimensions)

[[1]]
[1] "a" "b" "c" ## row names

[[2]]
[1] "example"  "value_example" ## column names

• Type and Class

The ‘type’ of an object in R refers to the basic category or data structure to which the object belongs. Types are fundamental and provide information about the underlying representation of the data.

Common types in R include: numeric, character, logical, and complex.

The typeof() function can be used to determine the type of an object.

## Create a vector
type_example <- c(6,8,10)

## Check the type

typeof(type_example)

## output
[1] "double"

#### "double" indicates that 'type_example' is a numeric object stored as a double-precision floating-point number (this format uses more memory than single-pricision numbers).

The class of an object in R is a more high-level concept that defines how the object should be treated and what operations can be performed on it. For most basic R objects, the ‘class’ and the ‘type’ are more or less similar. However, for compound objects such as lists this is not the case. Unless you anticipate in digging deep into analysis and programming in R, having a basic idea of the class is sufficient.

The ‘class()’ function is used to view the class of an object.

## Create a vector
class_example <- c(6,8,10)

## Check the class

class(class_example)
[1] "numeric"

• Levels

For a ‘factor’ class objects, the ‘levels’ indicate the different factors that make up the vector.

By using levels() function the levels of a object of class factor can be viewed.

##Create an example variable

factors <- c(1,2,3,1,2,3,1,2,3)

## Convert it to a "factor" class with levels 1,2 and 3

factors <- factor(factors, levels = c(1,2,3))

## Check the type
typeof(factors)
[1] "integer"

## Check the class
class(factors)
[1] "factor"

## Check the levels
levels(factors)
[1] "1" "2" "3"

• Length

The length indicates how long is the R object and can be checked by using length() function.

## If we consider the previous example from factors

length(factors)
[1] 9 ## Length is 9 as there are 9 numbers in the vector named "factors"

• Comments

You can have a comment embedded into an R object. This will not be printed as an output, but can checked either using either comment() or attributes() functions. To allocate the comment, only comment() function can be used.

## allocate a comment to 'factors' variable created above

comment(factors) <- c("this is an example vector created to demonstrate the concept of 'factors'")

## check the comment
comment(factors)

[1] "this is an example vector created to demonstrate the concept of 'factors'"

Lists

‘Lists’ are heterogeneous class of R objects that can contain data of several types (e.g. character, logical, numeric) and provide a way to organize and structure diverse types of data in a single object.

Most of the attributes meant for atomic vectors also implies to ‘lists’.

A list can be created by using list() function.

## an example list is created by using previously defined vectors 'value_example' and 'example_factors'

example_list <- list(values = value_example,factors = example_factors) ## elements in a list can be named, and each element is separated by a comma

## structure of the list 

str(example_list)

List of 2
 $ values : num [1:3] 6 8 10
 $ factors:'data.frame': 9 obs. of  2 variables:
  ..$ factors: Factor w/ 3 levels "1","2","3": 1 2 3 1 2 3 1 2 3
  ..$ data   : num [1:9] 1 4 5 6 2 8 1 3 7

If you like to know more, I would recommend 20 Vectors of R for Data Science , which is clear and understandable.