Catatan Kuliah - Introduction to R

Introduction to R

• Merupakan suatu bahasa pemrograman yang mengimplementasikan bahasa S (1960-1n), berorientasi objek untuk pengolahan statistik dan grafik.
• R dikembangkan pada tahun 1976.
• R merupakan versi open sourcenya, dan S merupakan versi berbayarnya.
• R berorientasi objek, yang artinya variabel, data, fungsi, hasil, disimpan dalam memori komputer dalam bentuk objek bernama.
• Baik data, fungsi, operator, dll dalam R dipandang sebagai objek.
• Terdapat 2 jenis objek dan karakteristik dalam objek dilihat dari 2 aspek: mode dan length.
  1. Objek data: mode numeric, complec, character, logical, raw.
  2. Objek bahasa: mode function, expression, list, dll.

Basic Rule in R:

1. Assignment A <- 5 === A = 5 === 5 -> A
2. Case sensitive
3. Object name

• Diawali huruf A-Z atau a-z
• Tidak dimulai dengan angka -> error
• Hindari penggunaan underscore (_), sebaiknya dengan titik atau pemisah huruf besar kecil

4. Tidak menggunakan spasi atau karakter spesial (@, #, $, %)
5. Tidak menggunakan reserved words di R seperti: FALSE, TRUE, Inf, NA, NaN, NULL, break, else, for, if, dll. atau penamaan yang sama dengan fungsi built in seperti: c, q, s, t, diff, length, mean, dll.
6. Ada batas karakter penamaan variabel/object (256 byte)
7. Eksekusi dalam R berdasarkan line per line
8. Penamaan objek diawali titik, menjadi file hidden di memory.
9. Operator assignment bisa dituliskan dengan ALT + “=”

Advantages of R

1. Gratis
2. Kemampuan grafis baik
3. Unggul dalam simulasi dan analisis yang membutuhkan pemrgraman intensif
4. Dapat mengembangkan package

Disadvantages of R

1. Tidak user friendly Yang user friendly adalah package R yang lain: Shiny, TCl/TK, dan RCmdr
2. Mudah membuat kesalahan
3. Penyiapan data menjadi sulit karena memerlukan syntax tertentu

Data object modes in R

Dalam R ada 4 tipe/mode data: 1. numeric atau bilangan real, baik desimal/bulat, negatif/positif.

class(23.7)

## [1] "numeric"

class(23)

## [1] "numeric"

class(-2)

## [1] "numeric"

class(-10.37)

## [1] "numeric"

Note: most numbers in R are represented in double precision, called double in R.

typeof(23.7)

## [1] "double"

typeof(23)

## [1] "double"

typeof(-2)

## [1] "double"

typeof(-10.37)

## [1] "double"

Note: typeof lebih detail daripada class, typeof menampilkan storage mode dari x. typeof -> type data di storage, class -> data itu masuk kelas apa.

1. integer, spesifik untuk bilangan yang tidak memiliki angka desimal di belakangnya. memiliki suffix L untuk mengkhususkan bahwa bilangan tsb khusus untuk integer.

class(176L) #harus bilangan bulat bukan desimal

## [1] "integer"

class(176)

## [1] "numeric"

typeof(167L)

## [1] "integer"

typeof(167)

## [1] "double"

Note: WHY L, karena ada bilangan kompleks dalam R yang diikuti i, jika menggunakan l maka akan mirip dengan I. note: why must be suffix, karena di R, default mode dr numeric adalah double.

2. real/single, representasi bilangan real ke dalam bilangan biner/byte komputer.
3. double, default numeric di R. byte yang dipakai adalah 2x nya real.

2. logical atau boolean, memiliki 2 value: benar atau salah. bisa dituliskan dengan T atau F, TRUE atau FALSE.

typeof(TRUE)

## [1] "logical"

typeof(FALSE)

## [1] "logical"

class(T)

## [1] "logical"

class(F)

## [1] "logical"

Note: TRUE bernilai 1, FALSE bernilai 0 dan dapat dioperasikan dengan sesamanya atau dengan tipe data numerik

TRUE + 23

## [1] 24

FALSE * 32

## [1] 0

TRUE * FALSE 

## [1] 0

TRUE + FALSE 

## [1] 1

TRUE + 134L

## [1] 135

3. complex, merpakan bilangan kompleks dan diakhiri dengan i untuk menandai bahwa bilangan tersebut imajiner. Bisa dilakukan pengoperasian dengan tipe numeric lain atau logical, tapi tetap menghasilkan bilangan kompleks.

class(2i)

## [1] "complex"

class(2i+120L)

## [1] "complex"

class(2i+TRUE)

## [1] "complex"

typeof(2i)

## [1] "complex"

4. character, merupakan tipe data karakter baik 1 huruf atau lebih. Dalam programming, string adalah serangkaian karakter. Character atau string dapat direpresentasikan dengan single quotes (’’) atau double quotes (““).

typeof('a@h')

## [1] "character"

class("*jj")

## [1] "character"

Note: apapun karakter yang diawali dan diakhiri tanda petik dianggap sebagai character, walaupun itu sebuah bilangan/numeric.

typeof("23")

## [1] "character"

class("90L")

## [1] "character"

class("TRUE")

## [1] "character"

Note: panjang karakter dr suatu value tipe tertentu dalam bracket dapat diketahui dengan nchar()

nchar("midaa")

## [1] 5

nchar(20)

## [1] 2

nchar(23i+90)

## [1] 6

nchar(TRUE)

## [1] 4

nchar("TRUE")

## [1] 4

5. raw, menyimpan data dalam bentuk raw bytes.

a <- charToRaw("hello!")
a

## [1] 68 65 6c 6c 6f 21

class(a)

## [1] "raw"

typeof(a)

## [1] "raw"

Note: hierarki data type di R: character > complex > numeric > logical

typeof(c(1, "1"))

## [1] "character"

typeof(c(1, TRUE))

## [1] "double"

typeof(c(1, 2i))

## [1] "complex"

typeof(c("T", T))

## [1] "character"

# jika ada 2 tipe data dicampur, maka vektor mengikuti pada data yang tipenya lebih tinggi.

Standard Data Object Type in R

Terdapat 6 tipe dasar objek di R: ### Vector * dibentuk dengan c() * tipe data paling sederhana dari objek data dalam R * berisi data homogen (sama tipe) dan berdimensi 1

vec1 <- c(1L, 2, 3, "a")
vec2 <- c(c(1,2,3), "a", TRUE)
vec3 <- c(T, F)
vec1

## [1] "1" "2" "3" "a"

vec2

## [1] "1"    "2"    "3"    "a"    "TRUE"

vec3

## [1]  TRUE FALSE

class(vec1)

## [1] "character"

class(vec2)

## [1] "character"

class(vec3)

## [1] "logical"

List

• dapat memuat data tipe heterogen seperti vector dan list lain, berdimensi 1
• dapat berisi data yang heterogen
• dibentuk dengan list()

lis1 <- list("A", "B", "Bandung", c(1, 2, 3, T))
lis1

## [[1]]
## [1] "A"
## 
## [[2]]
## [1] "B"
## 
## [[3]]
## [1] "Bandung"
## 
## [[4]]
## [1] 1 2 3 1

class(lis1)

## [1] "list"

Matriks

• berbentuk array 2 dimensi dan elemennya homogen
• dibentuk dengan matrix() dan menyimpan parameter nrow() yg menerima banyak baris matriks
• dapat dibentuk dari sebuah vector

mat1 <- matrix(vec1, nrow=2)
mat1

##      [,1] [,2]
## [1,] "1"  "3" 
## [2,] "2"  "a"

class(mat1)

## [1] "matrix" "array"

Factors

• berupa elemen-elemen unik dalam vektor yang digunakan untuk mengategorikan data (integer/char) sebagai levels/kategori
• walaupun ditampilkan dlm bentuk character tapi dianggap sebagai numerik
• dibentuk dengan factor() dan menerima data tipe vector.

fac1 <- factor(vec1)
fac1

## [1] 1 2 3 a
## Levels: 1 2 3 a

class(fac1)

## [1] "factor"

Arrays

• digunakan untuk membuat array n-dimensi
• menerima argumen dimension atau dim
• dibentuk dengan array() dan menerima argumen dim= untuk menentukan dimensinya

arr1 <- array(c(1:27), dim = c(3,3,3))
arr1

## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
## 
## , , 2
## 
##      [,1] [,2] [,3]
## [1,]   10   13   16
## [2,]   11   14   17
## [3,]   12   15   18
## 
## , , 3
## 
##      [,1] [,2] [,3]
## [1,]   19   22   25
## [2,]   20   23   26
## [3,]   21   24   27

class(arr1)

## [1] "array"

Data Frame

• merupakan list dalam bentuk matriks
• data tabular 2 dimensi
• menyimpan kolom-kolom dan baris-baris, di mana setiap kolom merepresentasikan vektor dan setiap indeksnya merepresentasikan baris
• dibentuk dengan data.frame().

col1 <- 1:12
col2 <- LETTERS[1:12]
col3 <- letters[1:12]
col4 <- month.name[1:12]
myDataFrame <- data.frame(col1, col2, col3, col4)
myDataFrame

class(myDataFrame)

## [1] "data.frame"

Accessing Elements in Data Objects

Mengakses elemen dalam data objects bisa dengan 4 cara: 1. Dengan 1 kurung siku -> x[i] * Digunakan dalam semua objek data * Mengembalikan objek dalam x, yang dijelaskan oleh i * Ketika digunakan di vector maka kembaliannya adalah vector, begitupula list

vect1 <- c(1:12)
list1 <- list(c(1:3), c(letters[1:5]), c(LETTERS[6:12]), c(month.name[2:7]))
vect1

##  [1]  1  2  3  4  5  6  7  8  9 10 11 12

list1

## [[1]]
## [1] 1 2 3
## 
## [[2]]
## [1] "a" "b" "c" "d" "e"
## 
## [[3]]
## [1] "F" "G" "H" "I" "J" "K" "L"
## 
## [[4]]
## [1] "February" "March"    "April"    "May"      "June"     "July"

vect1[9] #akses elemen ke-9

## [1] 9

class(vect1[9])

## [1] "integer"

vect1[3:7] #akses elemen ke-3 sampai ke-7

## [1] 3 4 5 6 7

class(vect1[3:7])

## [1] "integer"

list1[3]

## [[1]]
## [1] "F" "G" "H" "I" "J" "K" "L"

class(list1[3])

## [1] "list"

2. Dengan double kurung siku -> x[[i]]

• Dapat digunakan di semua objek data
• Mengembalikan elemen single dari x

list1[2] 

## [[1]]
## [1] "a" "b" "c" "d" "e"

list1[[2]]

## [1] "a" "b" "c" "d" "e"

vect1[3]

## [1] 3

vect1[[3]]

## [1] 3

Jelas bahwa dalam list, 1 kurung siku mengembalikan list sementara 2 kurung siku mengembalikan single value element-nya.

3. Dengan tanda dollar -> x$i

• Mengembalikan objek yang memiliki nama i dari objek x
• Digunakan dalam list atau dataframe (list atau data frame harus diberi nama dulu)

myDataFrame$col2

##  [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L"

#memberi nama dalam list1
names(list1) <- c("Pertama", "Kedua", "Ketiga", "Keempat")
list1

## $Pertama
## [1] 1 2 3
## 
## $Kedua
## [1] "a" "b" "c" "d" "e"
## 
## $Ketiga
## [1] "F" "G" "H" "I" "J" "K" "L"
## 
## $Keempat
## [1] "February" "March"    "April"    "May"      "June"     "July"

list1$Ketiga

## [1] "F" "G" "H" "I" "J" "K" "L"

4. Dengan @ -> x@i

• Digunakan pada data bertipe S4 (system in R yang digunakan dalam OOP)
• Mengembalikan elemen yang tersimpan di slot bernama i

Operations in R

Arithmetic Operators

23+5

## [1] 28

23-5

## [1] 18

23/5

## [1] 4.6

23*5

## [1] 115

23%%5 #modulus

## [1] 3

23^5 #exponent

## [1] 6436343

23%/%3 #integer division

## [1] 7

2 * (5-2^3)

## [1] -6

log10(300) #logaritmik

## [1] 2.477121

asin(0.5) #trigonometri

## [1] 0.5235988

# this is a comment and won't be executed

Relational Operators

Mengembalikan nilai TRUE atau FALSE dari perbandingan hubungan 2 nilai

20-3 < 6

## [1] FALSE

45 > 32.4

## [1] TRUE

"a" > 45 #a dikembalikan ke nilai raw-nya, 97

## [1] TRUE

"a" != 61L #sama saja dengan 61

## [1] TRUE

# berlaku pula untuk ==, >=, <=

Logical Operators

! -> NOT & -> element wise logical AND -> hanya memeriksa elemen pertama dan menghasilkan elemen berkuran 1 && -> AND | -> element wise logical OR -> hanya memeriksa elemen pertama dan menghasilkan elemen berkuran 1 || -> OR Hanya bisa untuk data tipe logical, numeric, dan complex

firstStatement <- c(T, TRUE, TRUE, 1)
secondStatement <- c(F, T, FALSE, TRUE)
!secondStatement 

## [1]  TRUE FALSE  TRUE FALSE

firstStatement&secondStatement

## [1] FALSE  TRUE FALSE  TRUE

firstStatement&&secondStatement #irisan dalam diiris dg object lain

## Warning in firstStatement && secondStatement: 'length(x) = 4 > 1' in coercion to
## 'logical(1)'

## Warning in firstStatement && secondStatement: 'length(x) = 4 > 1' in coercion to
## 'logical(1)'

## [1] FALSE

firstStatement|secondStatement

## [1] TRUE TRUE TRUE TRUE

firstStatement||secondStatement #irisan dalam digabung dg object lain

## Warning in firstStatement || secondStatement: 'length(x) = 4 > 1' in coercion to
## 'logical(1)'

## [1] TRUE

Assignment Operators

<-, <<-, = Leftwards assignment ->, ->> Rightwards assignment (nama objectnya yg kanan)

x <- 90L
x

## [1] 90

10^8 -> y
y

## [1] 1e+08

y/x ->> z
z

## [1] 1111111

Special Values

Ada 4 nilai khusus di R: Missing Value (NA), Tak hingga (Inf), NULL, dan Not a Number (NaN) 1. NULL adalah sebuah objek yang dikembalikan ketika sebuah ekspresi atau fungsi menghasilkan nilai yang tidak terdefinisi. * operasi yang mengandung NA akan mengasilkan NA * terdapat argumen na.rm untuk remove NA * pengujian NULL dengan is.null().

typeof(NULL)

## [1] "NULL"

2. NA atau Not Available adalah konstanta logical yang berkuran 1 dan mengindikasikan adanya value/nilai yang hilang. Bisa ada ketika mengimpor data. NA dan “NA” adalah beda.

typeof(NA)

## [1] "logical"

typeof("NA")

## [1] "character"

k <- data.frame(a=c(2,3,5,8),b=c(3,8,NA,5),c=c(10,4,6,11))
is.na(k) #pengujian apakah ada NA

##          a     b     c
## [1,] FALSE FALSE FALSE
## [2,] FALSE FALSE FALSE
## [3,] FALSE  TRUE FALSE
## [4,] FALSE FALSE FALSE

mean(k)

## Warning in mean.default(k): argument is not numeric or logical: returning NA

## [1] NA

colMeans(k, na.rm = TRUE, dims = 1)

##        a        b        c 
## 4.500000 5.333333 7.750000

3. NaN atau Not a Number adalah vector logical dengan panjang 1, diaplikasikan pada nilai numeric. NaN dapat diuji dengan is.nan().

typeof(NaN)

## [1] "double"

4. Inf atau Infinite adalah hasil menyimpan produk yang berukuran sangat besar atau sebuah value yang merupakan hasil bagi sebuah angka dengan 0. Inf menunjukkan bahwa value itu sebuah angka dan bukan missing value, tapi tak hingga. pengujian Infinite dengan is.infinite().

typeof(Inf)

## [1] "double"

class(Inf)

## [1] "numeric"

Re-assigning

Misal a = 23, b = 32 dan ingin ditukar nilai a ke b dan b ke a:

a <- 23
b <- 32
temp <- a
a <- b
b <- temp
a

## [1] 32

b

## [1] 23

Operations in Vector

• Membuat vector dengan c()
• Bisa dipanggil dengan indeks kurung siku atau dengan gabungan indeks c() untuk memanggil beberapa indeks tertentu yang tidak berurut. Bisa juga dengan indeks negatif.

v1 <- c(12, 13, 14, 15, 16, 17)
v1

## [1] 12 13 14 15 16 17

v1[2:4] # URUTAN 2 sampai 4

## [1] 13 14 15

v1[c(6,4)] #URUTAN 6 dan 4

## [1] 17 15

v1[c(-2, -5)] #SELAIN urutan 2 dan 5

## [1] 12 14 15 17

• Beberapa fungsi penting dalam statistika

min(v1) #nilai minimum

## [1] 12

max(v1) #nilai maksimum

## [1] 17

range(v1) #rentang

## [1] 12 17

length(v1) #panjang vector

## [1] 6

sum(v1) #jumlahan

## [1] 87

prod(v1) #product elemen 

## [1] 8910720

mean(v1) #rata-rata

## [1] 14.5

sd(v1) #standard deviation

## [1] 1.870829

var(v1) #varians

## [1] 3.5

• Vector juga bisa dimodifikasi

v1

## [1] 12 13 14 15 16 17

v1[v1>16] <- 1 #mengganti yang nilainya > 16
v1

## [1] 12 13 14 15 16  1

#remove(v1) #menghapus vector
#v1

• Bisa diterapkan operasi aritmatik

sampleVec1 <- c(5, 2, 5, 1, 51, 2)
sampleVec2 <- c(7, 9, 1, 5, 2, 1)
sampleVec1+sampleVec2

## [1] 12 11  6  6 53  3

sampleVec1-sampleVec2

## [1] -2 -7  4 -4 49  1

sampleVec1*sampleVec2

## [1]  35  18   5   5 102   2

sampleVec1/sampleVec2

## [1]  0.7142857  0.2222222  5.0000000  0.2000000 25.5000000  2.0000000

• Vector bisa diurutkan dengan sort() dengan argument decreasing=TRUE/FALSE untuk menentukan urutan. secara default sortingnya ascending. Note: sort() mengembalikan value dan tidak memodifikasi object aslinya.

sort(sampleVec1, decreasing = TRUE)

## [1] 51  5  5  2  2  1

sort(sampleVec2)

## [1] 1 1 2 5 7 9

Operations in Matrix

• Dibentuk dengan matrix() dan menerima argumen ncol() dan byrow(). Secara default byrow adalah FALSE yang artinya data diisi urut berdasarkan kolom.

sampleMatrix1 <- matrix(c(10,2,3,4,22,45), ncol = 2, byrow = TRUE)
sampleMatrix2 <- matrix(c(21:26), ncol = 2)
sampleMatrix1

##      [,1] [,2]
## [1,]   10    2
## [2,]    3    4
## [3,]   22   45

sampleMatrix2

##      [,1] [,2]
## [1,]   21   24
## [2,]   22   25
## [3,]   23   26

• Operasi + - / dan * bisa untuk matriks yang sama
• Dilakukan perhitungan per-index i,j yang sama

sampleMatrix1-sampleMatrix2

##      [,1] [,2]
## [1,]  -11  -22
## [2,]  -19  -21
## [3,]   -1   19

sampleMatrix1+sampleMatrix2

##      [,1] [,2]
## [1,]   31   26
## [2,]   25   29
## [3,]   45   71

sampleMatrix1*sampleMatrix2

##      [,1] [,2]
## [1,]  210   48
## [2,]   66  100
## [3,]  506 1170

sampleMatrix1/sampleMatrix2

##           [,1]       [,2]
## [1,] 0.4761905 0.08333333
## [2,] 0.1363636 0.16000000
## [3,] 0.9565217 1.73076923

• Transpose Matriks dengan t()
• Untuk perhitungan perkalian matriks yang matematis dimensi axb dan bxc, maka digunakan **%*%**

transposeSampleMatrix2 = t(sampleMatrix2)
resultMatrix = sampleMatrix1%*%transposeSampleMatrix2
resultMatrix

##      [,1] [,2] [,3]
## [1,]  258  270  282
## [2,]  159  166  173
## [3,] 1542 1609 1676

• Mengambil vector diagonal dari matriks dengan diag()
• Beberapa func lain: solve() untuk menghasilkan solusi sistem persamaan linier atau inverse matriks eigen() untuk menghasilkan akar ciri dan vektor ciri

diag(resultMatrix)

## [1]  258  166 1676

eigen(resultMatrix)

## eigen() decomposition
## $values
## [1]  2.101275e+03 -1.274940e+00  5.703744e-14
## 
## $vectors
##            [,1]       [,2]       [,3]
## [1,] -0.1649277  0.7233890 -0.4082483
## [2,] -0.1012532  0.0259628  0.8164966
## [3,] -0.9810946 -0.6899524 -0.4082483

Note: * ketika elemen yang diinput < elemen yang bisa terisi pada matriks yang terbentuk, elemen yg ada diulang. * matriks juga bisa dikalikan dengan skalar.

mat1 <- matrix(1:12, 4,4)

## Warning in matrix(1:12, 4, 4): data length differs from size of matrix: [12 != 4
## x 4]

mat1

##      [,1] [,2] [,3] [,4]
## [1,]    1    5    9    1
## [2,]    2    6   10    2
## [3,]    3    7   11    3
## [4,]    4    8   12    4

mat1 * 4

##      [,1] [,2] [,3] [,4]
## [1,]    4   20   36    4
## [2,]    8   24   40    8
## [3,]   12   28   44   12
## [4,]   16   32   48   16

• Membuat matriks I atau O

matrix(1,4,4)

##      [,1] [,2] [,3] [,4]
## [1,]    1    1    1    1
## [2,]    1    1    1    1
## [3,]    1    1    1    1
## [4,]    1    1    1    1

matrix(0,3,3)

##      [,1] [,2] [,3]
## [1,]    0    0    0
## [2,]    0    0    0
## [3,]    0    0    0

• Matriks identitas

mat0 <- matrix(0,3,3)
diag(mat0) <- 1
mat0

##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    1    0
## [3,]    0    0    1

Note: bisa membuat matriks identitas secara langsung

m1 <- diag(1,5,5)
m1

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    0    0    0    0
## [2,]    0    1    0    0    0
## [3,]    0    0    1    0    0
## [4,]    0    0    0    1    0
## [5,]    0    0    0    0    1

• Menggabungkan matriks

m1 <- matrix(1:4, 2,2)
m2 <- matrix(6:9, 2,2)
cbind(m1,m2)

##      [,1] [,2] [,3] [,4]
## [1,]    1    3    6    8
## [2,]    2    4    7    9

rbind(m1,m2)

##      [,1] [,2]
## [1,]    1    3
## [2,]    2    4
## [3,]    6    8
## [4,]    7    9

Operations in Character

nchar() - menghitung banyak karakter dalam string

nchar("Nur Khamidah") #spasi diitung

## [1] 12

nchar(123L)

## [1] 3

nchar(T)

## [1] 4

nchar(FALSE)

## [1] 5

nchar(10e7) #kok bisa

## [1] 5

paste() - menggabungkan n string menjadi 1

paste("Institut", "Pertanian", "Bogor")

## [1] "Institut Pertanian Bogor"

sprintf() - membuat kombinasi string dengan format tertentu

sprintf("%s goes to school at %.0f AM", "Mida", 8)

## [1] "Mida goes to school at 8 AM"

# %s untuk string, %f untuk numeric tanpa pembulatan

substr() - mengambil beberapa karakter dari string pada indeks/urutan tertentu

country <- "INDONESIA"
substr(country, 3, 3)

## [1] "D"

substr(country, 2, 6)

## [1] "NDONE"

strsplit() - split kalimat/karakter menjadi vector berdasarkan separator tertentu

sentence <- "Aku,Kamu,Dia,Mereka,Kami,Kita"
strsplit(sentence, ",")

## [[1]]
## [1] "Aku"    "Kamu"   "Dia"    "Mereka" "Kami"   "Kita"

toupper() dan tolower()

toupper("Indonesia")

## [1] "INDONESIA"

tolower("jAkARTa")

## [1] "jakarta"

Decisions Making in R

Decision making atau pengambilan keputusan di R dapat dilakukan dengan beberapa cara: 1. if statement * Jika kondisi bernilai TRUE maka statement akan dieksekusi, jika kondisi bernilai FALSE tidak dieksekusi apapun. * Dibuat dengan: if(condition) {statement}

a <- 8 #TRUE
#a <- 20 #FALSE
a1 <- 2*a + 15
a2 <- 4*a - 23
if(a1 > a2){
  print("a1 lebih besar dari a2")
}

## [1] "a1 lebih besar dari a2"

2. if-else statement

• Jika kondisi bernilai TRUE maka statement pertama dieksekusi, jika FALSE maka statement kedua dieksekusi.
• Dibentuk dengan: if (condition) {statement1} else {statement2}

b <- 23
b1 <- sqrt(b) * 2
b2 <- b^2 / 40
if(b1 > b2){
  print("b1 lebih besar dari b2")
} else {
  print("b1 lebih kecil dari b2")
}

## [1] "b1 lebih kecil dari b2"

3. if-else if ladder statement

• jika kondisi ke-i pertama bernilai TRUE maka statement ke-i dieksekusi, statement else (terakhir) dieksekusi ketika tidak ada kondisi bernilai TRUE
• dibentuk dengan: if (condition1) { statement 1 } else if(condition2){ statement 2 } .. else if(condition n){ statement n } else { last statement }

nilai <- 90
if(nilai > 90 & nilai <= 100){
  score <- "A"
} else if(nilai > 80){
  score <- "B"
} else if(nilai > 70){
  score <- "C"
} else if(nilai > 60){
  score <- "D"
} else if(nilai > 0 & nilai <=60){
  score <- "E"
} else {
  score <- "Tidak Valid"
}
sprintf("Nilai score Anda %s.", score)

## [1] "Nilai score Anda B."

4. nested if-else statement

• Memungkinkan dalam 1 statement if terdapat serangkaian statement if lain
• Dibentuk dengan: if (parent condition1) { if(child condition1){ child statement1 } else { child statement2 } } else if(condition2){ <- langsung kesini jika if parent 1 FALSE statement 2 } .. else if(condition n){ statement n } else { last satement }

nilaiUTS <- 65
nilaiUAS <- 61
nilaiAkhir <- mean(nilaiUTS, nilaiUAS)
if(nilaiAkhir>70){
  if(nilaiAkhir > 60){
    status <- "Lulus"
  } else {
    status <- "Remedi"
  }
} else {
    status <- "Tidak Lulus"
}
sprintf("Dalam mata kuliah ini Anda %s", status)

## [1] "Dalam mata kuliah ini Anda Tidak Lulus"

if(status == "Remedi"){
  print("Take the retest!")
} else if(status == "Tidak Lulus"){
  print("Repeat the class next year!")
} else{
  print("Congratulations!")
}

## [1] "Repeat the class next year!"

4. ifelse statement

• Seperti if dan else tetapi dalam 1 line code
• Dibentuk dengan ifelse(condition, statement TRUE, statement FALSE)

x <- -12
ifelse(x > 0, "x bilangan positif", "x bilangan negatif")

## [1] "x bilangan negatif"

5. switch statement

• switch(expression, list)

switch(3, "Apple", "Books", "Watermelon", "Desk", "Table")

## [1] "Watermelon"

Loop in R

Ada 3 bentuk perulangan di R, yaitu dengan for, while, dan repeat. 1. For loop * Secara umum digunakan untuk mengiterasi item dalam sebuah deret * Disebut entry contrlled loop, yang artinya condition yang dientry ditest terlebih dahulu, jika bernilai TRUE maka dieksekusi, jika bernilai FALSE maka body loop tidak dieksekusi sama sekali. * Dibentuk dengan: for (condition in sequence){statement}

for (i in 1:7){print(i^2)}

## [1] 1
## [1] 4
## [1] 9
## [1] 16
## [1] 25
## [1] 36
## [1] 49

for (i in 1:12){print(month.name[i])}

## [1] "January"
## [1] "February"
## [1] "March"
## [1] "April"
## [1] "May"
## [1] "June"
## [1] "July"
## [1] "August"
## [1] "September"
## [1] "October"
## [1] "November"
## [1] "December"

name <- c('Alison', 'Matthew', 'Lucas', 'David', 'Cindy')
for (i in name){print(i)}

## [1] "Alison"
## [1] "Matthew"
## [1] "Lucas"
## [1] "David"
## [1] "Cindy"

2. While loop

• Sebuah tipe perulangan yang pasti dieksekusi
• Body loop akan selalu dieksekusi sampai condition yang diberikan bernilai FALSE
• While pasti tereksekusi minimal sekali
• Harus diberi pernyataan tambahan untuk menghentikan loop
• Dibentuk dengan: while (condition){statement}

init <- 1
while (init <= 3){
  print(init^3)
  init <- init+1 #dalam while harus ada pernyataan ini agar tidak forever looping
}

## [1] 1
## [1] 8
## [1] 27

height <- 1
while (height <= 7){
  print(strrep("# ", height))
  height <- height + 1
}

## [1] "# "
## [1] "# # "
## [1] "# # # "
## [1] "# # # # "
## [1] "# # # # # "
## [1] "# # # # # # "
## [1] "# # # # # # # "

3. Repeat loop

• Loop/perulangan sederhana yang akan mengeksekusi statement sampai ada kondisi yang menghentikannya. Kondisi diletakkan setelah pernyataan loop.
• Pada dasarnya repeat tidak memiliki formula terentu untuk mengehntikan perulangan sehingga harus ditambahkan sendiri.
• Jika tidak diberi kondisi maka loop akan diulang terus.
• Dibentuk dengan: repeat { statement if(condition){ break <- untuk menghentikan perulangan } }

inits <- 0
repeat{
  #sprintf("%.0f adalah pangkat dua dari %.0f", inits^2, inits)
  print(paste(inits^2, "adalah pangkat dua dari", inits))
  inits <- inits + 1
  if(inits>8){
    break
  }
}

## [1] "0 adalah pangkat dua dari 0"
## [1] "1 adalah pangkat dua dari 1"
## [1] "4 adalah pangkat dua dari 2"
## [1] "9 adalah pangkat dua dari 3"
## [1] "16 adalah pangkat dua dari 4"
## [1] "25 adalah pangkat dua dari 5"
## [1] "36 adalah pangkat dua dari 6"
## [1] "49 adalah pangkat dua dari 7"
## [1] "64 adalah pangkat dua dari 8"

• Terdapat perintah next dalam looping, untuk menghentikan eksekusi pada iterasi tertentu dan melanjutkan ke iterasi berikutnya. Dengan catatan, harus ada batas maksimal kapan iterasi dihentikan.

num <- 1:11
for (i in num){
  if (i==8){
    next
  }
  print(paste("Bulan ke-", i, "adalah bulan", month.name[i]))
}

## [1] "Bulan ke- 1 adalah bulan January"
## [1] "Bulan ke- 2 adalah bulan February"
## [1] "Bulan ke- 3 adalah bulan March"
## [1] "Bulan ke- 4 adalah bulan April"
## [1] "Bulan ke- 5 adalah bulan May"
## [1] "Bulan ke- 6 adalah bulan June"
## [1] "Bulan ke- 7 adalah bulan July"
## [1] "Bulan ke- 9 adalah bulan September"
## [1] "Bulan ke- 10 adalah bulan October"
## [1] "Bulan ke- 11 adalah bulan November"