Program Java: Menentukan determinan matriks dengan menggunakan Uraian Laplace

Tutorial ini sebenarnya ini merupakan penulisan kembali tutorial yang saya buat sekitar tahun 2010 tentang penggunaan rekursif dalam pemrograman. Waktu itu saya membuat sebuah program yang entah kenapa begitu istimewa--setidaknya untuk ukuran saya. Kenapa begitu istimewa, adalah karena program yang saya buat tidak pernah ditemukan dalam buku ajar manapun di seluruh dunia. Yang artinya program yang saya buat adalah orisinil temuan saya.

Ternyata setelah saya selidiki metode ini sudah dibuat oleh beberapa orang--berdasarkan tanggal posting artikel. Contohnya satu di link ini---beberapa post yang dibuat lebih awal dari post saya ini dibuat sesudah 2010 ketika saya sudah menemukan metode ini, ini contohnya. Namun pada Tahun 2010 itu saya sudah browsing di google dan saya buka beberapa halaman tidak ada tutorial yang mirip. Jadi waktu itu saya simpulkan, sayalah orang pertama yang membuat/menulis Uraian Laplace di java (komputer). Anggap saja (biar tidak dianggap takabur) apa yang saya lakukan pada waktu itu merupakan proses menemukan kembali (reinventing).

Sebenarnya kalo dipikir-pikir kesulitan dalam implementasi algoritma ini tidak ada yang terlalu sulit. Asalkan kita cukup memahami rekursif, maka kita tentu dengan mudah mengimplementasikannya ke dalam program. Yang membuat program ini heboh adalah dari segi popularitas Uraian Laplace sendiri yang merupakan metode yang digunakan untuk menghitung determinan matriks.

Bayangkan sejak ditemukannya komputer, hingga tahun 2010 belum ada manusia di dunia ini yang sempat memikirkan bagaimana mengimplementasikan Uraian Laplace dalam menghitung determinan matriks, hehe.

Tanpa perlu berbasa basi saya berikan saja source code nya dan pembaca selanjutnya bisa melakukan verifikasi yakni dengan membandingkan hasil perhitungan program saya ini dengan hasil perhitungan MATLAB dalam menghitung determinan matriks.

Jadi program saya itu adalah sebagai berikut:

public class LaplaceExpansion {
 
 public static void main(String[] args){
  
  double[][] mm = { {2,5,6,7, 12} , 
        {3,4,56,6, 6} , 
        {1,2,3,1 ,23} , 
        {4,5,6,12,11},
        {4,2,1,3,5}
  } ; 
  
  Matrix mat = new Matrix(); 
  double det = mat.determinant(mm); 
  System.out.println(det); 
 }
 
 public static void printMatriks(double[][] matriks){
  for(int i=0; i < matriks.length; i++){
   for( int j=0 ; j < matriks[0].length; j++){
    System.out.print( matriks[i][j] + "\t|\t" ); 
   }
   System.out.println(); 
  }
 }
 
}

class Matrix{
 double[][] matrix; 
 public Matrix(double[][] matriks){
  this.matrix = matriks; 
 }
 
 public Matrix(){
  
 }
 public double determinant(double matriks[][]){
  if( matriks.length == 1 && matriks[0].length == 1){
   return matriks[0][0]; 
  }
  double result = 0.0 ; 
  for(int i=0; i < matriks.length; i++){
   int baris = i +1; 
   int kolom = 1; 
   int  sign = (int) Math.pow(-1 , baris + kolom ); 
   result = result +   (sign * matriks[i][0] * 
     determinant(removeRowColumn(matriks, i, 0))) ; 
  }
  return result; 
 }
 
 public double[][] removeRowColumn( double[][] matriks , int row , int column ){
  double[][] result = new double[matriks.length - 1]
       [matriks[0].length - 1];
  int m = 0; 
  for(int i = 0 ; i < matriks.length; i++ ){
   if(i!= row){
    int n = 0; 
    for(int j= 0; j < matriks[0].length; j++ ){
     if( j != column){
      result[m][n] = matriks[i][j]; 
      n++;
     }
    }
    m++;
   }
  }
  return result; 
 }
}

Saya belum pernah melakukan benchmarking tentang efisiensi implementasi saya ini. Yang jelas secara singkat bisa kita lihat bahwa implementasi ini akan menghasilkan kompleksitas O(N log N) yang jika dibandingkan dengan metode Gauss-Jordan (yang juga digunakan dalam menghitung determinant matriks) dengan kompleksitas O(N^3) tentu lebih efisien.