Fungsi, Pemrograman Berorientasi Objek, dan Optimasi dalam R

Fungsi

Pengertian Fungsi

R telah menyiapkan banyak fungsi yang bisa dimanfaatkan untuk komputasi dan grafik Fungsi yang belum tersedia didalam R memungkinkan untuk diciptakan sendiri.

Lalu apa itu Fungsi?

Fungsi adalah susunan kode untuk melakukan tugas tertentu, seperti perhitungan matematis, pembacaan data, analisis statistik, dan lainnya. Dengan kata lain fungsi adalah sekumpulan mekanisme dasar yang dijalankan secara simultan.

Struktur fungsi didalam R adalah:

myfunction <- function(arglist) {expr return(value)}

Katerangan:

  1. myfunction merupakan nama fungsi yang akan dibangun

  2. arglist (Argument list) adalah argumen fungsi yang merupakan input fungsi, dapat berupa nilai default, berulang atau tidak didefinisikan secara pasti. Argumen fungsi R dapat menerima nama fungsi R lain untuk dijalankan.

  3. expr (expression) merupakan badan fungsi yang berisi statement/pernyataan atau perintah.

  4. returnadalah perintah untuk mendefinisikan output fungsi tersebut. Output/luaran dari fungsi adalah berupa objek yang dapat secara langsung dituliskan objeknya atau menggunakan return(). Jika luarannya memiliki mode berbeda, umumnya digunakan objek list. contoh: return(), return(list()), list().

Untuk menggunakan fungsi yang telah dibuat dapat menggunakan syntax berikut: namefunction(arg1, arg2, ...)

Nama argumen tidak perlu dituliskan, kecuali urutan diabaikan

Contoh:

myfunction(10 ,20)

myfunction(arg2=2, arg1=5)

Fungsi Return Value Bentuk 1

angka_acak1 <- function(n,pw) {
              x=runif(n)
              y=runif(n)
              z=(x+y)^pw
              return(z)
              }
angka_acak1(10,2)
##  [1] 0.10715263 1.32825171 1.66362434 0.17134930 1.03227816 0.09026683
##  [7] 0.75744848 1.46685229 1.14677215 1.00370084

Fungsi yang terdapat 2 argumen yang didefinisikan yaitu n dan pw yang membangkitkan x dan y dari bilangan acak seragam (uniform) sebanyak n, juga membangkitkan z dimana \(z=(x+y)^{pw}\).

Sehingga fungsi tersebut mengeluarkan bilangan z sebanyak 10 bilangan sesuai dengan yang didefinisikan dimana n=10 dan pw=2

Return Value Bentuk 2

angka_acak2 <- function(n,pw) {
              x=runif(n)
              y=runif(n)
              z=(x+y)^pw
              return(list(x,y,z))
              }
angka_acak2(5,2)
## [[1]]
## [1] 0.8170418 0.5307710 0.7119084 0.2681422 0.5758018
## 
## [[2]]
## [1] 0.8152166 0.8351412 0.9444807 0.1364610 0.9691397
## 
## [[3]]
## [1] 2.6642673 1.8657162 2.7436248 0.1637038 2.3868442

Mirip dengan Fungsi bentuk 1 yang terdapat 2 argumen yang didefinisikan yaitu n dan pw yang membangkitkan x dan y dari bilangan acak seragam (uniform) sebanyak n, juga membangkitkan z dimana \(z=(x+y)^{pw}\).

Perbedaannya adalah fungsi tersebut mengeluarkan bilangan x, y, z sebanyak 5 bilangan dalam bentuk objek list() sesuai dengan yang didefinisikan dimana n=10 dan pw=2

Fungsi Return Value Bentuk 3

angka_acak3 <- function(n=15,pw=2){
              x=runif(n)
              y=runif(n)
              z=(x+y)^pw
              return(z)
              }
angka_acak3()
##  [1] 1.88954431 0.80398767 1.58665633 2.62850103 0.03688706 0.60778610
##  [7] 0.90021234 1.61238751 3.17135734 1.69677025 0.68888974 0.40697701
## [13] 1.96601287 0.73576448 1.46034031

Mirip dengan Fungsi bentuk 1 yang terdapat 2 argument yang telah diinisialisasi angkanya (default nilai) yaitu n=15 dan pw=2 yang nilai membangkitkan x dan y dari bilangan acak seragam (uniform) sebanyak n, juga membangkitkan z dimana \(z=(x+y)^{pw}\).

Sehingga fungsi tersebut untuk mengeluarkan output bilangan z sebanyak 15 bilangan, dalam pemanggilannya kita tidak perlu lagi mendefinisikan nilai n dan pw karena nilai n=15 dan pw=2 telah didefinisikan sebelumnya didalam argumen.

