Pengantar Pembangkitan Bilangan Acak

Dalam dunia simulasi, penggunaan bilangan acak menjadi salah satu cara untuk merepresentasikan sistem yang kompleks. Dengan menghasilkan data yang memiliki sifat tertentu secara matematis, simulasi dapat berjalan lebih efisien tanpa memerlukan pemeriksaan berulang, terutama dalam pendekatan skala besar yang lebih modern. Pendekatan ini memungkinkan berbagai jenis sebaran bilangan acak digunakan sesuai karakteristik sistem yang disimulasikan. Misalnya, distribusi seragam untuk nilai yang memiliki probabilitas sama, distribusi binomial dan Bernoulli untuk kejadian biner, serta distribusi Poisson untuk kejadian acak dalam waktu atau ruang. Penggunaan distribusi ini memungkinkan simulasi yang lebih akurat dan mendalam.

Pembangkitan Bilangan Acak yang Dapat Didekati Distribusi Seragam

Sebaran seragam kontinu pada interval \([a, b]\) memiliki:

  • fungsi kepekatan peluang: \(f(x) = \begin{cases} \frac{1}{b-a}, & a \leq x \leq b \\ 0, & \text{lainnya} \end{cases}\)

  • Fungsi kumulatif peluang: \(F(x) = \begin{cases} 0, & x < a \\ \frac{x-a}{b-a}, & a \leq x \leq b \\ 1, & x > b \end{cases}\)

  • Nilai harapan dan ragam: \(E[X] = \frac{a + b}{2}, \quad Var(X) = \frac{(b-a)^2}{12}\)

Untuk sembarang peubah acak \(X\), fungsi kumulatif peluang didefinisikan sebagai \(F(x) = P(X \leq x)\) Memiliki sifat \(\lim_{ x \to -\infty} F(x) = 0, \quad \lim_{ x \to \infty} F(x) = 1\). Sehingga, peubah acak lain dapat dibangkitkan dari peubah acak seragam \(U(0,1)\), yang menjadi building-block dalam metode simulasi.

Pembangkitan Bilangan Acak yang Dapat Didekati Distribusi Seragam

  1. Distribusi bernouli
  2. Distribusi binomial
  3. Distribusi poisson

Pembangkitan Bilangan Acak Seragam

Pembangkitan bilangan acak seragam dapat dibangkitkan menggunakan fungsi berikut:

\(U_{n+1} = (\pi + U_n)^5 \mod 1; n\geq 0; 0 < U_0 < 1\)

Dimana :

  • \(U_n \sim U(0,1)\)

  • \(U_0\) : Nilai awal (misal: 0.321)

Atau bilangan acak seragam dapat dibangkitkan secara rekursif dengan fungsi:

\(X_{n+1} = (a X_n + b)\mod m\)

\(U_i = \frac{X_i}{m} \sim U(0,1)\)

Dimana :

  • \(a, b\) adalah konstanta
  • \(m\) adalah modulus
  • \(X_0\) adalah nilai awal

Melalui rumus pembangkitan bilangan acak diatas, bilangan yang dihasilkan tidak benar-benar acak, Sehingga disebut Pseudo-random Number.

Oleh karena itu, pemilihan konstanta a, c, m sangat penting agar:

  1. Efisiensi perhitungan: Perhitungan harus cepat dan ringan.

  2. Panjang siklus: Siklus bilangan acak yang dihasilkan harus cukup panjang sebelum berulang.

    • b dan m tidak memiliki faktor bersama kecuali bilangan satu.

    • (a-1) merupakan kelipatan dari setiap bilangan prima yang membagi m.

    • (a-1) merupakan keliapatan 4 jika m merupakan kelipatan 4

      sehingga dapat dirumuskan \(m = 2^k\) , \(a = 4c + 1\) dan \(b>0\)

  3. Independensi antar pengamatan: Nilai-nilai yang dihasilkan harus tampak acak dan tidak berkorelasi.

    \(\rho = \left( \frac{1}{a} - \frac{6b}{a \cdot m} \left( 1 - \frac{b}{m} \right) \right) \pm \frac{a}{m}\)

