Soal 1 : Newton Rhapson

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().

Rcode & hasil :

#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

Penjelasan :

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.

Soal 2 : Kuantil t

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\).

Rcode & hasil :

#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

Penjelasan :

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.

Soal 3 : Secant

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.

Rcode & hasil :

#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

Penjelasan :

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.

Soal 4 : Mini Project

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.

Rcode & hasil :

#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

Penjelasan :

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().