27 Mei 2019
Aritmatika Matrix dalam Pemrograman Java

Melanjutkan tulisan sebelumnya tentang array multidimensi, tulisan kali ini akan membahas salah satu bentuk pemanfaatan array multidimensi dalam pemrograman java, yaitu untuk menyelesaikan permasalahan aritmatika matrix

Matrix dapat diemulasikan dalam pemrograman java sebagai array dua dimensi. Sebagai contoh ditentukan matrix A yang terdiri atas 3 baris dan 3 kolom.

A = [ 1 2 3 4 5 6 7 8 9 ]

Matrix A diatas dapat ditulis dalam kode program java sebagai berikut :

int[][] A = {
  {1, 2, 3},
  {4, 5, 6},
  {7, 8, 9}
};

Array A diatas terdiri atas 3 elemen baris dan tiap-tiap elemen terdiri atas 3 nilai kolom. Untuk mengakses nilai pada baris ke-i dan kolom ke-j, kita cukup sebutkan variabel array disertai index baris dan kolomnya A[i][j].

Penjumlahan Matrix

Dua buah matrix dapat dijumlahkan dengan syarat kedua matrix tersebut memiliki jumlah baris dan kolom yang sama. Proses dilakukan dengan menjumlahkan nilai dari kedua matrix pada index baris dan kolom yang sama. Penjumlahan dari kedua matrix akan menghasilkan matrix baru.

Sebagai contoh, ditentukan matrix A dan B :

A = 3 7 1 2 4 6 5 8 9 B = 6 2 4 3 5 1 8 7 9

Proses penjumlahan kedua matrix tersebut adalah sebagai berikut :

A + B = 3 7 1 2 4 6 5 8 9 + 6 2 4 3 5 1 8 7 9 = ( 3 + 6 ) ( 7 + 2 ) ( 1 + 4 ) ( 2 + 3 ) ( 4 + 5 ) ( 6 + 1 ) ( 5 + 8 ) ( 8 + 7 ) ( 9 + 9 ) = 9 9 5 5 9 7 13 15 18

Berikut ini implementasi proses penjumlahan matrix diatas dalam kode program java. Pertama kita definisikan kedua matrix sebagai array integer 2 dimensi

int[][] A = {
  {3, 7, 1},
  {2, 4, 6},
  {5, 8, 9}
};
int[][] B = {
  {6, 2, 4},
  {3, 5, 1},
  {8, 7, 9}
}

Untuk mengantisipasi perubahan terhadap jumlah elemen array, ada baiknya kita lakukan pemeriksaan jumlah elemen terlebih dahulu, untuk menghindari error pada proses penjumlahan nantinya.

if((A.length==B.length)&&(A[0].length==B[0].length)) {
  // kode berikut diketik disini
}
else {
  System.out.println("Ukuran matrix tidak sama");
}

Berikut kita bentuk array C untuk menampung hasil penjumlahan dari A dan B. Ukuran dari C akan berpatokan pada array A

int[][] C = new int[A.length][A[0].length];

Dari sini kita definisikan perulangan bertingkat untuk mengakses tiap elemen dari masing-masing array. Perulangan pertama dengan index i digunakan untuk mengakses tiap-tiap baris dalam kedua array. Dalam tiap iterasi perulangan pertama, kita definisikan perulangan kedua dengan index j untuk mengakses nilai tiap-tiap kolom dari baris. Selebihnya kita tinggal set nilai C[i][j] yaitu hasil penjumlahan dari A[i][j] dan B[i][j].

for(int i=0; i<A.length; i++) {
  for(int j=0; j<A[0].length; j++) {
    C[i][j] = A[i][j] + B[i][j];
  }
}

Untuk menampilkan nilai-nilai elemen dari array C kita gunakan kode berikut :

for(int[] c: C) {
  for(int q: c) {
    System.out.print(q+" ");
  }
  System.out.println();
}

Contoh kode selengkapnya adalah sebagai berikut :

