R Programming Basics

access_time 2 months ago visibility11 comment 0

This article provides a basic introduction about programming with R incl. atomic vector, variable, operations, branching, loops and functions. 

infoAll examples can run RStudio or R Tools for Visual Studio on Windows.  About these two IDEs, refer to R Introduction.

Hello, World!

We always start with a 'Hello World!' example when learning a new programming language.

The following is the content of an example R script file named R01.HelloWorld.R.

# Set working directory
setwd("F:/Projects/RTutorialSamples")

# This is a quick demo of R
print ('Hello, World!')

myVar <- "Hello, World!"

print(myVar)

Output:

> # Set working directory
> setwd("F:/Projects/RTutorialSamples")
> 
> # This is a quick demo of R
> print ('Hello, World!')
[1] "Hello, World!"
> 
> myVar <- "Hello, World!"
> 
> print(myVar)
[1] "Hello, World!"
> 

Functions

There are two functions used in the above script, print and setwd.

Function setwd sets the current working directory to the path provided. Once the directory is setup, working space related files like .RData or .Rhistory can be saved in this directory. Relative paths will be resolved using working directory path. 

Function print simply prints out the input string or string variable to the output stream/console.

Variable

As other programming languages, you can define variables in R. The above script defines a variable named myVar and assigns a string literal 'Hello, World!" to it. 

Comments

To add comments into your R script, add character '#' to the comment line as the above script example shows. 

Run R scripts using command line

R scripts can be invoked using Rscript.exe executable:

Rscript.exe R01.HelloWorld.R

Atomic vector

R is created for statistical computing and graphics thus there is a core difference compared with other programming languages about vectors. A vector is a sequence of data elements of the same basic type. Members in a vector are called components.

In R, the following atomic vectors are available:

  • Logical
  • Numeric
  • Integer
  • Complex
  • Character
  • Raw

All other objects in R are created with these basic vectors. 

Examples

The following script R02.AtomicVectors.R shows some examples of vectors in R:

# Example R02 Basic Vectors

# logical
v <- TRUE
print(v)
print(class(v))

# numeric 
v <- 99.99
print(v)
print(class(v))

# integer
v <- 100L
print(v)
print(class(v))

# complex

v <- 10 -3i
print(v)
print(class(v))

# character

v <- 'i am a character'
print(v)
print(class(v))

Variables

As mentioned in the 'Hello World!' example, variables are used to store values. Variable value can be access through the identifier (variable name). Variable naming in R needs to following some standards:

  • Consists of letters, numbers, . , or _ characters
  • Starts with a letter or the dot not followed by a number

To assign values to variables, the following operators can be used:

  • <-
  • ->
  • <<-

To list all the variables in the current environment:

ls()
ls(all.names = TRUE)

To find variables with specific patterns:

ls(pattern="pat")
To delete variables, use rm function:
rm
rm(list=ls())

Examples

The following code script R03.Variables.R shows some examples of using variables:

atomicV<-"Jan"
print(v)
print(class(v))
print(length(v))

c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec") -> v
print(v)
print(class(v))
print(length(v))

v2 <- 2
.myv <- TRUE

ls()

ls(all.names = TRUE)

ls(pattern = "v")

ls(pattern = "v", all.names = TRUE)

ls(pattern = "^v", all.names = TRUE)

ls(pattern = "v$", all.names = TRUE)

rm(v)

rm(list=ls())
Sample output
> atomicV<-"Jan"
> print(v)
 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
> print(class(v))
[1] "character"
> print(length(v))
[1] 12
> 
> c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec") -> v
> print(v)
 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
> print(class(v))
[1] "character"
> print(length(v))
[1] 12
> 
> v2 <- 2
> .myv <- TRUE
> 
> ls()
 [1] "atomicV"          "cdt"              "colors"           "data"            
 [5] "floor"            "GCtorture"        "myVar"            "output.forest"   
 [9] "output.tree"      "result"           "result1"          "result2"         
[13] "sales"            "sales.timeseries" "sales1"           "sales2"          
[17] "sales3"           "sf"               "v"                "v2"              
[21] "X"               
> 
> ls(all.names = TRUE)
 [1] ".myv"             ".Random.seed"     "atomicV"          "cdt"             
 [5] "colors"           "data"             "floor"            "GCtorture"       
 [9] "myVar"            "output.forest"    "output.tree"      "result"          