Implementasi dalam R

Pembangkitan Manual

Pada simulasi ini, nilai awal \(x_0 = 78\) digunakan bersama konstanta \(a = 1598\) , \(b = 17\), dan \(m=1000\) dalam rumus \((aX_{n} + b) \mod m\) untuk menghitung nilai \(X_i\), yang kemudian dimodifikasi dengan operasi modulus 1000 untuk menghasilkan nilai \(U_i\) yang divisualisasikan dalam histogram.

# Inisialisasi nilai awal
x0 <- 78
n <- 250

# Membuat matrix untuk menyimpan nilai pada setiap iterasi
xi <- matrix(NA, n, 3)
colnames(xi) <- c("aX(i-1)+b", "Xi", "Ui")

# Proses perulangan untuk menghitung nilai Xi dan Ui
for (i in 1:n) {
  xi[i, 1] <- (1598 * x0 + 17)  # Menghitung nilai aX(i-1) + b
  xi[i, 2] <- xi[i, 1] %% 1000  # Mengambil nilai Xi dengan operasi modulus
  xi[i, 3] <- xi[i, 2] / 1000   # Menghitung nilai Ui dengan membagi Xi dengan 1000
  x0 <- xi[i, 2]  # Memperbarui nilai x0 untuk iterasi selanjutnya
}

# Menampilkan histogram dari nilai Ui
hist(xi[, 3], main = "Histogram of Ui", xlab = "Ui", col = "skyblue", border = "black")

Pembangkitan Menggunakan Fungsi runif()

set.seed(150)
seragam_numbers <- runif(250, min=0, max=1)
hist(seragam_numbers, main="Histogram Bilangan Acak seragam (runif)", col="lightblue", border="black")

Pembangkitan Bilangan Acak Bernoulli

Distribusi Bernoulli merupakan salah satu distribusi diskret yang memiliki dua kemungkinan nilai, yaitu 0 dan 1. Pembangkitan bilangan acak Bernoulli dapat dilakukan dengan memanfaatkan peubah acak seragam. Distribusi Bernoulli adalah distribusi untuk peubah acak yang hanya memiliki dua nilai, yaitu 0 dan 1. Nilai 1 terjadi dengan probabilitas \(p\), dan nilai 0 terjadi dengan probabilitas \(1-p\).

Misalkan \(X\) adalah variabel acak Bernoulli dengan parameter \(p\), maka kita dapat menuliskan fungsi massa probabilitasnya sebagai berikut:

\[ P(X = 1) = p, \quad P(X = 0) = 1 - p \]

Pembangkitan Bilangan Acak Bernoulli dari Peubah Acak seragam

Untuk membangkitkan bilangan acak Bernoulli menggunakan peubah acak seragam, kita memanfaatkan sifat peubah acak seragam \(U\) yang terdistribusi seragam pada interval [0,1]. Berikut adalah langkah-langkah pembangkitannya:

  1. Generate Peubah Acak seragam: Kita akan menghasilkan bilangan acak \(U\) yang terdistribusi seragam pada interval [0, 1]. Dalam R, ini dapat dilakukan dengan fungsi runif().
  2. Transformasi ke Bilangan Acak Bernoulli: Jika \(U \leq p\), maka nilai yang dibangkitkan adalah 1. Jika \(U > p\), maka nilai yang dibangkitkan adalah 0.

Secara matematis, pembangkitan bilangan acak Bernoulli dari peubah acak seragam \(U\) adalah sebagai berikut:

\[ X = \begin{cases} 1 & \text{jika } U \leq p \\ 0 & \text{jika } U > p \end{cases} \]

Implementasi dalam R

Mari kita implementasikan langkah-langkah di atas dalam R. Berikut adalah fungsi untuk membangkitkan bilangan acak Bernoulli.

# Fungsi untuk pembangkitan bilangan acak Bernoulli 
bernoulli = function(p, n) { 
  u = runif(n) # Generate n bilangan acak seragam 
  x = ifelse(u <= p, 1, 0) # Konversi ke bilangan acak Bernoulli 
  return(x) 
  }

# Contoh pembangkitan bilangan acak Bernoulli dengan p = 0.3

