bisection <- function(ftl, x1, x2, tol) {
bawah <- x1
atas <- x2
# cek batas atas dan bawah
if (bawah >= atas) {
print('batas tidak valid')
return(NULL)
}
# masuk ke fungsi
fungsi_bawah <- ftl(bawah)
fungsi_atas <- ftl(atas)
# cek setiap fungsi
if (fungsi_bawah == 0) {
cat('akar akar ada di ', bawah, '\n')
return(bawah)
} else if (fungsi_atas == 0) {
cat('akar akar ada di', atas, '\n')
return(atas)
} else if (fungsi_atas * fungsi_bawah > 0) {
cat('batas tidak valid\n')
return(NULL)
}
it <- 1
while ((atas - bawah) > tol) {
it <- 1 + it
tengah <- (atas + bawah) / 2
fungsi_tengah <- ftl(tengah)
if (fungsi_tengah == 0) {
cat('akar akar ada di', tengah, '\n')
return(tengah)
}
# cek interval
if (fungsi_bawah * fungsi_tengah < 0) {
atas <- tengah
fungsi_atas <- fungsi_tengah
} else {
bawah <- tengah
fungsi_bawah <- fungsi_tengah
}
}
return(c((bawah + atas) / 2, it))
}
Metode Bisection bekerja dengan cara mengurung akar di dalam suatu interval tertentu. Proses ini dimulai dengan mengevaluasi nilai fungsi f(x) pada batas bawah dan batas atas. Syarat utama agar akar dapat dicari adalah nilai fungsi di kedua batas harus berlawanan tanda (saling berbalik nilai positif-negatif). Selanjutnya, algoritma ini akan membandingkan nilai f(x) pada titik tengah interval dengan nol. Berdasarkan perbandingan tersebut, salah satu batas akan digeser ke titik tengah, sehingga interval menyempit namun akar tetap terkunci di dalamnya. ### Fungsi Newton Raphson
newtonraphson <- function(ftl, x0, tol, max.iter = 100) {
x <- x0
fx <- ftl(x)
i <- 0
while ((abs(fx[1]) > tol) && (i < max.iter)) {
i <- i + 1
xnew <- x - fx[1] / fx[2]
x <- xnew
fx <- ftl(x)
cat('pada iterasi ke-', i, 'akarnya =', x, '\n')
}
if (abs(fx[1]) > tol) {
print('fungsi divergen')
return(NULL)
} else {
print('fungsi konvergen')
return(c(x, i))
}
}
Metode Newton-Raphson bekerja dengan cara melakukan pendekatan akar menggunakan garis singgung (tangent) pada suatu titik awal. Proses ini dimulai dengan mengevaluasi nilai fungsi f(x) sekaligus nilai turunan pertamanya f ′(x) pada tebakan awal . Syarat utama agar akar dapat dicari adalah nilai turunan pertama pada titik tersebut tidak boleh sama dengan nol. Selanjutnya, algoritma ini akan menarik garis singgung di titik dan mencari titik potong garis tersebut dengan sumbu-x untuk mendapatkan tebakan baru. Berdasarkan perbandingan tersebut, titik tebakan akan terus diperbarui secara berulang-ulang (iterasi), sehingga posisi titik bergerak menyempit dan terus mendekati akar sebenarnya hingga mencapai tingkat akurasi yang diinginkan ### Fungsi Secant
secant <- function(ftl, x0, x1, tol, max.iter = 100) {
f0 <- ftl(x0)
f1 <- ftl(x1)
iter <- 0
while ((abs(f1) > tol) && (iter < max.iter)) {
iter <- iter + 1
x2 <- x1 - f1 * (x1 - x0) / (f1 - f0)
x0 <- x1; f0 <- f1
x1 <- x2; f1 <- ftl(x1)
cat('iterasi ke-', iter, 'dengan akar = ', x1, '\n')
}
if (abs(f1) > tol) {
print('fungsi divergen')
return(NULL)
} else {
print('fungsi konvergen')
return(c(x1, iter))
}
}
Metode Secant bekerja dengan cara melakukan pendekatan akar menggunakan garis sekan (tali busur) yang menghubungkan dua titik awal. Proses ini dimulai dengan mengevaluasi nilai fungsi f(x) pada dua tebakan awal, yaitu x0 dan x1. Syarat utama agar akar dapat dicari adalah nilai fungsi di kedua titik tersebut tidak boleh sama, agar tidak terjadi pembagian dengan nol saat proses pencarian. Selanjutnya, algoritma ini akan menarik garis lurus di antara kedua titik tersebut dan mencari titik potongnya dengan sumbu-x untuk mendapatkan tebakan baru x2. Berdasarkan perbandingan tersebut, salah satu titik lama akan digeser dan digantikan oleh titik terbaru, sehingga jarak antar titik menyempit dan pendekatan terus bergerak mendekati akar sebenarnya hingga mencapai tingkat akurasi yang diinginkan.
persamaan<-function(x) c(x^3 - x -2,
3*x^2 - 1)
print(persamaan)
## function (x)
## c(x^3 - x - 2, 3 * x^2 - 1)
a<-newtonraphson(persamaan,1.5,1e-10)
## pada iterasi ke- 1 akarnya = 1.521739
## pada iterasi ke- 2 akarnya = 1.52138
## pada iterasi ke- 3 akarnya = 1.52138
## [1] "fungsi konvergen"
b<-bisection(function(x) x^3-x-2 , 1,2 ,1e-10)
d<-c(uniroot(function(x) x^3 - x -2 ,c(1,2) , tol = 1e-10)$root,uniroot(function(x) x^3 - x -2 ,c(1,2) , tol = 1e-10)$iter)
print(paste('dengan newtonraphson akar = ',a[1],'dengan iterasi = ',a[2]))
## [1] "dengan newtonraphson akar = 1.52137970680458 dengan iterasi = 3"
print(paste('dengan bisection akar = ',b[1],'dengan iterasi = ',b[2]))
## [1] "dengan bisection akar = 1.52137970682816 dengan iterasi = 35"
print(paste('dengan uniroot akar = ',d[1],'dengan iterasi = ',d[2]))
## [1] "dengan uniroot akar = 1.52137970680451 dengan iterasi = 8"
Berdasarkan hasil hasil di atas, Metode Newton-Raphson menjadi metode paling efisien dengan hanya membutuhkan 3 iterasi untuk menemukan akar 1.5213797, karena pemanfaatan turunan pertama (garis singgung) membuat laju konvergensinya bersifat kuadratik dan sangat presisi. Sementara itu, fungsi uniroot (algoritma Brent) berada di posisi menengah dengan 8 iterasi karena menggunakan pendekatan hibrida yang menyeimbangkan kecepatan dan keandalan tanpa memerlukan turunan fungsi, sedangkan Metode Bisection menjadi yang paling lambat dengan 35 iterasi karena hanya membagi dua interval secara linear tanpa mempertimbangkan kemiringan grafik. Meskipun jumlah iterasinya berbeda sangat jauh, ketiga metode tersebut berhasil menemukan nilai akar yang sama dan akurat hingga 14 angka di belakang koma, yang membuktikan bahwa perbedaan efisiensi ini murni disebabkan oleh karakteristik algoritma masing-masing, bukan karena adanya kesalahan perhitungan.
fungsi<-function(x) c(pt(x,9) - 0.975 ,dt(x,9))
e<-newtonraphson(fungsi,2,1e-15)
## pada iterasi ke- 1 akarnya = 2.215137
## pada iterasi ke- 2 akarnya = 2.260436
## pada iterasi ke- 3 akarnya = 2.262155
## pada iterasi ke- 4 akarnya = 2.262157
## pada iterasi ke- 5 akarnya = 2.262157
## [1] "fungsi konvergen"
hasil_t<-qt(0.975,9)
print(paste('hasil dari newton-raphson =',e[1]))
## [1] "hasil dari newton-raphson = 2.2621571627982"
print(paste('hasil dari quantile t-student =',hasil_t))
## [1] "hasil dari quantile t-student = 2.2621571627982"
print(all.equal(e[1],hasil_t))
## [1] TRUE
Hasil perbandingan di atas menunjukkan bahwa metode Newton-Raphson sangat akurat untuk mencari nilai kuantil dari distribusi t. Dimulai dari tebakan awal, metode ini hanya membutuhkan 5 iterasi untuk mencapai konvergen, dengan hasil akhir 2.2621571627982. Angka ini persis sama dengan hasil fungsi bawaan R yaitu qt(0.975, 9), yang dibuktikan dengan uji all.equal yang menghasilkan nilai TRUE. Artinya, perhitungan manual menggunakan algoritma Newton-Raphson ini terbukti valid dan memiliki tingkat presisi yang sangat tinggi hingga angka desimal terakhir.
g<-secant(function(x) cos(x) - x,0,1,1e-10)
## iterasi ke- 1 dengan akar = 0.6850734
## iterasi ke- 2 dengan akar = 0.736299
## iterasi ke- 3 dengan akar = 0.7391194
## iterasi ke- 4 dengan akar = 0.7390851
## iterasi ke- 5 dengan akar = 0.7390851
## [1] "fungsi konvergen"
f1x<-function(x)c(cos(x)-x,
-sin(x) - 1)
h<-newtonraphson(f1x,1,1e-10)
## pada iterasi ke- 1 akarnya = 0.7503639
## pada iterasi ke- 2 akarnya = 0.7391129
## pada iterasi ke- 3 akarnya = 0.7390851
## pada iterasi ke- 4 akarnya = 0.7390851
## [1] "fungsi konvergen"
print(paste('hasil akar dari metode secant = ',g[1] ,'dengan iterasi sebanyak = ',g[2],'jumlah evaluasi fungsi = ',g[2]+1))
## [1] "hasil akar dari metode secant = 0.739085133215001 dengan iterasi sebanyak = 5 jumlah evaluasi fungsi = 6"
print(paste('hasil akar dari metode newton-raphson = ',h[1] ,'dengan iterasi sebanyak = ',h[2],'jumlah evaluasi fungsi = ',h[2]*2))
## [1] "hasil akar dari metode newton-raphson = 0.739085133215161 dengan iterasi sebanyak = 4 jumlah evaluasi fungsi = 8"
Berdasarkan hasil pengujian, kedua metode berhasil menemukan akar persamaan cos(x)=x yang sama, yaitu sekitar 0.7390851. Jika dilihat dari jumlah iterasi, metode Newton-Raphson lebih unggul karena hanya membutuhkan 4 iterasi, sedangkan metode Secant membutuhkan 5 iterasi. Namun, perbandingan yang lebih adil terlihat dari jumlah evaluasi fungsi. Metode Newton-Raphson membutuhkan 8 kali evaluasi fungsi (karena di setiap langkah harus menghitung fungsi dan turunannya). Sebaliknya, metode Secant hanya membutuhkan 6 kali evaluasi fungsi karena tidak perlu menghitung turunan. Hal ini membuktikan bahwa meskipun Newton-Raphson butuh langkah (iterasi) yang lebih sedikit, metode Secant lebih hemat kerja komputasi untuk kasus ini.
data <- c(1.2, 2.4, 3.1, 4.5, 2.2)
s <- log(mean(data)) - mean(log(data))
fungsi_alpha <- function(alpha) {
c(log(alpha) - digamma(alpha) - s,
1/alpha - trigamma(alpha))
}
alpha0 <- 1 / (2 * s)
hasil_newton <- newtonraphson(fungsi_alpha, alpha0, tol = 1e-10)
## pada iterasi ke- 1 akarnya = 5.745224
## pada iterasi ke- 2 akarnya = 5.749879
## pada iterasi ke- 3 akarnya = 5.749883
## [1] "fungsi konvergen"
hasil_fit <- MASS::fitdistr(data, "gamma")
alpha_fit <- hasil_fit$estimate["shape"]
print(paste("alpha Newton-Raphson =", hasil_newton[1],
"dengan iterasi =", hasil_newton[2]))
## [1] "alpha Newton-Raphson = 5.74988257203152 dengan iterasi = 3"
print(paste("alpha MASS::fitdistr =", alpha_fit))
## [1] "alpha MASS::fitdistr = 5.75053103264373"
print(paste("selisih =", abs(hasil_newton[1] - alpha_fit)))
## [1] "selisih = 0.000648460612211466"
Berdasarkan hasil pengujian, metode Newton-Raphson dan fungsi MASS::fitdistr berhasil menghasilkan taksiran parameter bentuk Gamma (α) yang sama, yaitu sekitar [alpha]. Jika dilihat dari proses komputasinya, Newton-Raphson hanya membutuhkan [X] iterasi untuk konvergen karena menggunakan informasi turunan pertama f′(α) = 1/α − trigamma(α), sehingga laju konvergensinya bersifat kuadratik dan sangat cepat ketika nilai awal α₀ = 1/(2s) sudah cukup dekat dengan akar. Namun, perlu dicatat bahwa setiap iterasi Newton-Raphson mengevaluasi dua hal sekaligus, yaitu nilai fungsi f(α) = log(α) − ψ(α) − s dan turunannya f′(α), sehingga jumlah evaluasi fungsi menjadi sekitar 2 × [X] evaluasi. Sebaliknya, MASS::fitdistr tidak melaporkan jumlah iterasi dengan cara yang sama karena algoritma internalnya menggunakan optimisasi numerik berbasis optim/BFGS yang memperkirakan gradien secara numerik, bukan turunan analitik seperti Newton. Meskipun demikian, hasil akhir keduanya praktis identik dengan selisih hanya sekitar [selisih], yang membuktikan bahwa implementasi Newton-Raphson pada fungsi newtonraphson() sudah benar dan akurat. Dengan kata lain, Newton-Raphson lebih efisien dari sisi jumlah langkah karena memanfaatkan turunan analitik, tetapi tetap memerlukan evaluasi fungsi dan turunan di setiap iterasi; sedangkan fitdistr lebih praktis karena langsung menangani optimisasi tanpa perlu menurunkan rumus secara manual, meskipun biaya komputasinya tidak selalu sebanding karena menggunakan pendekatan numerik.