[13] "result1"          "result2"          "sales"            "sales.timeseries"
[17] "sales1"           "sales2"           "sales3"           "sf"              
[21] "v"                "v2"               "X"               
> 
> ls(pattern = "v")
[1] "v"  "v2"
> 
> ls(pattern = "v", all.names = TRUE)
[1] ".myv" "v"    "v2"  
> 
> ls(pattern = "^v", all.names = TRUE)
[1] "v"  "v2"
> 
> ls(pattern = "v$", all.names = TRUE)
[1] ".myv" "v"   
> 
> rm(v)
> 
> rm(list=ls())

Operator 

A R operator is a symbol that instructs the compiler to perform specific mathematical or logical manipulations. The following types of operators are available in R:

  • Arithmetic
  • Relational
  • Logical
  • Assignment
  • Others

The following are some typical operators for each category. Refer to R official manual for the meaning of each of them. 

Operator categoryOperators
Arithmetic+, _, *,/, %%, %/%, ^
Relational >, <, ==, <=, >=, !=
Logical& (element wise), | (element wise), !, &&, ||
Assignment<-, ->, =, <<- (global variable), ->>
Others:, %in%, %*% (transpose)

Examples

The following code script R04.Operators.R provides some examples of using these operators:

### Arithmetic operators
a <- 15
b <- 2
a+b
a-b
a*b
a/b
#Mod
a%%b
#Divide (quotient)
a%/%b
a^b

# vector with more than one element
x<- c(1,2,3)
y<- c(4,5,6)
x+y

### Relational operators
x>=y
x>y
x<y
x!=y
x==y

### Logical operators
x&y
x|y
!x
!y
# Single output
x&&y
x||y

### Assignment operators
c('a',1,TRUE,5+5i) ->> v2

### Other operators
v <- 1:100
print(v)

1 %in% v
101 %in% v

# multiply a matrix with its transpose
mx = matrix(1:10,nrow=2, ncol=5)
View(mx)
tmx = t(mx)
View(tmx)

mx %*% tmx

Sample output
> ### Arithmetic operators
> a <- 15
> b <- 2
> a+b
[1] 17
> a-b
[1] 13
> a*b
[1] 30
> a/b
[1] 7.5
> #Mod
> a%%b
[1] 1
> #Divide (quotient)
> a%/%b
[1] 7
> a^b
[1] 225
> 
> # vector with more than one element
> x<- c(1,2,3)
> y<- c(4,5,6)
> x+y
[1] 5 7 9
> 
> ### Relational operators
> x>=y
[1] FALSE FALSE FALSE
> x>y
[1] FALSE FALSE FALSE
> x<y
[1] TRUE TRUE TRUE
> x!=y
[1] TRUE TRUE TRUE
> x==y
[1] FALSE FALSE FALSE
> 
> ### Logical operators
> x&y
[1] TRUE TRUE TRUE
> x|y
[1] TRUE TRUE TRUE
> !x
[1] FALSE FALSE FALSE
> !y
[1] FALSE FALSE FALSE
> # Single output
> x&&y
[1] TRUE
> x||y
[1] TRUE
> 
> ### Assignment operators
> c('a',1,TRUE,5+5i) ->> v2
> 
> ### Other operators
> v <- 1:100
> print(v)
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
 [21]  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39  40
 [41]  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58  59  60
 [61]  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80
 [81]  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98  99 100
> 
> 1 %in% v
[1] TRUE
> 101 %in% v
[1] FALSE
> 
> # multiply a matrix with its transpose
> mx = matrix(1:10,nrow=2, ncol=5)
> View(mx)
> tmx = t(mx)
> View(tmx)
> 
> mx %*% tmx
     [,1] [,2]
[1,]  165  190
[2,]  190  220

For the matrix and transposed matrix, the output looks like the following:

mx:

tmx:

Branching

Branching are commonly used in programming and in R the following are the commonly used ones:

  • if
  • if .. else
  • switch

The following flow chart shows in high-level how it works:

Examples

The following code script R05.Branching.R provides some examples of using these branching features:

rm(list=ls())

# Branching if else switch

a <- 2
b <- 3

if(a>b)
{
  print("a is greater than b")
}else
{
  print("a is not greater than b")
}


# switch


switch(
  5,
  "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
)
Sample output
[1] "a is not greater than b"
> 
> 
> # switch
> 
> 
> switch(
+   5,
+   "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
+ )
[1] "May"

Loops and loop control

R supported loops include: repeat, while, for.  The following flow chart shows how that works in high-level:

Loop control language features include break and next. Break will break the current entire loop while next will exit and go to next iteration only. 

Examples

The following code script R06.Loops.R provides some examples of using loops and breaks:

