Dalam banyak kasus, kita harus menghitung Ar, di mana A adalah matriks persegi berukuran n×n dan r adalah bilangan bulat positif yang besar. Dalam kasus ini, jika kita menghitung Ar secara langsung, waktu komputasi akan menjadi mahal dan kita mungkin akan mendapatkan kesalahan numerik yang besar di komputer.

Oleh karena itu, kita ingin menyederhanakan Ar sehingga kita dapat menghitungnya secara efisien. Salah satu ide kunci untuk menyederhanakan Ar adalah diagonalisasi. Pada bagian ini kita akan mendiskusikan diagonalisasi pada sebuah matriks bujur sangkar.

Q <- matrix(c(1, 1, -1, 1), 2, 2) 
D <- matrix(c(3, 0, 0, 1), 2, 2)
Q_inv <- solve(Q)
print(Q_inv)
##      [,1] [,2]
## [1,]  0.5  0.5
## [2,] -0.5  0.5
A <- matrix(c(1, 0, 3, -2, 2, -3, 1, -3, -2), 3, 3) 
eigen(A)
## eigen() decomposition
## $values
## [1]  4.50349224 -3.56576496  0.06227272
## 
## $vectors
##            [,1]        [,2]       [,3]
## [1,]  0.5276592 -0.01504018 -0.7715961
## [2,] -0.6521968 -0.47442002 -0.5343413
## [3,]  0.5442565 -0.88017012 -0.3451359
p <- eigen(A)$vectors 
D <- diag(eigen(A)$values) 
p %*% D %*% solve(p)
##               [,1] [,2] [,3]
## [1,]  1.000000e+00   -2    1
## [2,] -7.008283e-16    2   -3
## [3,]  3.000000e+00   -3   -2

Untuk menghitung limit ini, pertama-tama kita perlu mendiagonalisasi P. Dalam R kita akan menggunakan fungsi eigen() untuk mendiagonalisasi matriks transisi P. Pertama-tama kita harus mendefinisikan matriksnya:

A <- matrix(c(1/4, 1/5, 1/3, 1/6, 1/4, 1/5, 1/3, 1/3, 1/4, 2/5, 1/6, 1/3, 1/4, 1/5, 1/6, 1/6), 4, 4)
p <- eigen(A)$vectors 
D <- diag(eigen(A)$values) 
p %*% D %*% solve(p)
##              [,1]         [,2]         [,3]         [,4]
## [1,] 0.2500000+0i 0.2500000+0i 0.2500000+0i 0.2500000+0i
## [2,] 0.2000000-0i 0.2000000+0i 0.4000000+0i 0.2000000+0i
## [3,] 0.3333333+0i 0.3333333-0i 0.1666667-0i 0.1666667+0i
## [4,] 0.1666667+0i 0.3333333+0i 0.3333333+0i 0.1666667+0i
ini <- c(1/4, 1/4, 1/4, 1/4)
ini %*% p %*% D^(10000) %*% solve(p)
##              [,1]        [,2]         [,3]         [,4]
## [1,] 0.2435175+0i 0.276212+0i 0.2841037+0i 0.1961669+0i

Diagonalisasi adalah proses mengubah matriks persegi menjadi bentuk diagonal dengan menggunakan matriks eigenvectors. Di R Studio, Anda dapat menggunakan fungsi eigen() untuk mendapatkan eigenvectors dan eigenvalues dari matriks, dan kemudian menggunakan eigenvectors tersebut untuk melakukan diagonalisasi.

Berikut adalah langkah-langkah umum untuk melakukan diagonalisasi di R Studio:

  1. Tentukan matriks persegi yang ingin Anda diagonalisasi. Misalnya, simpan matriks dalam variabel A.

  2. Gunakan fungsi eigen() untuk mendapatkan eigenvectors dan eigenvalues dari matriks A. Contoh sintaksnya:

result <- eigen(A)

  1. Variabel result akan berisi dua komponen, yaitu values (eigenvalues) dan vectors (eigenvectors). Anda dapat mengakses eigenvectors dengan menggunakan result$vectors.

  2. Buat matriks P dengan menggunakan eigenvectors sebagai kolom-kolomnya. Contoh sintaksnya:

P <- result$vectors
  1. Invers matriks P dan simpan dalam variabel P_inv. Anda dapat menggunakan fungsi solve() untuk melakukan invers matriks. Contoh sintaksnya:
P_inv <- solve(P)
  1. Hitung matriks diagonal D dengan menggunakan eigenvalues sebagai diagonalnya. Contoh sintaksnya:
D <- diag(result$values)
  1. Lakukan diagonalisasi dengan menggunakan rumus D = P_inv %*% A %*% P. Contoh sintaksnya:
diagonalized_A <- P_inv %*% A %*% P

Matriks diagonalized_A akan menjadi bentuk diagonal dari matriks A setelah diagonalisasi.

Perhatikan bahwa proses diagonalisasi hanya dapat dilakukan pada matriks persegi dan matriks tersebut harus memiliki eigenvectors yang lengkap.