namun adanya inisialisasi argument tidak membatasi perubahan nilai argumen, kita tetap dapat mendefinisikan nilai inisialisasi argument lain saat pemanggilan fungsi.

angka_acak3(n=2)
## [1] 1.231075 1.290181
angka_acak3(n=2, pw=3)
## [1] 0.5781365 0.7224600

Fungsi Return Value Bentuk 4

angka_acak4 <- function(){
              x=runif(n)
              y=runif(n)
              z=(x+y)^pw
              return(z)
              }

n <- 7 #mendefinisikan nilai n diluar fungsi karena fungsi tidak memiliki argumen
pw <- 3 #mendefinisikan nilai pw diluar fungsi karena fungsi tidak memiliki argumen

angka_acak4()
## [1] 1.5903114 1.6026974 0.9689545 4.6229826 0.3427923 1.1562959 0.1968408

Fungsi bentuk diatas tidak memiliki argument, sehingga saat pemanggilan fungsi diharuskan untuk mendefinisikan terlebih dahulu variabel yang ada seperti n dan pw diluar fungsi (disebut: variabel global). Sedangkan variabel lokal adalah variabel yang didefinisikan didalam fungsi.

Untuk membuat nilai tidak berubah-ubah maka dapat menggunakan fungsi set.seed() sebelum pemanggilan fungsi.

set.seed(100)
angka_acak4()
## [1] 0.3117853 0.5201667 0.3772818 0.3163497 2.4642852 0.4461619 1.7754753

Fungsi MEDIAN suatu vektor

med <- function(vect) {
                n <- length(vect)
                vects <- sort(vect)
                if(n%%2 == 1) {m <- vects[(n+1)/2]}
                else {m <- (vects[n/2]+vects[(n/2)+1])/2}
                return(m)
                }
x1 <- c(1,5,3,7,3,4,2,7)
med(x1)
## [1] 3.5

Pada fungsi med mempunyai argumen yang merupakan suatuvect, dan memiliki ekspresi sebagai berikut:

  1. Mendefinisikan panjang vektor kedalam n

  2. Karena untuk mencari median suatu vektor harus diurutkan terlebih dahulu dan mendefinisikan kedalam objek vects

  3. Karena untuk mencari median memiliki 2 kondisi dimana:

  • jika n ganjil if(n%%2 == 1) {m <- vects[(n+1)/2]} jika n bernilai ganjil (modulo 2 bersisa 1) maka ubah n menjadi mdimana nilai m adalah vects ke- \((n+1)/2\)

  • jika n genap m <- (vects[n/2]+vects[(n/2)+1])/2 jika n bernilai genap maka ubah n menjadi mdimana nilai m adalah vects ke- \([n/2]\) ditambah vects ke- \((n/2)+1\) lalu dibagi dengan 2.

Kemudian output dari fungsi med di atas adalah nilai m (vects ke-m), dengan kata lain med(x1) mengeluarkan nilai median dari vektor x1

Pembuktian fungsi med

median(x1)
## [1] 3.5

Nilai median yang dikeluarkan oleh fungsi med sama dengan nilai median yang dikeluarkan oleh fungsi median yang telah tersedia dalam base R.

Fungsi MODUS suatu vektor

modus <- function(vect){
            v <- unique(vect)
            frekuensi <- NULL
            
            for(i in v){ #looping
            byk <- sum(vect==i) #memeriksa setiap i yang sama dari vect dan banyak i yang sama 
            frekuensi <- c(frekuensi,byk)
            }
            
            fmax <- max(frekuensi)
            vf <- cbind(nilai_modus=v,frekuensi)
            mode <- vf[frekuensi==fmax,]
            return(mode)
            }
modus(x1)
##      nilai_modus frekuensi
## [1,]           3         2
## [2,]           7         2

Pada fungsi modus mempunyai argumen yang merupakan suatuvect, dan memiliki ekspresi sebagai berikut:

  1. Mendefinisikan nilai vektor unique kedalam v

  2. Membuat objek kosong bernama frekuensi

  3. Melakukan looping dari i sampai sepanjang v, membuat objek byk dimana memeriksa setiap i dari v dan menghitung jumlah kemunculan i yang sama pada vect dan menyimpan byk kedalam vektor frekuensi.

  4. Kemudian mencari nilai maksimum dari frekuensi dan mesukkan kedalam objek fmax

  5. Kemudian menggabungkan v (diberi nama menjadi nilai_modus) dan frekuensi kedalam matriks vf.

  6. mode adalah nilai modus yang berisi matriks vf yang mempunyai nilai frekuensi maksimal.