set.seed(123)
bernoulli(0.3, 10)
##  [1] 1 0 0 0 0 1 0 0 0 0

Penjelasan Kode:

  • Fungsi runif(n) digunakan untuk menghasilkan \(n\) bilangan acak seragam pada interval [0, 1].

  • Fungsi ifelse() digunakan untuk melakukan transformasi bilangan acak seragam \(U\) menjadi bilangan acak Bernoulli. Jika \(U \leq p\), maka hasilnya adalah 1, dan jika \(U > p\), maka hasilnya adalah 0.

Pembangkitan Bilangan Acak Binomial

Distribusi Binomial digunakan untuk menghitung jumlah keberhasilan dalam sejumlah percobaan Bernoulli. Pembangkitan bilangan acak Binomial dapat dilakukan dengan memanfaatkan bilangan acak Bernoulli yang telah dibangkitkan sebelumnya, yang akan digunakan untuk mensimulasikan beberapa percobaan Bernoulli. Distribusi Binomial adalah distribusi untuk jumlah keberhasilan dalam \(n\) percobaan Bernoulli yang independen, di mana setiap percobaan memiliki probabilitas sukses \(p\). Misalkan \(X\) adalah variabel acak Binomial dengan parameter \(n\) (jumlah percobaan) dan \(p\) (probabilitas sukses), maka fungsi massa probabilitasnya adalah:

\[ P(X = k) = \binom{n}{k} p^k (1-p)^{n-k}, \quad k = 0, 1, 2, \dots, n \]

Pembangkitan Bilangan Acak Binomial dari Bilangan Acak Bernoulli

Untuk membangkitkan bilangan acak Binomial, kita dapat menggunakan bilangan acak Bernoulli yang telah dibangkitkan sebelumnya. Jika kita ingin menghasilkan bilangan acak Binomial dengan parameter \(n\) dan \(p\), maka langkah-langkahnya adalah:

  1. Generate \(n\) Bilangan Acak Bernoulli: Kita akan menghasilkan \(n\) bilangan acak Bernoulli independen, masing-masing dengan probabilitas sukses \(p\).
  2. Hitung Jumlah Keberhasilan: Hitung jumlah dari bilangan acak Bernoulli yang bernilai 1. Jumlah ini merupakan bilangan acak Binomial.

Secara matematis, bilangan acak Binomial \(X\) dapat ditulis sebagai:

\[ X = \sum_{i=1}^{n} X_i \]

Di mana \(X_i \sim \text{Bernoulli}(p)\) untuk \(i = 1, 2, \dots, n\).

Implementasi dalam R

Mari kita implementasikan pembangkitan bilangan acak Binomial dalam R. Kita akan memanfaatkan fungsi bernoulli() yang telah kita buat sebelumnya untuk menghasilkan bilangan acak Binomial.

# Fungsi untuk pembangkitan bilangan acak Binomial
binomial = function(n, p, size) {
  # Menghasilkan bilangan acak Binomial dengan menggunakan pembangkitan Bernoulli
  x = replicate(size, sum(bernoulli(p, n)))  # Melakukan n percobaan untuk setiap ukuran
  return(x)
}

# Contoh pembangkitan bilangan acak Binomial dengan n = 10, p = 0.3, dan size = 5
set.seed(123)
binomial(10, 0.3, 5)
## [1] 2 3 2 3 5
# Menggunakan fungsi rbinom
rbinom(5, 10, 0.3)
## [1] 1 3 4 1 3

Fungsi bernoulli(p, n) digunakan untuk menghasilkan \(n\) bilangan acak Bernoulli dengan probabilitas sukses \(p\). Fungsi replicate(size, ...) digunakan untuk menghasilkan size bilangan acak Binomial, dengan setiap bilangan acak Binomial dihitung sebagai jumlah dari \(n\) bilangan acak Bernoulli.

Pembangkitan Bilangan Acak Poisson