# Loops
i <- 1
repeat
{
  print('I am repeating')
  i = i+1
  if(i>10)
    break
}


j<-1
while(j<=10)
{
  print('I am repeating')
  j = j+1
}

v<-1:10
for(i in v)
{
  print('I am repeating')
}

# only print every two loops

v<-1:10
for(i in v)
{
  print(i)
  if(i%%2 != 0)
    next
  
  print('I am repeating')
}
Sample output
> # Loops
> i <- 1
> repeat
+ {
+   print('I am repeating')
+   i = i+1
+   if(i>10)
+     break
+ }
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
> 
> 
> j<-1
> while(j<=10)
+ {
+   print('I am repeating')
+   j = j+1
+ }
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
> 
> v<-1:10
> for(i in v)
+ {
+   print('I am repeating')
+ }
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
[1] "I am repeating"
> 
> # only print every two loops
> 
> v<-1:10
> for(i in v)
+ {
+   print(i)
+   if(i%%2 != 0)
+     next
+   
+   print('I am repeating')
+ }
[1] 1
[1] 2
[1] "I am repeating"
[1] 3
[1] 4
[1] "I am repeating"
[1] 5
[1] 6
[1] "I am repeating"
[1] 7
[1] 8
[1] "I am repeating"
[1] 9
[1] 10
[1] "I am repeating"

Functions

In the above examples, we used functions several times. A function in R is a set of statements to perform certain task. A function is also one object in R. 

Function are created using these components:

  • Name
  • Arguments
  • Body
  • Return Value (optional)
Function_Name <- function(arg1, arg2, ...) 
{ 
   Function body 
   Return value
}

Examples

The following code script R07.Functions.R provides some examples of using functions:

RTutorial.plus <- function(a,b)
{
  result <- a+b
  print(paste('result is ', result))
  return(result)
}

RTutorial.plus(10,11)

RTutorial.plus <- function(a,b)
{
  result <- a+b
  print(paste('result is ', result))
}

result<-RTutorial.plus(10,11)

print(result)

RTutorial.plus <- function(a,b=11)
{
  result <- a+b
  print(paste('result is ', result))
  return(result)
}

RTutorial.plus(10)
It shows example functions with/without return values. The last function also has an optional parameter named 'b' with default value '11'

Sample output
> RTutorial.plus <- function(a,b)
+ {
+   result <- a+b
+   print(paste('result is ', result))
+   return(result)
+ }
> 
> RTutorial.plus(10,11)
[1] "result is  21"
[1] 21
> 
> RTutorial.plus <- function(a,b)
+ {
+   result <- a+b
+   print(paste('result is ', result))
+ }
> 
> result<-RTutorial.plus(10,11)
[1] "result is  21"
> 
> print(result)
[1] "result is  21"
> 
> RTutorial.plus <- function(a,b=11)
+ {
+   result <- a+b
+   print(paste('result is ', result))
+   return(result)
+ }
> 
> RTutorial.plus(10)
[1] "result is  21"
[1] 21

Summary

Hopefully you now have a good understanding about the basics of R programming. In the other articles of this series, I will show more advanced topics about R programming. 

copyright The content on this page is licensed under CC-BY-SA-4.0.
Like this article?
Share on

Please log in or register to comment.

account_circle Log in person_add Register

Log in with external accounts

Want to publish your article on Kontext?

Learn more

Kontext Column

Created for everyone to publish data, programming and cloud related articles.
Follow three steps to create your columns.


Learn more arrow_forward

More from Kontext

Statistics with R (Part I)

local_offer r-lang

visibility 10
thumb_up 0
access_time 2 months ago

Till now, we've gone through R programming basics, data types, packages and IDEs, data APIs to work with data sources and various plotting functions. Let's now dive into the most important part about statistics and modelling with R. After all, R was created for statistics.  warning  Due ...

local_offer r-lang

visibility 9
thumb_up 0
access_time 2 months ago

In this series, we've walked-through R programming basics and advanced data types . This article will focus on R packages and IDEs so that you can program efficiently with R. Let's recap these commonly mentioned R terminologies: Package : An extension of the R base system with code, data and ...

Plotting with R (Part II)

local_offer plot local_offer r-lang

visibility 12
thumb_up 0
access_time 2 months ago

In Plotting with R (Part I) , I summarized the functions that can be used in R plotting. In this part, we continue the journey to plot more rich and complex charts like Pie Chart, Bar Chart, BoxPlot, Histogram, Line and Scatterplot using those functions.  Pie chart can be drawn using ...

About column

Programming with R language - tutorials about R. 

rss_feed Subscribe RSS