public class Main {
  public static void main(String[] args) {
    int[][] A = {
      {3, 7, 1},
      {2, 4, 6},
      {5, 8, 9}
    };
    int[][] B = {
      {6, 2, 4},
      {3, 5, 1},
      {8, 7, 9}
    };
    if((A.length == B.length) && (A[0].length == B[0].length)) {
      int[][] C = new int[A.length][A[0].length];
      for(int i=0; i<A.length; i++) {
        for(int j=0; j<A[0].length; j++) {
          C[i][j] = A[i][j] + B[i][j];
        }
      }
      for(int[] c: C) {
        for(int q: c) {
          System.out.print(q+" ");
        }
        System.out.println();
      }
    }
    else {
      System.out.println("Ukuran matrix tidak sama");
    }
  }
}

Untuk operasi pengurangan matrix kurang lebih menggunakan cara yang sama

Perkalian Matrix

Dua buah matrix dapat dikalikan dengan kondisi keduanya memiliki ukuran yang sama. Atau, paling minimum, ukuran kolom pada matrix A sama dengan ukuran baris pada matrix B. Jika diketahui matrix A berukuran M x N dan matrix B berukuran N x P, maka perkalian AB akan menghasilkan matrix berukuran M x P.

Sebagai contoh, ditentukan matrix A berukuran 3x2 dan B berukuran 2x3 :

A = 3 8 4 2 5 8 B = 3 3 7 2 8 1

Proses perkalian kedua matrix tersebut adalah sebagai berikut :

A × B = 3 8 4 2 5 8 × 3 3 7 2 8 1 = ( 3 × 3 ) + ( 8 × 2 ) ( 3 × 3 ) + ( 8 × 8 ) ( 3 × 7 ) + ( 8 × 1 ) ( 4 × 3 ) + ( 2 × 2 ) ( 4 × 3 ) + ( 2 × 8 ) ( 4 × 7 ) + ( 2 × 1 ) ( 5 × 3 ) + ( 8 × 2 ) ( 5 × 3 ) + ( 8 × 8 ) ( 5 × 7 ) + ( 8 × 1 ) = 25 73 29 16 28 30 31 79 43

Berikut ini adalah implementasi dari perkalian matrix dalam kode program java. Pertama kita sebutkan kedua matrix sebagai array integer 2 dimensi

int[][] A = {
  {3, 8},
  {4, 2},
  {5, 8}
};
int[][] B = {
  {3, 3, 7},
  {2, 8, 1}
};

Kemudian kita perlu pastikan bahwa ukuran kolom dari array A sama dengan ukuran baris dari array B

if((A[0].length == B.length)) {
  // kode berikut diketik disini
}
else {
  System.out.println("Ukuran kolom A tidak sama dengan baris B");
}

Berikut kita buat array C dengan ukuran baris sama dengan baris A dan ukuran kolom sama dengan kolom B

int[][] C = new int[A.length][B[0].length];

Sama seperti sebelumnya, untuk penghitungan kita gunakan perulangan bertingkat. Perulangan pertama dengan index i digunakan untuk mengakses tiap baris dari array A, Didalam perulangan pertama kita sebutkan perulangan kedua dengan index j digunakan untuk mengakses tiap nilai kolom dari array B. Terakhir, didalam perulangan kedua, kita sebutkan perulangan ketiga dengan index k untuk mengakses kolom A dan baris B

Didalam perulangan, kita jumlahkan nilai elemen C[i][j] dengan hasil perkalian antara A[i][k] dan B[k][j]

for(int i=0; i<A.length; i++) {
  for(int j=0; j<B[0].length; j++) {
    for(int k=0; k<A[0].length; k++) {
      C[i][j] += A[i][k] * B[k][j];
    }
  }
}

Contoh kode selengkapnya adalah sebagai berikut :

public class Main {
  public static void main(String[] args) {
    int[][] A = {
      {3, 8},
      {4, 2},
      {5, 8}
    };
    int[][] B = {
      {3, 3, 7},
      {2, 8, 1}
    };
    if(A[0].length == B.length) {
      int[][] C = new int[A.length][B[0].length];
      for(int i=0; i<A.length; i++) {
        for(int j=0; j<B[0].length; j++) {
          for(int k=0; k<A[0].length; k++) {
            C[i][j] += A[i][k] * B[k][j];
          }
        }
      }
      for(int[] c: C) {
        for(int i: c) {
          System.out.print(i+" ");
        }
        System.out.println();
      }
    }
    else {
      System.out.println("Ukuran kolom A tidak sama dengan baris B");
    }
  }
}