Sehingga output dari fungsi modus adalah nilaimode yang berupa matriks vf dengan frekuensi maksimal

Dimana modus(x1) adalah matriks 2x2 karena memiliki 2 nilai modus yaitu 3 dan 7 dengan frekuensi masing-masing berjumlah 2.

Fungsi untuk Menduga Parameter pada Regresi Berganda

p.est<-function(A){ #FUnction dengan argument A
if(!is.matrix(A)) #screening dimana A harus berupa matriks 
stop("input must be on matrix") #jika tidak matriks maka fungsi akan mengeluarkan peringatan 'input must be on matrix' 
x1<-A[,-1] #memisahkan variabel x dan y dimana variabel x merupakan semua kolom matriks A kecuali kolom ke-1
y <-A[,1] #Mendefinisikan variabel y merupakan kolom ke-1 dari matriks A 

one<-rep(1,nrow(A)) #Membuat vektor yang isinya 1 semua sepanjang row dari matriks A
x <-cbind(one,x1) #menggabungkan vektor 'one' sebagai kolom 1 dengan matriks x1 (yang berisi variabel x) 
colnames(x)<-paste("x",1:ncol(x),sep="") #memberikan nama setiap kolom pada matriks x dari x1 hingga x(sebanyak kolom)

b.est<-as.vector(solve(t(x) %*% x) %*% (t(x) %*% y)) #menginput rumus B estimator (keterangan di pembahasan) 

names(b.est)<-paste("b",0:(length(b.est)-1),sep="") #Memberi nama pada matriks b.est dimulai dari b0 hingga sesuai dengan panjang dari b.est 
fitted.value<-as.vector(x%*%b.est) #Membuat suatu vektor bernama fitted.value (nilai dugaan/prediksi yang dihasilkan model) yang merupakan perkalian m atriks x dengan b.est
error<-as.vector(y-fitted.value) #Mendefinisikan nilai error dimana (y real - y dugaan)
names(fitted.value)<-names(error)<-1:nrow(A)
list(beta.est=b.est,fit.val=fitted.value,error=error) #mengeluarkan output fungsi yang berupa 3 list (selanjutnya di pembahasan)
}
  • b.est adalah objek yang mencari nilai dari \(\widehat{\beta }\) dari metode kuadrat terkecil, dimana mencari nilai estimator \(\widehat{\beta }\) dalam MKT seperti berikut:

