Menentukan akar persamaan \(f(x)=x^3-x-2\) menggunakan metode
Newton-Raphson dengan nilai awal \(x_0=1{,}5\) dan toleransi \(10^{-10}\). Hasilnya dibandingkan dengan
metode Bisection pada selang \([1,2]\)
dan fungsi uniroot().
#Fungsi Newton-Raphson
newtonraphson <- function(ftn, x0, tol = 1e-10, max.iter = 100) {
x <- x0
fx <- ftn(x)
iter <- 0
while (abs(fx[1]) > tol && iter < max.iter) {
if (fx[2] == 0) stop("Turunan bernilai nol")
x <- x - fx[1] / fx[2]
fx <- ftn(x)
iter <- iter + 1
cat("Iterasi", iter, "nilai x:", x, "\n")
}
if (abs(fx[1]) > tol) {
cat("Algorithm failed to converge\n")
return(NULL)
} else {
cat("Algorithm converged\n")
return(list(root = x, iter = iter))
}
}
#Fungsi dan turunannya
f1 <- function(x) {
c(x^3 - x - 2, 3*x^2 - 1)
}
#Newton-Raphson
hasil_newton <- newtonraphson(f1, 1.5)
## Iterasi 1 nilai x: 1.521739
## Iterasi 2 nilai x: 1.52138
## Iterasi 3 nilai x: 1.52138
## Algorithm converged
cat("\nHASIL NEWTON-RAPHSON\n")
##
## HASIL NEWTON-RAPHSON
print(hasil_newton)
## $root
## [1] 1.52138
##
## $iter
## [1] 3
#Metode Bisection
bisection <- function(f, a, b, tol = 1e-10, max.iter = 100) {
iter <- 0
while (((b - a) / 2) > tol && iter < max.iter) {
mid <- (a + b) / 2
if (f(a) * f(mid) < 0) {
b <- mid
} else {
a <- mid
}
iter <- iter + 1
}
return(list(root = (a + b) / 2, iter = iter))
}
f <- function(x) x^3 - x - 2
hasil_bisection <- bisection(f, 1, 2)
cat("\nHASIL BISECTION\n")
##
## HASIL BISECTION
print(hasil_bisection)
## $root
## [1] 1.52138
##
## $iter
## [1] 33
#Metode uniroot
hasil_uniroot <- uniroot(
f,
interval = c(1, 2),
tol = 1e-10
)
cat("\nHASIL UN IROOT\n")
##
## HASIL UN IROOT
print(hasil_uniroot)
## $root
## [1] 1.52138
##
## $f.root
## [1] -3.153033e-13
##
## $iter
## [1] 8
##
## $init.it
## [1] NA
##
## $estim.prec
## [1] 5.000067e-11
#Tabel perbandingan
perbandingan_1 <- data.frame(
Metode = c("Newton-Raphson", "Bisection", "uniroot"),
Akar = c(
hasil_newton$root,
hasil_bisection$root,
hasil_uniroot$root
),
Iterasi = c(
hasil_newton$iter,
hasil_bisection$iter,
hasil_uniroot$iter
)
)
print(perbandingan_1)
## Metode Akar Iterasi
## 1 Newton-Raphson 1.52138 3
## 2 Bisection 1.52138 33
## 3 uniroot 1.52138 8
Berdasarkan hasil perhitungan, ketiga metode menghasilkan akar yang
hampir sama, yaitu sekitar 1,52138. Metode
Newton-Raphson membutuhkan 3 iterasi, Bisection membutuhkan 33 iterasi,
sedangkan uniroot() membutuhkan 8 iterasi. Dengan demikian,
pada soal ini Newton-Raphson mencapai hasil yang diinginkan dengan
jumlah iterasi paling sedikit. Namun, jumlah iterasi tersebut berlaku
untuk fungsi, nilai awal, selang, dan toleransi yang digunakan pada soal
ini.
Mencari kuantil \(t_{0,975}\) untuk
derajat bebas 9 menggunakan metode Newton-Raphson. Hasilnya dibandingkan
dengan fungsi qt(0.975, 9). Perhitungan Newton-Raphson
dilakukan dengan nilai awal \(x_0=1\)
dan \(x_0=10\).
#Fungsi distribusi t dan turunannya
ft <- function(x) {
c(
pt(x, df = 9) - 0.975,
dt(x, df = 9)
)
}
#Fungsi Newton-Raphson
newtonraphson <- function(ftn, x0, tol = 1e-10, max.iter = 100) {
x <- x0
iter <- 0
fx <- ftn(x)
status <- "Konvergen"
while (abs(fx[1]) > tol && iter < max.iter) {
if (!is.finite(fx[2]) || abs(fx[2]) < 1e-12) {
status <- "Gagal konvergen: turunan terlalu kecil"
break
}
x <- x - fx[1] / fx[2]
fx <- ftn(x)
iter <- iter + 1
}
if (abs(fx[1]) <= tol) {
status <- "Konvergen"
} else if (status == "Konvergen") {
status <- "Gagal konvergen: iterasi maksimum"
}
return(list(
root = x,
iter = iter,
status = status,
error = if (status == "Konvergen") abs(fx[1]) else NA
))
}
#Newton-Raphson dengan x0 = 1
hasil_x1 <- newtonraphson(ft, x0 = 1)
cat("\nHASIL NEWTON-RAPHSON (x0 = 1)\n")
##
## HASIL NEWTON-RAPHSON (x0 = 1)
print(hasil_x1)
## $root
## [1] 2.262157
##
## $iter
## [1] 6
##
## $status
## [1] "Konvergen"
##
## $error
## [1] 1.010303e-14
#Pembanding menggunakan fungsi qt()
hasil_qt <- qt(0.975, df = 9)
cat("\nHASIL FUNGSI qt()\n")
##
## HASIL FUNGSI qt()
print(hasil_qt)
## [1] 2.262157
#Newton-Raphson dengan x0 = 10
hasil_x10 <- newtonraphson(ft, x0 = 10)
cat("\nHASIL NEWTON-RAPHSON (x0 = 10)\n")
##
## HASIL NEWTON-RAPHSON (x0 = 10)
print(hasil_x10)
## $root
## [1] -16776.42
##
## $iter
## [1] 1
##
## $status
## [1] "Gagal konvergen: turunan terlalu kecil"
##
## $error
## [1] NA
#Tabel perbandingan
perbandingan_2 <- data.frame(
Metode = c(
"Newton-Raphson (x0 = 1)",
"Fungsi qt()",
"Newton-Raphson (x0 = 10)"
),
Hasil = c(
hasil_x1$root,
hasil_qt,
hasil_x10$root
),
Iterasi = c(
hasil_x1$iter,
NA,
hasil_x10$iter
),
Status = c(
hasil_x1$status,
"Referensi",
hasil_x10$status
),
Selisih = c(
abs(hasil_x1$root - hasil_qt),
0,
if (hasil_x10$status == "Konvergen") {
abs(hasil_x10$root - hasil_qt)
} else {
NA
}
)
)
print(perbandingan_2)
## Metode Hasil Iterasi
## 1 Newton-Raphson (x0 = 1) 2.262157 6
## 2 Fungsi qt() 2.262157 NA
## 3 Newton-Raphson (x0 = 10) -16776.419496 1
## Status Selisih
## 1 Konvergen 2.469136e-13
## 2 Referensi 0.000000e+00
## 3 Gagal konvergen: turunan terlalu kecil NA
Newton-Raphson dengan nilai awal \(x_0=1\) menghasilkan nilai
2,262157 setelah 6 iterasi. Hasil tersebut sama dengan
nilai dari fungsi qt(), yaitu 2,262157,
dengan selisih yang sangat kecil. Sementara itu, penggunaan nilai awal
\(x_0=10\) tidak berhasil konvergen
karena turunan fungsi menjadi terlalu kecil setelah iterasi pertama.
Hasil ini menunjukkan bahwa pemilihan nilai awal berpengaruh terhadap
keberhasilan metode Newton-Raphson dalam mencari kuantil distribusi
t.
Menyelesaikan persamaan \(\cos(x)=x\) menggunakan metode Secant dengan nilai awal \(x_0=0\) dan \(x_1=1\), serta metode Newton-Raphson dengan nilai awal \(x_0=1\). Kedua metode dibandingkan berdasarkan jumlah iterasi dan evaluasi fungsi.
#Fungsi yang akan dicari akarnya
f <- function(x) {
cos(x) - x
}
#Turunan fungsi
df <- function(x) {
-sin(x) - 1
}
#Fungsi metode Secant
secant <- function(f, x0, x1, tol = 1e-10, max.iter = 100) {
iter <- 0
eval_f <- 2
f0 <- f(x0)
f1 <- f(x1)
while (abs(f1) > tol && iter < max.iter) {
if (abs(f1 - f0) < 1e-15) {
stop("Pembagi terlalu kecil")
}
x2 <- x1 - f1 * (x1 - x0) / (f1 - f0)
x0 <- x1
f0 <- f1
x1 <- x2
f1 <- f(x1)
iter <- iter + 1
eval_f <- eval_f + 1
}
return(list(
root = x1,
iter = iter,
eval_f = eval_f
))
}
#Fungsi metode Newton-Raphson
newtonraphson <- function(f, df, x0, tol = 1e-10, max.iter = 100) {
x <- x0
iter <- 0
eval_f <- 1
eval_df <- 0
fx <- f(x)
while (abs(fx) > tol && iter < max.iter) {
dfx <- df(x)
eval_df <- eval_df + 1
if (abs(dfx) < 1e-15) {
stop("Turunan terlalu kecil")
}
x <- x - fx / dfx
fx <- f(x)
eval_f <- eval_f + 1
iter <- iter + 1
}
return(list(
root = x,
iter = iter,
eval_f = eval_f,
eval_df = eval_df
))
}
#Menjalankan metode Secant
hasil_secant <- secant(f, x0 = 0, x1 = 1)
cat("\nHASIL METODE SECANT\n")
##
## HASIL METODE SECANT
print(hasil_secant)
## $root
## [1] 0.7390851
##
## $iter
## [1] 5
##
## $eval_f
## [1] 7
#Menjalankan metode Newton-Raphson
hasil_newton_3 <- newtonraphson(f, df, x0 = 1)
cat("\nHASIL METODE NEWTON-RAPHSON\n")
##
## HASIL METODE NEWTON-RAPHSON
print(hasil_newton_3)
## $root
## [1] 0.7390851
##
## $iter
## [1] 4
##
## $eval_f
## [1] 5
##
## $eval_df
## [1] 4
#Tabel perbandingan
perbandingan_3 <- data.frame(
Metode = c("Secant", "Newton-Raphson"),
Akar = c(
hasil_secant$root,
hasil_newton_3$root
),
Iterasi = c(
hasil_secant$iter,
hasil_newton_3$iter
),
Evaluasi_fungsi = c(
hasil_secant$eval_f,
hasil_newton_3$eval_f
),
Evaluasi_turunan = c(
0,
hasil_newton_3$eval_df
),
Total_evaluasi = c(
hasil_secant$eval_f,
hasil_newton_3$eval_f + hasil_newton_3$eval_df
)
)
print(perbandingan_3)
## Metode Akar Iterasi Evaluasi_fungsi Evaluasi_turunan
## 1 Secant 0.7390851 5 7 0
## 2 Newton-Raphson 0.7390851 4 5 4
## Total_evaluasi
## 1 7
## 2 9
Kedua metode menghasilkan akar yang sama, yaitu sekitar 0,7390851. Metode Secant membutuhkan 5 iterasi dengan 7 evaluasi fungsi. Sementara itu, Newton-Raphson membutuhkan 4 iterasi, 5 evaluasi fungsi, dan 4 evaluasi turunan, sehingga total evaluasinya sebanyak 9 kali. Jadi, Newton-Raphson membutuhkan iterasi lebih sedikit, sedangkan Secant membutuhkan total evaluasi yang lebih sedikit pada perhitungan ini karena tidak memerlukan evaluasi turunan.
Mengestimasi parameter bentuk (shape) distribusi Gamma menggunakan
metode Newton-Raphson. Hasil estimasi parameter alpha kemudian
dibandingkan dengan hasil dari fungsi MASS::fitdistr().
Data yang digunakan merupakan data contoh dan dapat diganti dengan data penelitian.
#Data contoh
x <- c(
2.4, 3.1, 1.8, 4.2, 2.9,
5.1, 3.7, 2.2, 4.8, 3.3
)
#Menghitung nilai s
s <- log(mean(x)) - mean(log(x))
#Nilai awal alpha
alpha0 <- 1 / (2 * s)
cat("\nNilai s = ")
##
## Nilai s =
print(s)
## [1] 0.05065816
cat("\nNilai awal alpha = ")
##
## Nilai awal alpha =
print(alpha0)
## [1] 9.870079
#Fungsi MLE Gamma dan turunannya
f_gamma <- function(alpha) {
f <- log(alpha) - digamma(alpha) - s
df <- 1 / alpha - trigamma(alpha)
return(c(f, df))
}
cat("\nHASIL FUNGSI MLE GAMMA\n")
##
## HASIL FUNGSI MLE GAMMA
print(f_gamma(alpha0))
## [1] 0.0008545425 -0.0053054798
#Fungsi Newton-Raphson
newtonraphson <- function(ftn, x0, tol = 1e-10, max.iter = 100) {
x <- x0
iter <- 0
fx <- ftn(x)
while (abs(fx[1]) > tol && iter < max.iter) {
if (abs(fx[2]) < 1e-12) {
stop("Turunan terlalu kecil")
}
x <- x - fx[1] / fx[2]
fx <- ftn(x)
iter <- iter + 1
cat("Iterasi", iter, "Alpha =", x, "\n")
}
return(list(
root = x,
iter = iter,
error = abs(fx[1])
))
}
#Estimasi menggunakan Newton-Raphson
hasil_newton_gamma <- newtonraphson(
f_gamma,
x0 = alpha0
)
## Iterasi 1 Alpha = 10.03115
## Iterasi 2 Alpha = 10.03386
## Iterasi 3 Alpha = 10.03386
alpha_newton <- hasil_newton_gamma$root
cat("\nHASIL ESTIMASI NEWTON-RAPHSON\n")
##
## HASIL ESTIMASI NEWTON-RAPHSON
print(hasil_newton_gamma)
## $root
## [1] 10.03386
##
## $iter
## [1] 3
##
## $error
## [1] 4.440892e-16
cat("\nAlpha Newton-Raphson = ")
##
## Alpha Newton-Raphson =
print(alpha_newton)
## [1] 10.03386
cat("\nJumlah iterasi = ")
##
## Jumlah iterasi =
print(hasil_newton_gamma$iter)
## [1] 3
#Estimasi menggunakan MASS::fitdistr()
library(MASS)
## Warning: package 'MASS' was built under R version 4.5.3
hasil_mass <- fitdistr(
x,
densfun = "gamma",
start = list(
shape = alpha_newton,
rate = alpha_newton / mean(x)
)
)
cat("\nHASIL MASS::fitdistr()\n")
##
## HASIL MASS::fitdistr()
print(hasil_mass)
## shape rate
## 10.033863 2.995183
## ( 4.414685) ( 1.351313)
#Tabel perbandingan
perbandingan_4 <- data.frame(
Metode = c("Newton-Raphson", "MASS::fitdistr"),
Alpha = c(
alpha_newton,
unname(hasil_mass$estimate["shape"])
),
Rate = c(
alpha_newton / mean(x),
unname(hasil_mass$estimate["rate"])
),
Iterasi = c(
hasil_newton_gamma$iter,
NA
)
)
print(perbandingan_4)
## Metode Alpha Rate Iterasi
## 1 Newton-Raphson 10.03386 2.995183 3
## 2 MASS::fitdistr 10.03386 2.995183 NA
#Menghitung selisih estimasi alpha
selisih <- abs(
alpha_newton - hasil_mass$estimate["shape"]
)
cat("\nSelisih estimasi alpha = ")
##
## Selisih estimasi alpha =
print(selisih)
## shape
## 1.463221e-10
Berdasarkan hasil estimasi, metode Newton-Raphson memperoleh nilai
alpha sebesar 10,03386 dengan 3 iterasi. Sementara itu,
fungsi MASS::fitdistr() menghasilkan nilai shape sekitar
10,033863 dan rate sekitar 2,995183.
Selisih estimasi alpha dari kedua metode sangat kecil, yaitu sekitar
\(1,463221 \times 10^{-10}\). Dengan
demikian, hasil estimasi parameter alpha menggunakan Newton-Raphson
hampir sama dengan hasil dari MASS::fitdistr().