Distribusi Poisson digunakan untuk menghitung jumlah kejadian dalam suatu interval waktu atau ruang tertentu, dengan rata-rata kejadian \(\lambda\). Pembangkitan bilangan acak Poisson ini dapat dilakukan menggunakan peubah acak seragam dengan algoritma inverse transform. Distribusi Poisson adalah distribusi untuk jumlah kejadian dalam suatu interval waktu atau ruang yang tetap, dengan rata-rata kejadian \(\lambda\). Fungsi massa probabilitas untuk distribusi Poisson adalah:

\[ P(X = k) = \frac{\lambda^k e^{-\lambda}}{k!}, \quad k = 0, 1, 2, \dots \]

Pembangkitan Bilangan Acak Poisson dari Peubah Acak seragam

Untuk membangkitkan bilangan acak Poisson, kita dapat menggunakan peubah acak seragam \(U\) yang terdistribusi seragam pada interval [0, 1]. Pembangkitan bilangan acak Poisson dilakukan dengan langkah-langkah sebagai berikut:

  1. Generate Bilangan Acak seragam: Pertama, kita akan menghasilkan beberapa bilangan acak \(U_1, U_2, \dots\) yang terdistribusi seragam pada interval [0, 1].
  2. Hitung Jumlah Kejadian: Untuk setiap bilangan acak seragam yang dihasilkan, kita menghitung jumlah kejadian \(k\) sehingga jumlah kumulatifnya lebih besar atau sama dengan nilai \(\lambda\).

Pembangkitan Bilangan Acak Poisson Menggunakan Sebaran seragam

  1. Tentukan Parameter: Diketahui bahwa distribusi Poisson memiliki parameter \(\lambda\), yang menyatakan rata-rata kejadian dalam suatu interval waktu atau ruang.

  2. Generate Bilangan Acak seragam: Pertama, kita menghasilkan bilangan acak seragam \(U_i\) yang terdistribusi seragam pada interval \([0, 1]\).

    \[ U_i \sim \text{seragam}(0, 1) \]

  3. Langkah Pembangkitan Bilangan Acak Poisson: Bilangan acak Poisson \(X\) dapat dibangkitkan dengan pendekatan inverse transform. Berikut langkah-langkahnya:

    • Mulai dengan \(k = 0\) dan jumlah kumulatif \(S = 0\).
    • Hasilkan bilangan acak seragam \(U_k\).
    • Tambahkan \(-\ln(U_k)\) ke dalam \(S\).
    • Teruskan langkah ini sampai jumlah kumulatif \(S\) lebih besar atau sama dengan \(\lambda\).
    • Ketika \(S \geq \lambda\), maka nilai \(X = k\) adalah jumlah kejadian.

    Secara matematis, pembangkitannya adalah sebagai berikut:

    \[ S = \sum_{i=1}^{k} -\ln(U_i) \]

    Di mana \(U_i\) adalah bilangan acak seragam, dan proses ini diulang sampai \(S \geq \lambda\). Setelah itu, bilangan acak Poisson \(X\) dihitung sebagai \(k - 1\), karena kita menghitung jumlah kejadian hingga melebihi nilai \(\lambda\).

  4. Mendapatkan Bilangan Poisson: Setelah proses tersebut, bilangan acak Poisson adalah nilai \(k-1\), di mana \(k\) adalah jumlah langkah yang dibutuhkan agar \(S\) melebihi atau sama dengan \(\lambda\).

    \[ X = k - 1 \]

Implementasi dalam R

Mari kita implementasikan pembangkitan bilangan acak Poisson dalam R menggunakan algoritma inverse transform.

# Fungsi untuk pembangkitan bilangan acak Poisson
poisson = function(lambda, size) {
  x = numeric(size)
  for (i in 1:size) {
    sum_log = 0
    k = 0
    while (sum_log < lambda) {
      sum_log = sum_log - log(runif(1))  # Generate bilangan acak seragam dan tambahkan log-nya
      k = k + 1
    }
    x[i] = k - 1  # Bilangan acak Poisson adalah k - 1
  }
  return(x)
}

# Contoh pembangkitan bilangan acak Poisson dengan lambda = 5 dan size = 5
poisson(5, 5)
## [1] 4 3 9 5 4
# Dengan fungsi rpois
rpois(5, 5)
## [1]  4 10  8  8  3