\[\widehat{\beta }=({X}'X)^{-1}{X}'y\] t(x) adalah untuk mencari nilai \({X}'\) suatu matriks

solve adalah untuk mencari nilai invers dari suatu matriks

%*%adalah operator perkalian untuk matriks didalam R

  • fitted.valueobjek fitted.value pada fungsi diatas adalah objek untuk mengeluarkan y dugaan atau y prediksi dari model, dengan formula: \(X\widehat{\beta }\)

  • error adalah nama objek untuk mengeluarkan nilai error regresi didapatkan dengan mencari selisih y real dengan y duga

Output pada fungsi diatas adalah output data berupa list, yaitu beta.est yang berisi b.est, fit.val yang berisi nilai fitted.value, dan error.

Pendapatan<-c(3.5,3.2,3.0,2.9,4.0,2.5,2.3) #variabel tak bebas
Biaya.Iklan<-c(3.1,3.4,3.0,3.2,3.9,2.8,2.2) #variabel bebas 
Jumlah.Warung<-c(30,25,20,30,40,25,30) #variabel bebas
X<-cbind(Pendapatan,Biaya.Iklan,Jumlah.Warung)
X
##      Pendapatan Biaya.Iklan Jumlah.Warung
## [1,]        3.5         3.1            30
## [2,]        3.2         3.4            25
## [3,]        3.0         3.0            20
## [4,]        2.9         3.2            30
## [5,]        4.0         3.9            40
## [6,]        2.5         2.8            25
## [7,]        2.3         2.2            30

Menggabungkan ketiga variabel kedalam 1 matriks 7x3. Dimana variabel tak bebas berada dikolom pertama dan variabel bebas berada dikolom kedua dan ketiga, masing-masing variabel terdapat 7 observasi.

p.est(X)
## $beta.est
##          b0          b1          b2 
## -0.21381852  0.89843390  0.01745279 
## 
## $fit.val
##        1        2        3        4        5        6        7 
## 3.094910 3.277176 2.830539 3.184754 3.988185 2.738116 2.286320 
## 
## $error
##           1           2           3           4           5           6 
##  0.40508982 -0.07717642  0.16946108 -0.28475357  0.01181483 -0.23811608 
##           7 
##  0.01368033

Pembuktian fungsi p.est dibandingkan dengan fungsi lm yang ada di R

model<-lm(Pendapatan~Biaya.Iklan+Jumlah.Warung)
model$coefficients
##   (Intercept)   Biaya.Iklan Jumlah.Warung 
##   -0.21381852    0.89843390    0.01745279

Nilai coefficients dari fungsi lm sama dengan nilai beta.est dari fungsi p.est

model$fitted.values
##        1        2        3        4        5        6        7 
## 3.094910 3.277176 2.830539 3.184754 3.988185 2.738116 2.286320

Nilai fitted.values dari fungsi lm sama dengan nilai fit.val dari fungsi p.est

model$residuals
##           1           2           3           4           5           6 
##  0.40508982 -0.07717642  0.16946108 -0.28475357  0.01181483 -0.23811608 
##           7 
##  0.01368033

Nilai residuals dari fungsi lm sama dengan nilai error dari fungsi p.est

Kekurangan fungsi p.est yang telah dibangun, berdasarkan yang telah dijabarkan sebelumnya:

  • Data input harus berupa matriks, tidak berlaku untuk data frame dan lainnya, sehingga harus engubah class data dari data.frame menjadi matriks terlebih dahulu

  • Variabel tak bebas harus berada di kolom ke-1 dari matriks data input.

Membuat fungsi bernama three.M yang digunakan untuk menghitung mean, median, dan modus dari suatu vektor modus (tanpa menggunakan fungsi mean, quantile, ataupun fungsi “instan” lain yang sudah tersedia sebelumnya di R)

• Hitung mean, median, modus dari X dibawah ini dengan menggunakan fungsi three.M tersebut!

Data bangkitan bilangan acak binomial sebanyak 100 dengan n=10, dan p=0.5.

set.seed(123)
bin <- rbinom(15,10,0.5)
bin
##  [1] 4 6 5 7 7 2 5 7 5 5 8 5 6 5 3
three.M<-function(B){

            panjang <- length(B)

            mean1<-sum(B)/panjang

            Bsort <- sort(B)
                if(panjang%%2 == 1) {m <- Bsort[(panjang+1)/2]}
                else {m <- (Bsort[panjang/2]+Bsort[(panjang/2)+1])/2}
                
          most <- as.numeric(names(sort(-table(B)))[1])

list(nilai_mean=mean1,nilai_median=m, nilai_modus=most)
}

Function three.M merupakan sebuah fungsi yang dibangun untuk mencari nilai Mean, Median, dan Modus dari suatu vektor (B).

Cara kerjanya:

  • Mencari panjang vektor B yang diletakkan dalam objek panjang

  • Membuat objek untuk menghitung nilai mean dan diletakkan dalam objek mean1 yang berisi jumlah vektor B dibagi dengan panjang

  • Membuat objek untuk menghitung nilai median sama seperti fungsi median med yang telah kita buat sebelumnya.

  • Membuat objek most untuk mencari nilai modus, most adalah function alternatif yang lebih ringkas untuk mencari nilai modus selain dengan fungsi modus yang telah dibangun sebelumnya. most bekerja dengan cara membuat tabel yang berisi data dan frekuensi dari vektor B kemudian mengurutkan data dengan cara memberi minus pada frekuensi masing-masing data, untuk mengakali agar data dengan frekuensi terbesar berada di urutan pertama, sehingga kita mengekstrak names tabel vektor pertama yang tidak lain merupakan data asli dengan frekuensi terbesar (nilai modus) dan mengubah class data menjadi numeric.

Kemudian output dari fungsi Three.M tersebut berupa list yang terdiri dari nilai_mean, nilai_median, dan nilai_modus.

three.M(bin)
## $nilai_mean
## [1] 5.333333
## 
## $nilai_median
## [1] 5
## 
## $nilai_modus
## [1] 5

Pembuktian

mean(bin)
## [1] 5.333333
median(bin)
## [1] 5
modus(bin)
## nilai_modus   frekuensi 
##           5           6

Pemrograman Berbasis Objek

Pemrograman Berbasis Objek atau Objek Oriented Programming (OOP) adalah sebuah paradigma dalam pembuatan sebuah program. Pemrograman Berbasis Objek menitikberatkan pada identifikasi objek-objek yang terlibat dalam sebuah program dan bagaimana objek-objek tersebut berinteraksi.

Pada Pemrograman Berbasis Objek, program yang dibangun akan dibagi-bagi menjadi objek-objek.

Dalam Pemrograman Berbasis Objek memiliki 2 istilah penting Class adalah nama atau kategori dari suatu objek yang memiliki sifat, atribut, dan hubungan terhadap class yang lain.

Method menyatakan perilaku/behavior tiap class yang dapat dituliskan programnya.

Analogi:

Misalkan dipunyai objek yang bernama car/mobil. Memiliki class yang dapat berupa: teknologi penemuan manusia, kendaraan, atau kendaraan roda 4 (secara hierarki: bersifat umum ke khusus).

Dan mobil tersebut (objek) memiliki method yang berupa pengisian bahan bakar refuel(), berjalan getDrive(), pengaturan kecepatan setSpeed() , dan sebagainya.

A1 <- c(1:10) #membangun sebuah vektor A1 yang terdiri dari 1 hingga 10
class(A1) #vektor A1 mempunyai kelas integer
## [1] "integer"
A2 <- matrix(A1,2,5) #membangumbangun matrik dengan vektor A1 ukuran 2x5
class(A2) #melihat kelas matrik A2
## [1] "matrix" "array"

Class A2 yaitu matrix dan array, kelas matriks tidak lain adalah array 2 dimensi.

(A3 <- 1:12) #membangun sebuah vektor A3 yang terdiri dari 1 hingga 12
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12
(A4 <- letters[1:12]) #membangun sebuah vektor A4 yang terdiri dari huruf alfabet (kecil) dari a hingga l
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l"
(B1 <- data.frame(A3,A4)) #menggabungkan vektor A3 dan A4 menjadi 1 data frame
##    A3 A4
## 1   1  a
## 2   2  b
## 3   3  c
## 4   4  d
## 5   5  e
## 6   6  f
## 7   7  g
## 8   8  h
## 9   9  i
## 10 10  j
## 11 11  k
## 12 12  l
class(B1) #mengecek class dari objek B1 == "data.frame"
## [1] "data.frame"
B1$A4 #mengakses kolom A4 dari data frame B1
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l"

Object – S3

set.seed(100)
(normal <- rnorm(12)) #membangkitkan 12 dat berdistribusi normal baku
##  [1] -0.50219235  0.13153117 -0.07891709  0.88678481  0.11697127  0.31863009
##  [7] -0.58179068  0.71453271 -0.82525943 -0.35986213  0.08988614  0.09627446
(A5 <- 10+A3+normal) #membangun vektor A5 yang berisikan penjumlahan 10+A3+normal pada setiap elemen vektor
##  [1] 10.49781 12.13153 12.92108 14.88678 15.11697 16.31863 16.41821 18.71453
##  [9] 18.17474 19.64014 21.08989 22.09627
B2 <- lm(A5~A3) #membuat model regresi linear denga variabel bebas adalah A3 dan variabel tak bebas adalah A5
class(B2) #melihat class dari objek B2 == "lm"
## [1] "lm"
methods(class=class(B2)) #mengeluarkan daftar 39 metode yang tersedia dan dapat dipanggil dari function `lm`
##  [1] add1           alias          anova          case.names     coerce        
##  [6] confint        cooks.distance deviance       dfbeta         dfbetas       
## [11] drop1          dummy.coef     effects        extractAIC     family        
## [16] formula        hatvalues      influence      initialize     kappa         
## [21] labels         logLik         model.frame    model.matrix   nobs          
## [26] plot           predict        print          proj           qr            
## [31] residuals      rstandard      rstudent       show           simulate      
## [36] slotsFromS3    summary        variable.names vcov          
## see '?methods' for accessing help and source code
summary(B2) #contoh penggunaaan method summary pada B2
## 
## Call:
## lm(formula = A5 ~ A3)
## 
## Residuals:
##      Min       1Q   Median       3Q      Max 
## -0.79586 -0.38102  0.08776  0.19923  0.85629 
## 
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept) 10.07842    0.32763   30.76 3.09e-11 ***
## A3           0.98802    0.04452   22.20 7.74e-10 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 0.5323 on 10 degrees of freedom
## Multiple R-squared:  0.9801, Adjusted R-squared:  0.9781 
## F-statistic: 492.6 on 1 and 10 DF,  p-value: 7.737e-10

Method summary mengeluarkan nilai regresi dari B2 berupa nilai residuals, coefficients, dan lain-lain.

plot(B2) #contoh penggunaaan function plot pada B2

Function plot(B2) berfungsi untuk mengeluarkan plot residual dari model OLS Regression dari B2

names(B2) #melihat names apa saja yang tersedia dari objek B2 yang dibangun dari function `lm`
##  [1] "coefficients"  "residuals"     "effects"       "rank"         
##  [5] "fitted.values" "assign"        "qr"            "df.residual"  
##  [9] "xlevels"       "call"          "terms"         "model"
B2$coefficients
## (Intercept)          A3 
##  10.0784182   0.9880201

Karena function lm pada dasarnya berbentuk list maka untuk mengakses names yang tersedia bisa menggunakan tanda simbol $

Mengubah menjadi Class

class(obj) <- "class.name"

Membuat class dan objek di R

Mobil1 <- list(Nama="Toyota", Panjang=3.5,Lebar=2, Kecepatan=180) #menggunakan `list`
Mobil1
## $Nama
## [1] "Toyota"
## 
## $Panjang
## [1] 3.5
## 
## $Lebar
## [1] 2
## 
## $Kecepatan
## [1] 180
class(Mobil1) #mengecek class mobil == "list"
## [1] "list"
class(Mobil1) <- "mobil" #Mengubah class dari objek Mobil1 menjadi "mobil"
class(Mobil1)
## [1] "mobil"
Mobil2 <- list(Nama="Suzuki", Panjang=1, Lebar=1.8, Kecepatan=150) #Membut objek Mobil2 dalam bentuk list
Mobil2
## $Nama
## [1] "Suzuki"
## 
## $Panjang
## [1] 1
## 
## $Lebar
## [1] 1.8
## 
## $Kecepatan
## [1] 150
class(Mobil2) <- "mobil" #Mengubah class dari objek Mobil2 menjadi "mobil"
class(Mobil2)
## [1] "mobil"

Fungsi Konstruktor

Fungsi Konstruktor salah satu cara untuk mengubah Class

• Lebih direkomendasikan menggunakan fungsi konstruktor

• Fungsi konstruktor menambahkan screening sebelum menambahkan class

Mobil <- function(Nama,Panjang,Lebar,Kecepatan){ 
          if(Panjang<2 || Lebar<1.5 || Kecepatan<80) #bagian screening
          stop("atribut tidak sesuai")
          Mobil <- list(Nama=Nama, Panjang=Panjang,
          Lebar=Lebar, Kecepatan=Kecepatan)
          class(Mobil) <- "mobil"
          Mobil
          }

Function Mobil yang terdapat 4 argumen yaitu Nama, Panjang, Lebar, dan Kecepatan.

Pada bagian screening, berfungsi untuk menyeleksi objek apabila panjang kurang dari 2, atau lebar kurang dari 1.5, atau Kecepatan kurang dari 80 maka bukan mobil. Sehingga akan mengeluarkan pernyataan “atribut tidak sesuai”.

Mendefinisikan Mobil dengan class list (Nama=Nama, Panjang=Panjang,Lebar=Lebar, Kecepatan=Kecepatan).

Mengubah class mobil yang tadinya list menjadi “mobil”, sama seperti function lm tadinya berupa class list yang diubah menjadi class lm.

Mobil3 <- Mobil("Daihatsu", 2.1, 1.9, 120)
Mobil3
## $Nama
## [1] "Daihatsu"
## 
## $Panjang
## [1] 2.1
## 
## $Lebar
## [1] 1.9
## 
## $Kecepatan
## [1] 120
## 
## attr(,"class")
## [1] "mobil"

Membuat objek Mobil3 dengan function Mobil yang telah dibangun sebelumnya dengan mendefinisikan Nama=“Daihatsu” dengan panjang 2.1, lebar 1.9 dan Kecepatan=120.

class(Mobil3)
## [1] "mobil"
#Mobil4 <- Mobil("Proton", 2, 1.8, 70)

Objek Mobil4 akan mengeluarkan pesan error “Error in Mobil(”Proton”, 2, 1.8, 70) : atribut tidak sesuai” karena kecepatan kurang dari 80. Tidak memenuhi kriteria function Mobil yang dibangun.

Fungsi Aksesor

nama <- function(objek) objek$Nama #memisahkan setiap parameter menjadi sebuah fungsi, fungsi `nama` digunakan hanya untuk melihat parameter nama dari objek menggunakan simbol $
kecepatan <- function(objek) objek$Kecepatan #fungsi `kecepatan` digunakan hanya untuk melihat parameter kecepatan dari objek
nama(Mobil3)
## [1] "Daihatsu"
kecepatan(Mobil3)
## [1] 120

Fungsi Generik

Print Method function(...){...}

Menciptakan Fungsi Generik

• Method hanya dapat didefinisikan untuk fungsi yang generik

• Membuat nama method baru dengan menciptakan fungsi generik

fungsibaru <- function (objek) UseMethod("fungsibaru")

print.mobil <- function(objek) {
          print(cat("Nama : ", nama(objek), "\n", #mendefinisikan Nama merupakan nama dari objek
          "Kecepatan : ", kecepatan(objek), #mendefinisikan Kecepa merupakan nama dari objek
          sep="")
          )
          }
print.mobil(Mobil3)
## Nama : Daihatsu
## Kecepatan : 120NULL

Object – S4

• Dapat mengatasi masalah dalam sistem objek S3 dengan sistem objek lebih formal

• Mendefinisikan class baru :

setClass("class.name", representation(x="type"), prototype(x="..."))

• Medefinisikan objek baru dari kelas tertentu : new(class.name,…)

Membuat Object S4

setClass("car",representation(Nama="character", #membuat class baru dalam s4 menggunakan `setClass`dan mendefinisikan atribut Nama berupa character
          Panjang="numeric", #mendefinisikan atribut Panjang berupa numeric
          Lebar="numeric",  #mendefinisikan atribut Lebar berupa numeric
          Kecepatan="numeric"))  #mendefinisikan atribut Kecepatan berupa numeric

Car1 <- new("car", Nama="Toyota", #sedangkan untuk membuat objek baru dengan function `new`
          Panjang=3.5, Lebar=2,
          Kecepatan=180)
Car1
## An object of class "car"
## Slot "Nama":
## [1] "Toyota"
## 
## Slot "Panjang":
## [1] 3.5
## 
## Slot "Lebar":
## [1] 2
## 
## Slot "Kecepatan":
## [1] 180

Membuat Object S4 (Menggunakan Fungsi Konstruktor)

Car <- function(Nama,Panjang,Lebar,Kecepatan){
          if(Panjang<2 || Lebar<1.5 || Kecepatan<80)
          stop("atribut tidak sesuai") 
          new("car", Nama=Nama, Panjang=Panjang,
          Lebar=Lebar, Kecepatan=Kecepatan)
          }

Function Car yang terdapat 4 argumen yaitu Nama, Panjang, Lebar, dan Kecepatan.

Pada bagian screening, berfungsi untuk menyeleksi objek apabila panjang kurang dari 2, atau lebar kurang adari 1.5, atau Kecepatan kurang dari 80 maka bukan mobil. Sehingga akan mengeluarkan pernyataan “atribut tidak sesuai”

Mendefinisikan objek class baru dengan function new

Car2 <- Car("Suzuki", 2.4, 1.8, 150)
Car2
## An object of class "car"
## Slot "Nama":
## [1] "Suzuki"
## 
## Slot "Panjang":
## [1] 2.4
## 
## Slot "Lebar":
## [1] 1.8
## 
## Slot "Kecepatan":
## [1] 150
class(Car2)[] #memanggil class object S4
## [1] "car"
## attr(,"package")
## [1] ".GlobalEnv"
class(Mobil1)
## [1] "mobil"

Dapat dilihat perbedaan dalam menampilkan class pada object S3 dan S4, pada object S4 class yang ditampilkan beserta nama attribute package Global Environment, sedangkan object S3 hanya menampilkan nama class saja.

Akses terhadap Slot

•Cara langsung (tidak direkomendasikan)

nama1 <- function(objek) objek@Nama #fungsi `nama1` digunakan hanya untuk melihat nama dari objek, jika s3 menggunakan simbol $ dalam s4 menggunakan simbol @
kecepatan1 <- function(objek) objek@Kecepatan #fungsi `kecepatan1` digunakan hanya untuk melihat kecepatan dari objek
nama1(Car1)
## [1] "Toyota"
kecepatan1(Car2)
## [1] 150

Class Method

setMethod("method","class.name",function(...){...})

setMethod(show, "car", function(object) { #membangun method bernama show
          print(cat("Nama : ", nama1(object), "\n",
          "Kecepatan : ", kecepatan1(object),
          sep="")
          )}
          )
Car2
## Nama : Suzuki
## Kecepatan : 150NULL
show(Car2)
## Nama : Suzuki
## Kecepatan : 150NULL

Menciptakan Fungsi Generik S4

setGeneric("fungsibaru", #membangun function Generik bernama 'fungsibaru' dengan funtion `setGeneric`
          function(objek) 
          standardGeneric("fungsibaru"))
## [1] "fungsibaru"

Output di atas untuk membangun function Generik baru bernama ‘fungsibaru’ dengan function setGeneric

Optimasi

Optimisasi ialah suatu proses untuk mencapai hasil yang ideal atau optimal (nilai efektif yang dapat dicapai). Dalam disiplin matematika optimisasi merujuk pada studi permasalahan yang mencoba untuk mencari nilai minimal atau maximal dari suatu fungsi riil.

Mencari hasil integral tak tentu menggunakan fungsi yac_str dari package Ryacas

\[∫x^2+4 dx\]

library(Ryacas)
yac_str("Integrate(x) x^2 + 4*x") #mencari penyelesaian integral dari fungsi diatas
## [1] "x^3/3+2*x^2"

Dapat dilihat bahwa benar hasil dari integral tak tentu \[∫x^2+4 dx = \frac{1}{3}(x^3)+2x^2\]

Mencari hasil integral tentu berikut menggunakan fungsi integrate

\[∫_{-10}^{10}x^2+4 dx\]

f1 <- function(x) x^2 + 4*x #mendefinisikan f1 dengan fungsi studi kasus
integrate(f1,lower = -10,upper = 10) #mencari penyelesaian dari fungsi f1 yang sudah didefinisikan dengan batas bawah -10 dan batas atas 10
## 666.6667 with absolute error < 7.6e-12

Hasil menunjukkan nilai yang sama jika menggunakan manual yaitu:

\[(\frac{1}{3}(10^3)+2(10)^2)-(\frac{1}{3}(-10^3)+2(-10)^2)\]

\[=533.3333-(-133.3333)\]

\[=666.6667\]

Mencari hasil integral tak tentu menggunakan fungsi yac_str dari package Ryacas

\[∫t^4 e^{-t} dt\]

yac_str("Integrate(t) t^4 * Exp(-t)") #mencari penyelesaian integral dari fungsi diatas
## [1] "4*(3*((-2)*(t+1)*Exp(-t)-t^2*Exp(-t))-t^3*Exp(-t))-t^4*Exp(-t)"

Mencari hasil integral tentu menggunakan fungsi integrate, bandingkan hasilnya dengan menghitung Γ(5) dengan menggunakan fungsi gamma

\[∫_{0}^{∞}t^4 e^{-t} dt\]

f2 <- function(t) t^(4) * exp(-t) #mendefinisikan fungsi seperti studi kasus
integrate(f2,lower = 0,upper = Inf) #mencari nia=lai inegral dari f2 dengan batas bawal 0 dan batas atas positive infinity
## 24 with absolute error < 2.2e-05
gamma(5) #mencari nilai dari gamma 5
## [1] 24

Hasil dengan menghitung integral dari fungsi \(∫_{0}^{∞}t^4 e^{-t} dt\) sama dengan hasil dari nilai \(Γ(5)\), dimana fungsi gamma (\(Γ(z)\)) adalah sebagai berikut:

\[∫_{0}^{∞}t^{z-1} e^{-t} dt\]

Sehingga fungsi untuk \(Γ(5)\) adalah

\[∫_{0}^{∞}t^{5-1} e^{-t} dt\]

Mencari titik minimum dari suatu fungsi

Mencari titik minimum dari fungsi berikut: \(f(x)=4x^4-2x^3-3x\)

f3 <- function(x) 4*x^4-2*x^3-3*x # membangun sebuah fungsi f(x)=4x^4-2x^3-3x
x3 <- seq(-1,1.5,by=.1) #membangun nilai x dari -1 hingga 1.5
x3
##  [1] -1.0 -0.9 -0.8 -0.7 -0.6 -0.5 -0.4 -0.3 -0.2 -0.1  0.0  0.1  0.2  0.3  0.4
## [16]  0.5  0.6  0.7  0.8  0.9  1.0  1.1  1.2  1.3  1.4  1.5
plot(x3,f3(x3),type="l", main = "Plot ") #membangun plot x3 dan f3 dari nilai x3
arrows(x0=0.90,y0=0,x1=0.75,y1=-1.70,lwd=2)
text(x=0.88,y=0.9,labels="Titik optimum (-1.83)",cex=0.7) 

optim(par=c(-0.5), fn=f3)
## Warning in optim(par = c(-0.5), fn = f3): one-dimensional optimization by Nelder-Mead is unreliable:
## use "Brent" or optimize() directly
## $par
## [1] 0.728418
## 
## $value
## [1] -1.832126
## 
## $counts
## function gradient 
##       36       NA 
## 
## $convergence
## [1] 0
## 
## $message
## NULL

$par merupakan nilai parameter duga dari x.

$value merupakan nilai optimum dari fungsi f3 nya dengan kata lain nilai titik terendah (optimum) pada plot.

$count menampilkan bahwa untuk melakukan proses optimasi terdapat 36 iterasi, gradien NA dikarenakan garis yang dibentuk bukan garis lurus.

$convergence=0 menunjukkan dalam fungsi f3 terdapat nilai optimal, yitu sebesar -1.832126. Namun jika convergence =1 atau -1, artinya fungsi tersebut tidak memiliki nilai optimumnya, atau bisa jadi jumlah iterasi perlu ditambahkan.

HAFIZAH ILMA (Statistician)