Laporan ini membahas penyelesaian persamaan menggunakan metode Newton-Raphson dan Secant. Hasil perhitungan dibandingkan dengan metode atau fungsi pembanding yang diminta pada setiap soal. Setiap bagian memuat kode R dan interpretasi hasil dalam satu paragraf.
Fungsi Newton-Raphson menerima fungsi yang menghasilkan dua nilai, yaitu nilai fungsi dan turunan pertamanya. Fungsi Secant hanya memerlukan nilai fungsi. Fungsi Bisection berikut digunakan untuk membandingkan jumlah iterasi pada soal nomor 1.
newtonraphson <- function(ftn, x0, tol = 1e-9, max.iter = 100) {
x <- x0
fx <- ftn(x)
iter <- 0
while (is.finite(fx[1]) && abs(fx[1]) > tol &&
iter < max.iter) {
if (!is.finite(fx[2]) || fx[2] == 0) break
x <- x - fx[1] / fx[2]
fx <- ftn(x)
iter <- iter + 1
}
if (!is.finite(fx[1]) || abs(fx[1]) > tol) {
return(list(root = NA_real_, iter = iter, converged = FALSE))
}
list(root = x, iter = iter, converged = TRUE)
}
secant <- function(ftn, x0, x1, tol = 1e-9, max.iter = 100) {
f0 <- ftn(x0)
f1 <- ftn(x1)
iter <- 0
while (is.finite(f1) && abs(f1) > tol && iter < max.iter) {
if (!is.finite(f0) || f1 == f0) break
x2 <- x1 - f1 * (x1 - x0) / (f1 - f0)
x0 <- x1
f0 <- f1
x1 <- x2
f1 <- ftn(x1)
iter <- iter + 1
}
if (!is.finite(f1) || abs(f1) > tol) {
return(list(root = NA_real_, iter = iter, converged = FALSE))
}
list(root = x1, iter = iter, converged = TRUE)
}
bisection <- function(ftn, a, b, tol = 1e-10, max.iter = 1000) {
fa <- ftn(a)
fb <- ftn(b)
if (!is.finite(fa) || !is.finite(fb) || fa * fb > 0) {
stop("Akar tidak terkurung dalam interval.")
}
iter <- 0
repeat {
m <- (a + b) / 2
fm <- ftn(m)
iter <- iter + 1
if (abs(fm) <= tol || iter >= max.iter) break
if (fa * fm < 0) {
b <- m
fb <- fm
} else {
a <- m
fa <- fm
}
}
list(root = m, iter = iter, residual = abs(fm))
}
Tentukan akar f(x) = x³ − x − 2 dengan x0 = 1,5 dan tol 10−10. Bandingkan jumlah iterasi dengan Bisection pada [1, 2] dan dengan uniroot.
Turunan pertama yang digunakan adalah f’(x) = 3x² − 1.
f1 <- function(x) x^3 - x - 2
df1 <- function(x) 3 * x^2 - 1
hasil.newton1 <- newtonraphson(
function(x) c(f1(x), df1(x)),
x0 = 1.5, tol = 1e-10
)
hasil.bisection1 <- bisection(f1, 1, 2, tol = 1e-10)
hasil.uniroot1 <- uniroot(f1, c(1, 2), tol = 1e-10)
tabel1 <- data.frame(
Metode = c("Newton-Raphson", "Bisection", "uniroot()"),
Akar = c(hasil.newton1$root, hasil.bisection1$root,
hasil.uniroot1$root),
Iterasi = c(hasil.newton1$iter, hasil.bisection1$iter,
hasil.uniroot1$iter),
Residual = c(abs(f1(hasil.newton1$root)),
hasil.bisection1$residual,
abs(f1(hasil.uniroot1$root)))
)
knitr::kable(tabel1, digits = 12,
caption = "Perbandingan metode pencarian akar soal nomor 1")
| Metode | Akar | Iterasi | Residual |
|---|---|---|---|
| Newton-Raphson | 1.521379707 | 3 | 0.0e+00 |
| Bisection | 1.521379707 | 33 | 3.3e-11 |
| uniroot() | 1.521379707 | 8 | 0.0e+00 |
Interpretasi. Ketiga metode menghasilkan akar yang
mendekati 1,5213797068. Newton-Raphson memanfaatkan turunan pertama
sehingga dapat mencapai toleransi dengan jumlah iterasi yang relatif
sedikit ketika tebakan awal berada cukup dekat dengan akar. Bisection
mempertahankan akar di dalam interval [1, 2], sehingga prosesnya lebih
terjamin, tetapi umumnya membutuhkan iterasi lebih banyak. Fungsi
uniroot() memberikan hasil pembanding dengan metode
pencarian akar yang tersedia di R.
Cari t0,975 untuk df = 9 dengan Newton (f = pt(x, 9) − 0,975, f’ = dt(x, 9)), bandingkan dengan qt(0.975, 9). Coba x0 = 10 dan jelaskan hasilnya.
Turunan fungsi distribusi kumulatif t adalah fungsi kepadatan t. Perhitungan dilakukan menggunakan tebakan awal x0 = 2 sebagai pembanding yang konvergen, kemudian dicoba kembali dengan x0 = 10 sesuai instruksi soal.
df <- 9
p <- 0.975
ft <- function(x) pt(x, df = df) - p
dft <- function(x) dt(x, df = df)
hasil.newton2 <- newtonraphson(
function(x) c(ft(x), dft(x)),
x0 = 2, tol = 1e-10
)
nilai.qt <- qt(0.975, 9)
# Percobaan sesuai soal: x0 = 10
hasil.x10 <- newtonraphson(
function(x) c(ft(x), dft(x)),
x0 = 10, tol = 1e-10, max.iter = 100
)
tabel2 <- data.frame(
Metode = c("Newton-Raphson (x0 = 2)", "qt(0.975, 9)",
"Newton-Raphson (x0 = 10)"),
Kuantil = c(hasil.newton2$root, nilai.qt, hasil.x10$root),
Iterasi = c(hasil.newton2$iter, NA, hasil.x10$iter),
Konvergen = c(hasil.newton2$converged, NA, hasil.x10$converged)
)
knitr::kable(tabel2, digits = 12,
caption = "Perbandingan kuantil distribusi t, df = 9")
| Metode | Kuantil | Iterasi | Konvergen |
|---|---|---|---|
| Newton-Raphson (x0 = 2) | 2.262157163 | 4 | TRUE |
| qt(0.975, 9) | 2.262157163 | NA | NA |
| Newton-Raphson (x0 = 10) | NA | 2 | FALSE |
Interpretasi. Nilai kuantil t untuk peluang 0,975
dan derajat bebas 9 adalah sekitar 2,262157, sesuai dengan hasil fungsi
qt(0.975, 9). Newton-Raphson dengan tebakan awal x0 = 2
dapat digunakan untuk memperoleh nilai yang mendekati kuantil tersebut.
Ketika x0 = 10 digunakan, nilai dt(10, 9) sangat kecil
sehingga pembagian pada langkah Newton dapat menghasilkan langkah yang
sangat besar. Akibatnya, iterasi dapat gagal mencapai akar. Hal ini
menunjukkan bahwa konvergensi Newton-Raphson dipengaruhi oleh pemilihan
tebakan awal.
Selesaikan cos x = x dengan Secant (x0 = 0, x1 = 1) dan Newton (x0 = 1). Bandingkan iterasi dan jumlah evaluasi fungsi.
Persamaan ditulis menjadi f(x) = cos(x) − x, dengan turunan f’(x) = −sin(x) − 1.
f3 <- function(x) cos(x) - x
df3 <- function(x) -sin(x) - 1
# Menghitung iterasi dan evaluasi fungsi untuk metode Secant
secant_trace <- function(f, x0, x1, tol = 1e-10, max.iter = 100) {
f0 <- f(x0)
f1 <- f(x1)
evaluasi_f <- 2
iter <- 0
while (is.finite(f1) && abs(f1) > tol && iter < max.iter) {
if (f1 == f0) break
x2 <- x1 - f1 * (x1 - x0) / (f1 - f0)
x0 <- x1
f0 <- f1
x1 <- x2
f1 <- f(x1)
evaluasi_f <- evaluasi_f + 1
iter <- iter + 1
}
list(root = x1, iter = iter, evaluasi_f = evaluasi_f)
}
# Menghitung iterasi dan evaluasi fungsi untuk Newton-Raphson
newton_trace <- function(f, df, x0, tol = 1e-10, max.iter = 100) {
x <- x0
fx <- f(x)
evaluasi_f <- 1
evaluasi_turunan <- 0
iter <- 0
while (is.finite(fx) && abs(fx) > tol && iter < max.iter) {
dfx <- df(x)
evaluasi_turunan <- evaluasi_turunan + 1
if (!is.finite(dfx) || dfx == 0) break
x <- x - fx / dfx
fx <- f(x)
evaluasi_f <- evaluasi_f + 1
iter <- iter + 1
}
list(root = x, iter = iter, evaluasi_f = evaluasi_f,
evaluasi_turunan = evaluasi_turunan)
}
hasil.secant3 <- secant_trace(f3, 0, 1, tol = 1e-10)
hasil.newton3 <- newton_trace(f3, df3, 1, tol = 1e-10)
tabel3 <- data.frame(
Metode = c("Secant", "Newton-Raphson"),
Akar = c(hasil.secant3$root, hasil.newton3$root),
Iterasi = c(hasil.secant3$iter, hasil.newton3$iter),
Evaluasi_fungsi = c(hasil.secant3$evaluasi_f,
hasil.newton3$evaluasi_f),
Evaluasi_turunan = c(0, hasil.newton3$evaluasi_turunan)
)
knitr::kable(tabel3, digits = 12,
caption = "Perbandingan Secant dan Newton-Raphson")
| Metode | Akar | Iterasi | Evaluasi_fungsi | Evaluasi_turunan |
|---|---|---|---|---|
| Secant | 0.7390851332 | 5 | 7 | 0 |
| Newton-Raphson | 0.7390851332 | 4 | 5 | 4 |
Interpretasi. Kedua metode menghasilkan akar yang mendekati 0,7390851332. Newton-Raphson menggunakan turunan pertama dan umumnya memerlukan iterasi lebih sedikit ketika tebakan awal cukup dekat dengan akar. Metode Secant tidak memerlukan turunan, tetapi menggunakan dua tebakan awal untuk membentuk garis sekan. Kolom evaluasi fungsi menunjukkan banyaknya pemanggilan fungsi selama proses iterasi, sedangkan evaluasi turunan dicatat secara terpisah untuk Newton-Raphson.
Taksir MLE parameter bentuk Gamma (α) dari data Anda dengan Newton (rumus di bawah, f’ = 1/α − trigamma(α)), α0 = 1/(2s). Bandingkan dengan MASS::fitdistr.
f(α) = ln(α) − ψ(α) − [ln(x̄) − (1/n) Σ ln(xᵢ)] = 0
dengan ψ merupakan fungsi digamma dan f’(α) = 1/α − trigamma(α).
Data positif berikut digunakan sebagai data contoh. Untuk mengikuti bentuk persamaan pada modul, s didefinisikan sebagai ln(x̄) − rata-rata ln(xᵢ), sehingga nilai awal α0 = 1/(2s).
# Data dummy positif
x <- c(12, 18, 25, 31, 42, 47, 58, 66, 79, 95)
n <- length(x)
s <- log(mean(x)) - mean(log(x))
alpha0 <- 1 / (2 * s)
f_gamma <- function(alpha) {
log(alpha) - digamma(alpha) -
(log(mean(x)) - mean(log(x)))
}
df_gamma <- function(alpha) {
1 / alpha - trigamma(alpha)
}
hasil.newton4 <- newtonraphson(
function(alpha) c(f_gamma(alpha), df_gamma(alpha)),
x0 = alpha0, tol = 1e-10, max.iter = 100
)
if (!requireNamespace("MASS", quietly = TRUE)) {
stop("Paket MASS belum tersedia. Jalankan install.packages('MASS').")
}
hasil.fitdistr <- MASS::fitdistr(x, densfun = "gamma")
tabel4 <- data.frame(
Metode = c("Newton-Raphson", "MASS::fitdistr()"),
Parameter_bentuk_alpha = c(
hasil.newton4$root,
unname(hasil.fitdistr$estimate["shape"])
),
Parameter_rate = c(
NA,
unname(hasil.fitdistr$estimate["rate"])
),
Iterasi = c(hasil.newton4$iter, NA)
)
knitr::kable(tabel4, digits = 10,
caption = "Perbandingan estimasi parameter Gamma")
| Metode | Parameter_bentuk_alpha | Parameter_rate | Iterasi |
|---|---|---|---|
| Newton-Raphson | 2.971962065 | NA | 3 |
| MASS::fitdistr() | 2.971968309 | 0.0628322981 | NA |
Interpretasi. Metode Newton-Raphson digunakan untuk
memperoleh penduga maksimum likelihood parameter bentuk Gamma dengan
mencari akar persamaan skor pada modul. Hasil estimasi parameter bentuk
kemudian dibandingkan dengan MASS::fitdistr(). Kedua hasil
parameter bentuk seharusnya sangat dekat karena menggunakan prinsip
maksimum likelihood yang sama. Pada data dummy yang digunakan, estimasi
parameter bentuk berada di sekitar 2,971962. Perbedaan kecil dapat
terjadi karena toleransi dan kriteria penghentian numerik. Parameter
rate dari fitdistr() ditampilkan sebagai
informasi tambahan.
Berdasarkan keempat soal, metode Newton-Raphson dapat digunakan untuk
mencari akar persamaan dan menyelesaikan persoalan statistika seperti
pencarian kuantil distribusi t serta estimasi parameter bentuk Gamma.
Metode Secant dapat menjadi alternatif ketika turunan fungsi tidak
digunakan, sedangkan Bisection dan uniroot() digunakan
sebagai pembanding pada pencarian akar. Hasil Newton-Raphson sangat
dipengaruhi oleh tebakan awal, seperti terlihat pada percobaan kuantil t
dengan x0 = 10.