Bab 5 Fungsi dan String


5.1 Tujuan Pembelajaran

CPMK 5

Mahasiswa mampu mendefinisikan fungsi dan menerapkannya untuk melakukan perhitungan dalam bahasa R.

Sub-CPMK 5

Mahasiswa mampu mendefinisikan dan menerapkan fungsi, argumen, operator, dan menggunakan fungsi built-in dalam R.

Deskripsi Isi Bahan Ajar

Bab 5 ini membahas tentang:

  1. Definisi Fungsi.
  2. Komponen dan Tipe Fungsi.
  3. Fungsi Built-In (Bawaan).
  4. Tipe Data String dalam R.
  5. Fungsi Built-In (Bawaan) String.

Waktu Pembelajaran

Alokasi Waktu = 3 x 50 menit (3 SKS)

Kegiatan Alokasi Waktu
Ceramah dan Diskusi Interaktif 50 menit
Praktik Fungsi dan String R 50 menit
Konsultasi Praktik R 50 menit
Presentasi individu 50 menit

Petunjuk Penggunaan Bahan Ajar

  1. Langkah-langkah pembelajaran.
    Pelajari definisi fungsi, komponen fungsi, tipe fungsi, fungsi built-in, tipe data string, dan fungsi built-in string dalam R. Terapkan pengetahuan Anda pada contoh-contoh kasus yang telah disajikan secara individu kolaboratif. Konsultasikanlah kesulitan Anda selama praktik pada pengajar mata kuliah ini. Anda bisa bekerja dengan IDE RStudio secara offline maupun online.

  2. Sumber Belajar yang Dibutuhkan.
    Laptop (Notebook), jaringan internet

Tujuan Akhir (Performance Objective)

Setelah menyelesaikan modul ini, mahasiswa mampu memahami definisi fungsi, komponen fungsi, tipe fungsi, fungsi built-in, tipe data string, dan fungsi built-in string dalam R.

5.2 Definisi Fungsi dalam R

Pada bab sebelumnya, kita telah banyak berlatih R dalam hal pengambilan keputusan dan perulangan. Topik tersebut memang merupakan konsep dasar dalam setiap pembelajaran pemrograman dasar tidak hanya dengan R. Sekarang kita akan beranjak lebih jauh lagi yaitu akan belajar fitur utama dari program komputer yaitu fungsi. Selain itu, kita juga akan memperdalam salah satu tipe data R yaitu string.

Semua variabel yang dideklarasikan dalam pekerjaan pemrograman kita akan disimpan pada Tab Environment yang bisa Anda lihat di bagian kanan atas dari lembar kerja RStudio. Pada bagian ini kita bisa memeriksa daftar variabel dan nilai yang telah tersimpan di dalam memori komputer. Meskipun demikian, ada cara lain untuk menyimpan deklarasi variabel yaitu dengan menyimpannya dalam suatu fungsi. Fungsi, seperti namanya, diprogram untuk melakukan suatu proses komputasi yang dirancang sesuai dengan tujuan pemrograman. Tujuan pemrograman yang membutuhkan kalkulasi yang rumit terkadang sedikit merepotkan dan biasanya fungsi digunakan untuk meringkas penulisan kode supaya implementasinya menjadi lebih mudah. Kumpulan fungsi dalam R yang telah dikembangkan, misalnya untuk tujuan analisis data penelitian, biasanya disimpan dalam bentuk “package”. Contoh package seperti “spheredata” (https://cran.r-project.org/web/packages/spheredata/index.html) dan “sphereML” (https://cran.r-project.org/web/packages/sphereML/index.html) yang telah dikembangkan oleh Penulis. Melalui package ini, fungsi yang tidak pernah difasilitasi oleh base R bisa digunakan jika sesuai dengan kebutuhan pemrograman kita.

Kita bisa menulis fungsi untuk melakukan operasi berulang di masa dengan hanya dengan menuliskan sintaks/ kode yang telah didefinisikan. Misalkan kita buat sebagai latihan disini dinamakan dengan “my_function” dan parameter inputnya (argumen) akan diisi oleh pengguna. Fungsi didefinisikan untuk melakukan suatu operasi komputasi tertentu di dalam tubuh fungsi yang diletakkan dalam kurung kurawal {}. Kemudian fungsi akan diprogram untuk mengeluarkan nilai output tertentu setelah fungsi dijalankan dengan perintah return (lihat materinya sudah pernah sedikit dibahas pada Bab 4).

Format dasar dari suatu fungsi R dapat digeneralisasikan dalam sintaks berikut.

Syntax:

function_name <- function(arg_1, arg_2, ...) { # here you can write a body of function }

Di atas adalah sintaks general dari fungsi R. Penjelasan komponennya adalah sebagai berikut.

  • function adalah “fungsi” dari base R untuk mendefinisikan fungsi.
  • function_name adalah nama fungsi yang kita buat.
  • arg_1, arg_2, ... adalah “argumen” atau parameter input yang harus diisikan oleh pengguna untuk melakukan perhitungan.

Contoh:

Berikut ini adalah contoh fungsi built-in R yaitu sum. Deskripsi dari fungsi ini bisa kita cari melalui Tab “Help”. Jelaskan kegunaan dari fungsi sum berdasarkan informasi yang telah diberikan! Apa saja komponen fungsinya?

sum(2,3,4)
## [1] 9

Ketikkan nama fungsi sum pada kolom pencarian dari Tab “Help”, Anda akan menemukan informasi di bawah ini.


5.3 Komponen dan Tipe Fungsi

Fungsi dibangun oleh beberapa komponen atau unsur antara lain:

  • Function name = adalah nama aktual dari fungsi yang kita definisikan dan yang akan tersimpang di dalam Environment R sebagai sebuah objek dengan nama tersebut.
  • Argument = adalah elemen “input” yang harus dimasukkan oleh pengguna. Tanpa argumen biasanya fungsi tidak bisa berjalan kecuali argumen “default” telah ditentukan.
  • Function body = adalah tubuh dari fungsi yang mengandung proses komputasi pemrograman yang akan kita lakukan. Ini merupakan bagian utama dari bangunan sebuah fungsi.
  • Return value = adalah output ungkapan yang kita harapkan dari proses komputasi yang kita jalankan.

Fungsi memfasilitasi kita untuk “membungkus” proses komando atau komputasi yang sedang kita terjakan untuk tugas tertentu. Fungsi bisa kita namakan secara spesifik sesuai dengan tujuan tugas sehingga bisa kita gunakan kembali di bagian yang lain. Fungsi memudahkan membagi program menjadi subunit dalam melakukan tugas spesifik untuk program tersebut, sehingga meningkatkan pemrograman menjadi bersifat “modular” dan meningkatkan kode program yang ditulis menjadi lebih mudah digunakan kembali. Dalam memanggil fungsi, kita memberikan informasi sebagai parameternya, dan fungsi tersebut dapat mengembalikan nilai dari fungsi yang sedang dijalankan.

Sekarang kita akan praktik membuat fungsi yang kita buat sendiri. Disini ditampilkan sebuah contoh untuk melakukan konversi satuan suhu dari satuan Fahrenheit (\(F\)) ke Celcius (\(C\)). Kita ingat bahwa persamaan di bawah ini dapat digunakan untuk konversi dari Fahrenheit ke Celcius.

\[ C = \frac{5}{9}(F-32) \]

Contoh:

Definisikan fungsi dengan nama “f_to_c” dengan argumen input “temp_in_F” dimana ini adalah suhu dalam satuan Fahrenheit yang akan diubah menjadi Celcius. Fungsi “f_to_c” kemudian ditugaskan menampilkan suhu Celcius yang telah dihitung.

f_to_c <- function(temp_in_F){
  temp_in_C <- 5/9 * (temp_in_F - 32)
  return(temp_in_C)
}

Sekarang kita terapkan untuk mengubah suhu \(10^oF\), berapakah dalam Celcius?

f_to_c(10)
## [1] -12.22222

Bagaimana kalau \(-40^oF\), berapakah suhunya dalam Celcius?

Argumen

Kita dapat meneruskan informasi melalui argumen. Argumen adalah disebutkan di dalam tanda kurung dari sebuah fungsi. Kita bisa membuat argumen sebanyak-banyaknya sesuai dengan kebutuhan pekerjaan kita. Argumen satu dengan lainnya kemudian dipisahkan dengan tanda koma.

Berikut ini adalah contoh fungsi dengan nama new_function dengan argumen fname. Fungsi ini ketika dijalankan akan meneruskan informasi yang disimpan dalam fname yang kemudian digunakan untuk mencetak nama lengkapnya.

Contoh:

new_function <- function(fname){
  paste(fname, "R Programming")
}

new_function("Python")
## [1] "Python R Programming"
new_function("PHP")
## [1] "PHP R Programming"
new_function("Julia")
## [1] "Julia R Programming"

Secara default, sebuah fungsi dapat dijalankan ketika argumen telah diisi oleh nilai tertentu. Jika meminta dua argumen, maka pengguna harus mengisi kedua argumen tersebut atau fungsi tidak bisa digunakan.

Contoh:

Contoh berikut ini menggunakan dua argumen dan berfungsi untuk mencetak kedua nilai dari kedua argumen tersebut.

nama_lengkap <- function(first_name, last_name){
  paste(first_name, last_name)
}

nama_lengkap("Suzuki", "Kunaiki")
## [1] "Suzuki Kunaiki"

Kita juga bisa menetapkan nilai argumen secara default. Jadi pengguna tidak perlu mengatur nilai argumen secara spesifik dalam menggunakan fungsi.

Contoh:

akuWNI <- function(country = "Indonesia"){
  paste("Aku adalah orang", country)
}

akuWNI()
## [1] "Aku adalah orang Indonesia"
akuWNI("Malaysia")
## [1] "Aku adalah orang Malaysia"

Terdapat beberapa jenis fungsi di dalam R antara lain:

  • Fungsi primitif
  • Fungsi infix
  • Fungsi replacement

Mari kita bahas setiap tipe satu per satu.

Fungsi Primitif

Secara umum, suatu fungsi terdiri dari tiga elemen:

  • Formal(), daftar argumen yang mengontrol bagaimana fungsi dipanggil.
  • Body(), kumpulan baris kode di dalam fungsi.
  • Environment(), struktur data bagaimana fungsi menemukan nilai yang berhubungan dengan namanya.

Formal() didefnisikan secara eksplisit ketika kita membuat sebuah fungsi, tetapi Environment() ditetapkan secara implisit berdasarkan lokasi dimana pengguna menggunakan fungsi. Tetapi terdapat pengecualian terhadap aturan bahwa sebuah fungsi memiliki tiga komponen, yaitu fungsi memanggil kode secara langsung. Fungsi-fungsi ini adalah primitive function. Fungsi ini ada utamanya dalam bahasa C, bukan R, sehingga elemen formal(), body(), dan environment() adalah NULL. Fitur ini hanya ditemukan di dalam base R. Fungsi primitif tidak mudah untuk ditulis dalam bahasa komputer tetapi sangat efisien untuk digunakan. Terdapat 2 jenis dari fungsi primitive, yaitu built-in atau spesial.

Berikut ini adalah daftar lengkap dari fungsi primitif di dalam R. Di baris kode yang dicontohkan ini, saya hanya menampilkan daftar dari 20 fungsi primitive dengan menggunakan subset c(1:20).

Contoh:

names(methods:::.BasicFunsList)[c(1:20)]
##  [1] "$"          "$<-"        "["          "[<-"        "[["        
##  [6] "[[<-"       "crossprod"  "tcrossprod" "xtfrm"      "c"         
## [11] "all"        "any"        "sum"        "prod"       "max"       
## [16] "min"        "range"      "cummax"     "rep"        "^"

Jumlah fungsi primitive yang didukung R bisa kita cari dengan fungsi length() yang kita temukan sebanyak 213. Oleh karena itu, membatasi sebanyak 20 di atas adalah untuk menyesuaikan agar tulisan ini tidak menghabiskan banyak halaman kertas. Bagaimana jika kita ingin menampilkan fungsi primitif yang lain?

Contoh:

x <- names(methods:::.BasicFunsList)

length(x)
## [1] 213

Salah satu contoh fungsi primitif dalam R lainnya adalah sum yang pernah kita gunakan di atas yang berfungsi untuk melakukan penjumlahan total dari suatu himpunan bilangan,

Contoh:

sum(2,20,99)
## [1] 121

Selanjutnya kita bisa memeriksa apakah suatu fungsi R merupakan fungsi primitif atau tidak dengan menggunakan sintaks di bawah ini.

Syntax:

is.primitive(func)

Sebelumnya kita pernah membuat fungsi bernama f_to_c, new_function, nama_lengkap, dan akuWNI. Mari kita periksa apakah primitif atau tidak dengan menggunakan is.primitive.

Contoh:

Seperti yang sudah dijelaskan sum adalah salah satu contoh dari fungsi primitif.

is.primitive(sum)
## [1] TRUE
is.primitive(f_to_c)
## [1] FALSE
is.primitive(nama_lengkap)
## [1] FALSE
is.primitive(akuWNI)
## [1] FALSE

Ketiganya jelas bukan merupakan fungsi primitif karena mereka dibuat oleh kita sendiri dalam contoh kita sebelumnya. Fungsi primitif sesuai namanya pasti sudah ditentukan secara bawaan di dalam bahasa pemrograman.

Fungsi Infix

Fungsi yang pernah kita buat sebelumnya adalah jenis fungsi “prefix” karena nama fungsi terletak sebelum argumen (a.k.a “pre”) yang diletakkan di dalam tanda kurung (). Fungsi R juga bisa ditulis secara “infix” dimana nama fungsi diletakkan di dalam argumen. Contohnya adalah operator + dan - merupakan fungsi infix. Jika kita mengoperasikan penjumlahan a+b artinya nama fungsinya adalah + dan argumennya adalah ekuivalen dengan (a,b).

Contoh:

Operator jumlahan + dapat kita jalankan dengan formula function_name() seperti di bawah ini.

'+'(2,3)
## [1] 5
'/'(2,3)
## [1] 0.6666667

Silakan coba operator lainnya yang pernah kita pelajari pada Bab 3 sebelumnya.

Kita juga bisa mendefinisikan sebuah fungsi dengan aturan infix ini. Caranya seperti di bawah ini.

Syntax:

'%func_name%' <- function(arg1, arg2) { #function body }

Contoh:

# R program to illustrate
# Infix function

'%Greater%' <- function(a,b){
  if(a>b) print(a)
  else if (b>a) print(b)
  else print("equal")
}

5 %Greater% 8
## [1] 8
2300 %Greater% 66
## [1] 2300

Sekarang kita membuat fungsi infix pemangkatan.

'%pwr%' <- function(x,y){
  return(x^y)
}

5 %pwr% 2
## [1] 25

Variabel yang dibuat di luar tubuh fungsi adalah variabel “global”. Variabel global dapat digunakan oleh fungsi manapun di dalam fungsi atau di luar fungsi.

Contoh:

txt <- "Kita sedang belajar pemrograman R"

my_function <- function(){
  paste("Contoh kalimatnya adalah", txt)
}

my_function()
## [1] "Contoh kalimatnya adalah Kita sedang belajar pemrograman R"

Sebaliknya, ketika kita membuat sebuah variabel di dalam tubuh fungsi maka variabel tersebut tidak tersimpan di dalam global environment dan hanya tersimpan ketika fungsi dipanggil.

Contoh:

local_function <- function(k,l){
  k <- 5
  l <- 10
  return (k*l)
}

local_function()
## [1] 50

Dalam hal ini, ketika kita menjalankan kode k atau l maka muncul kode Error: object 'k' not found atau Error: object 'l' not found karena keduanya didefinisikan secara lokal di dalam fungsi local_function() saja.

5.4 Fungsi Built-In (Bawaan).

R menyediakan beberapa fungsi bawaan (built-in) yang terbagi ke dalam beberapa kategori antara lain:

  • Fungsi matematika/ numerik
  • Fungsi karakter
  • Fungsi statistika
  • Fungsi lainnya

Fungsi Numerik

Tabel di bawah ini menunjukkan beberapa fungsi numerik dan karakter yang sering digunakan dalam membuat variabel.

Fungsi Deskripsi
abs(x) Mengembalikan nilai mutlak dari \(x\)
sqrt(x) Mengembalikan nilai akar dari \(x\)
ceiling(x) Membulatkan suatu bilangan desimal \(x\) ke atas
floor(x) Membulatkan suatu bilangan desimal \(x\) ke bawah
round(x, digits=n) Membulatkan nilai \(x\) sampai digit tertentu
cos(x), acos(x), cosh(x), etc Mengembalikan nilai trigonometri dari sudut \(x\)
log(x) Mengembalikan nilai logaritma natural dari \(x\)
log10(x) Mengembalikan nilai algoritma biasa dari \(x\)
exp(x) Mengembalikan nilai eksponensial \(e^x\)

Contoh:

abs(-10)
## [1] 10
sqrt(169)
## [1] 13
ceiling(pi)
## [1] 4
floor(pi)
## [1] 3
trunc(2*pi)
## [1] 6
round(pi, 5)
## [1] 3.14159
tan(pi/4)
## [1] 1
log(1000)
## [1] 6.907755
log10(1000)
## [1] 3
exp(10)
## [1] 22026.47

Fungsi Karakter

Beberapa fungsi yang bermanfaat untuk mengolah data karakter dan manipulasinya dikenal sebagai fungsi karakter. Tabel di bawah ini menambilkan beberapa fungsi karakter yang akan sering kita gunakan nanti di dalam R.

Fungsi Deskripsi
is.character() Memeriksa tipe data karakter
as.character() Mengatur nilai sebagai tipe data karakter
substr(x,start=n1,stop=n2) Mengekstrak karakter mulai dari \(n_1\) ke \(n_2\)
strsplit(x,split) Memisahkan karakter antar separator
paste(...,sep="") Menempelkan karakter di antara separator
toupper(x) Mengatur karakter menjadi “uppercase”
tolower(x) Mengatur karakter menjadi “lowercase”

Contoh:

is.character(100L)
## [1] FALSE
is.character(as.character(100L))
## [1] TRUE
substr("Indonesia", start=3, stop=7)
## [1] "dones"
strsplit("abc", split="")
## [[1]]
## [1] "a" "b" "c"
paste("x", 1:3, sep="M")
## [1] "xM1" "xM2" "xM3"
toupper("IndOneSia")
## [1] "INDONESIA"
tolower("IndOneSia")
## [1] "indonesia"

Fungsi Statistika

R merupakan salah satu bahasa pemrograman yang didedikasikan untuk pengolahan analisis statistika dan sains data. Operasi statistika dasar telah didukung R secara default tanpa harus menginstall package/ library tambahan. Hal ini merupakan kelebihan R dibandingkan bahasa pemrograman yang lain. Tabel di bawah ini menunjukkan beberapa fungsi yang berkaitan dengan statistika peluang. Untuk pembangkitan bilangan acak, kamu dapat menggunakan set.seed(1234) untuk menghasilkan output yang sama dengan buku ini.

Fungsi Deskripsi
dnorm() Fungsi distribusi normal (by default m=0, sd=1)
pnorm() Probabilitas normal kumulatif untuk q (area dibawah kurva normal ke kiri dari q)
qnorm() Quantile dari distribusi normal
rnorm() Variat acak di sekitar rerata m dan standar deviasi d

Contoh:

set.seed(1234)

x <- pretty(c(-3,3), 30)
y <- dnorm(x)

plot(x,y, type="l", xlab="Simple Deviate", ylab="Density")

pnorm(1.96)
## [1] 0.9750021
qnorm(0.9) #persentil ke-90
## [1] 1.281552
#50 random variates with mean 50 and sd 10
rnorm(50,m=50,sd=10)
##  [1] 37.92934 52.77429 60.84441 26.54302 54.29125 55.06056 44.25260 44.53368
##  [9] 44.35548 41.09962 45.22807 40.01614 42.23746 50.64459 59.59494 48.89715
## [17] 44.88990 40.88805 41.62828 74.15835 51.34088 45.09314 45.59452 54.59589
## [25] 43.06280 35.51795 55.74756 39.76344 49.84862 40.64051 61.02298 45.24407
## [33] 42.90560 44.98742 33.70907 38.32381 28.19960 36.59007 47.05706 45.34102
## [41] 64.49496 39.31357 41.44635 47.19377 40.05660 40.31486 38.92682 37.48014
## [49] 44.76172 45.03150

Fungsi statistika lainnya akan kita bahas selanjutnya di Bab 9. Tabel di bawah ini merangkum beberapa fungsi yang penting untuk dipelajari lebih dulu.

Fungsi Deskripsi
mean(x) Nilai rata-rata dari objek \(x\)
sd(x) Nilai standar deviasi dari objek \(x\)
median(x) Nilai median dari objek \(x\)
quantile(x,probs) Kuantil dari \(x\) dimana probs adalah nilai antara [0,1]
range(x) Nilai jangkauan dari objek \(x\)
sum(x) Nilai jumlahan(total) dari objek \(x\)
min(x) Nilai minimum dari objek \(x\)
max(x) Nilai minimum dari objek \(x\)
seq(from,to,by) Membuat barisan bilangan
rep(x,ntimes) Membuat bilangan berulang
cut(x,n) Membagi variabel kontinyu menjadi faktor menjadi level sebanyak n

Contoh:

x <- c(60,65,72,62,58,59,90,85,76,74)
mean(x)
## [1] 70.1
x <- c(60,65,72,62,58,59,90,85,76,74)
sd(x)
## [1] 11.22943
x <- c(60,65,72,62,58,59,90,85,76,74)
median(x)
## [1] 68.5
x <- c(60,65,72,62,58,59,90,85,76,74)
quantile(x,probs=0.5)
##  50% 
## 68.5
x <- c(60,65,72,62,58,59,90,85,76,74)
range(x)
## [1] 58 90
x <- c(60,65,72,62,58,59,90,85,76,74)
sum(x)
## [1] 701
sum(x)/length(x)
## [1] 70.1
min(x)
## [1] 58
max(x)
## [1] 90
seq(1,12,2)
## [1]  1  3  5  7  9 11
rep(1:3,2)
## [1] 1 2 3 1 2 3
cut(x,5)
##  [1] (58,64.4]   (64.4,70.8] (70.8,77.2] (58,64.4]   (58,64.4]   (58,64.4]  
##  [7] (83.6,90]   (83.6,90]   (70.8,77.2] (70.8,77.2]
## Levels: (58,64.4] (64.4,70.8] (70.8,77.2] (77.2,83.6] (83.6,90]

5.5 Tipe Data String dalam R.

Nilai suatu data yang ditulis di dalam tanda kutip (‘…’) atau (“…”) dalam R disebut sebagai “string”. Jika di dalam kutip ganda (“…”) kita masih bisa membuat dengan tanda kutip tunggal (‘…’).

Dalam R, data teks disimpan dalam vektor karakter atau medan karakter. Kita perlu mengingat bahwa setiap elemen vektor karakter merepresentasikan seluruh string, tidak hanya karakter tunggal. Dalam R, “string” adalah istilah acak yang digunakan sebagai sebuah “elemen dari karakter vektor”.

Seperti yang sudah kamu ketahui, vektor karakter harus dibuat dengan menggunakan fungsi c(). Kita dapat menggunakan tanda kutip tunggal atau ganda untuk membuat string, meskipun tanda kutip ganda lebih sering dipilih oleh programmer karena bisa mewakili tanda kutip tunggal.

Berikut ini adalah aturan dalam berurusan dengan string di R.

  • String yang dimulai dari tanda kutip tunggal harus diakhiri dengan tanda kutip tunggal pula. Contoh yang diperbolehkan di dalam R seperti ‘kamu’, ‘kamu”’, ‘kamu's’.
  • String yang dimulai dari tanda kutip ganda juga harus diakhiri dengan tanda kutip ganda. Diantara tanda kutip ganda kita bisa menulis tanda kutip tunggal. Contoh yang diperbolehkan di dalam R seperti “kamu adalah ‘anda’ sama saja”, “kita adalah ‘kami’ seperti ini”.

Contoh:

string1 <- "Ini adalah sebuah string"
string2 <- 'Jika aku ingin membuat "kutipan", saya bisa menggunakan tanda kutipan tunggal'
string3 <- "Jika aku ingin membuat 'kutipan', saya bisa menggunakan tanda kutipan tunggal"

print(string1)
## [1] "Ini adalah sebuah string"
print(string2)
## [1] "Jika aku ingin membuat \"kutipan\", saya bisa menggunakan tanda kutipan tunggal"
print(string3)
## [1] "Jika aku ingin membuat 'kutipan', saya bisa menggunakan tanda kutipan tunggal"

Syntax:

`c(value1, value2)

c("Aku", "adalah", "mahasiswa", "yang", "suka", "pemrograman", "R", "2026")
## [1] "Aku"         "adalah"      "mahasiswa"   "yang"        "suka"       
## [6] "pemrograman" "R"           "2026"

Fungsi c() memiliki dua aplikasi dalam pemrograman R antara lain:

  1. Menggabungkan nilai numerik dalam vektor dengan fungsi c()
  2. Menggabungkan nilai numerik dan variabel

Mari kita diskusikan kedua penerapan tersebut.

  1. Dengan fungsi numerik: Kita bisa memasukkan semua nilai yang ingin ditambahkan di dalam sebuah vektor dengan tanda koma.

Contoh:

x1 <- c(1,2,3,8,8,4,6)
print(x1)
## [1] 1 2 3 8 8 4 6
  1. Dengan nilai numeric dan variabel

Kita bisa menambahkan nilai baru ke dalam vektor seperti yang ditunjukkan oleh kode di bawah ini.

Contoh:

x2 <- c(x1, 5, 7, 1)
print(x2)
##  [1] 1 2 3 8 8 4 6 5 7 1

5.6 Fungsi Bawaan untuk Data String.

Base R telah memberikan banyak fungsi bawaan (default) yang bisa digunakan untuk mengolah data string, tetapi kita tidak merekomendasikannya karena sering inkonsisten. Sekarang kita gunakan package “stringr”. Semua fungsinya lebih intuitif yang ditandai dengan nama awalan str_. Sebagai contoh, str_length() berfungsi untuk mencari jumlah karakter dari sebuah string.

Cek tab Packages, Apakah kamu sudah menginstall package “stringr”? Jika belum jalankan ini.

install.packages("stringr")


Contoh:

library(stringr)

str_length(c("a", "R adalah bahasa pemrograman untuk statistika dan analisis data", NA))
## [1]  1 62 NA
language <- "R adalah bahasa pemrograman untuk statistika dan analisis data"

str_to_upper(language)
## [1] "R ADALAH BAHASA PEMROGRAMAN UNTUK STATISTIKA DAN ANALISIS DATA"
str_to_lower(language)
## [1] "r adalah bahasa pemrograman untuk statistika dan analisis data"
str_to_title(language)
## [1] "R Adalah Bahasa Pemrograman Untuk Statistika Dan Analisis Data"
str_to_sentence(language)
## [1] "R adalah bahasa pemrograman untuk statistika dan analisis data"
  • Fungsi str_c()

Contoh:

letters
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
## [20] "t" "u" "v" "w" "x" "y" "z"
LETTERS
##  [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
## [20] "T" "U" "V" "W" "X" "Y" "Z"
str_c("Letter; ", letters)
##  [1] "Letter; a" "Letter; b" "Letter; c" "Letter; d" "Letter; e" "Letter; f"
##  [7] "Letter; g" "Letter; h" "Letter; i" "Letter; j" "Letter; k" "Letter; l"
## [13] "Letter; m" "Letter; n" "Letter; o" "Letter; p" "Letter; q" "Letter; r"
## [19] "Letter; s" "Letter; t" "Letter; u" "Letter; v" "Letter; w" "Letter; x"
## [25] "Letter; y" "Letter; z"
str_c(letters, " adalah untuk", "...")
##  [1] "a adalah untuk..." "b adalah untuk..." "c adalah untuk..."
##  [4] "d adalah untuk..." "e adalah untuk..." "f adalah untuk..."
##  [7] "g adalah untuk..." "h adalah untuk..." "i adalah untuk..."
## [10] "j adalah untuk..." "k adalah untuk..." "l adalah untuk..."
## [13] "m adalah untuk..." "n adalah untuk..." "o adalah untuk..."
## [16] "p adalah untuk..." "q adalah untuk..." "r adalah untuk..."
## [19] "s adalah untuk..." "t adalah untuk..." "u adalah untuk..."
## [22] "v adalah untuk..." "w adalah untuk..." "x adalah untuk..."
## [25] "y adalah untuk..." "z adalah untuk..."
str_c("huruf ", letters[-26], " sebelum huruf ", letters[-1])
##  [1] "huruf a sebelum huruf b" "huruf b sebelum huruf c"
##  [3] "huruf c sebelum huruf d" "huruf d sebelum huruf e"
##  [5] "huruf e sebelum huruf f" "huruf f sebelum huruf g"
##  [7] "huruf g sebelum huruf h" "huruf h sebelum huruf i"
##  [9] "huruf i sebelum huruf j" "huruf j sebelum huruf k"
## [11] "huruf k sebelum huruf l" "huruf l sebelum huruf m"
## [13] "huruf m sebelum huruf n" "huruf n sebelum huruf o"
## [15] "huruf o sebelum huruf p" "huruf p sebelum huruf q"
## [17] "huruf q sebelum huruf r" "huruf r sebelum huruf s"
## [19] "huruf s sebelum huruf t" "huruf t sebelum huruf u"
## [21] "huruf u sebelum huruf v" "huruf v sebelum huruf w"
## [23] "huruf w sebelum huruf x" "huruf x sebelum huruf y"
## [25] "huruf y sebelum huruf z"
str_c(letters, collapse = "")
## [1] "abcdefghijklmnopqrstuvwxyz"
str_c(letters, collapse = ", ")
## [1] "a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z"
str_c(c("a", NA, "b"), "-d")
## [1] "a-d" NA    "b-d"
str_c(str_replace_na(c("aa", NA, "b")), "-d")
## [1] "aa-d" "NA-d" "b-d"
  • Fungsi str_count()

Contoh:

fruit <- c("apple", "banana", "pear", "pineapple")
str_count(fruit, "a")
## [1] 1 3 1 1
str_count(fruit, "p")
## [1] 2 0 1 3
str_count(fruit, "e")
## [1] 1 0 1 2
str_count(fruit, c("a", "i", "p", "p"))
## [1] 1 0 1 3
str_count(c("a.", "...", ".a.a"), ".")
## [1] 2 3 4
str_count(c("a.", "...", ".a.a"), fixed("."))
## [1] 1 3 2
  • Fungsi str_length()

Contoh:

str_length(letters)
##  [1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
str_length(NA)
## [1] NA
str_length(factor("ABC"))
## [1] 3
str_length(c("i", "like", "programming", NA))
## [1]  1  4 11 NA
  • Fungsi paste()

Kita dapat menggabung beberapa string dengan fungsi paste() di dalam R.

Contoh:

a <- "Kamu sedang "
b <- "belajar "
c <- "bahasa pemrograman R."

paste(a,b,c)
## [1] "Kamu sedang  belajar  bahasa pemrograman R."
  • Fungsi format()

Kita dapat memformat bilangan dan string dengan fungsi format()

Contoh:

result <- format(13.6789, digits=4)
print(result)
## [1] "13.68"
format(c(3, 13.521), scientific = TRUE)
## [1] "3.0000e+00" "1.3521e+01"

5.7 Tugas (Project-Based Learning)

Kerjakanlah tugas berikut secara individu dan presentasikan hasilnya di akhir pembelajaran!

Buatlah fungsi R untuk mengerjakan persamaan mekanika berikut ini.

  1. Gerak lurus beraturan (\(s\), \(v\), \(t\)).
  2. Gerak lurus berubah beraturan (\(s\), \(v_t\), \(a\)).
  3. Gerak parabola (\(v_x\), \(x\), \(v_y\), \(y\), \(x_{max}\), \(y_{max}\)).

Buatlah secara kreatif nama fungsi secara bebas dan tentukan nilai argumen yang dimasukkan sesuai dengan preferensi Anda!

5.8 Rubrik Penilaian Pembelajaran

Nama Mahasiswa :
NIM :

Aspek 1 2 3 4
Aktivitas pemrograman … … … …
Kelancaran tugas … … … …
Kualitas pekerjaan … … … …
Keterbukaan masukan … … … …

Definisi

  • Aktivitas pemrograman mengukur keterlibatan mahasiswa dalam proses mengikuti pelajaran.
  • Kelancaran tugas mengukur sejauh mana mahasiswa mampu mengikuti prosedur pemrograman yang telah dicontohkan dalam buku ini.
  • Kualitas pekerjaan mengukur kemampuan mahasiswa dalam menggunakan komputernya untuk melakukan pemrograman dengan R.
  • Keterbukaan masukan mengukur sejauh mana kualitas presentasi mahasiswa dan menerima masukan dan tanggapan dari temannya yang lain.

5.9 Penutup

Dalam bab ini, kita telah mempelajari salah satu keterampilan penting dalam pemrograman dasar yaitu fungsi. Kita telah membuat beberapa tipe fungsi yang dapat kita gunakan untuk mengembangkan “package” analisis data misalnya jika belum pernah disediakan di dalam repositori CRAN. Hal ini membuktikan kecanggihan dari bahasa pemrograman R yang bisa melakukan proses komputasi apapun bahkan mendukung kreativitas kita hingga ke tingkat tinggi. Selain itu, kita juga telah mempelajari beberapa fungsi yang dapat kita gunakan untuk mengolah data teks (string). Keterampilan ini akan sangat berguna untuk memahami topik-topik pembelajaran berikutnya yang tidak kalah penting untuk dipelajari. Tetap semangat.