Perkalian Penjumlahan Invers Transpose Matrix

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package tugasbesar;

/**
*
* @author Iki Minami
*/
public class tugasBesar {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
System.out.println(“Nama : ANGGA ARI WIJAYA”);
System.out.println(“N.I.M : 102410101070\nTUGAS BESAR\n——————————“);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MATRIX AWAL
int i=0, j=0; // variabel untuk perulangan
int[][] matrix = {{1,0,1},{0,7,0}}; // array untuk matrix awal
System.out.println(“——————————“);
System.out.println(“1. MATRIX AWAL\n——————————“);

// MENCETAK MATRIX AWAL
for(i=0; i<2; i++){ // perulangan untuk baris matrix awal
for(j=0; j<3; j++){ // perulangan untuk kolom matrix awal
System.out.print(matrix[i][j]+" "); // mencetak nilai matrix awal
}
System.out.println("");
}
System.out.println("");

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MATRIX TRANSPOSE
System.out.println("——————————");
System.out.println("2. MATRIX SETELAH DI TRANSPOSE\n——————————");

// MENCETAK MATRIX HASIL TRASPOSE
for(i=0; i<3; i++){ // perulangan untuk baris matrix transpose
for(j=0; j<2; j++){ // perulangan untuk kolom matrix transpose
System.out.print(matrix[j][i]+" "); // mencetak nilai matrix awal yang di transpose
}
System.out.println("");
}
System.out.println("");

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MATRIX PERKALIAN + PENGURUTAN
System.out.println("——————————");
System.out.println("3. PERKALIAN MATRIX\n——————————");
// PERKALIAN
// MENCETAK MATRIX AWAL
for(i=0; i<2; i++){ // perulangan untuk baris matrix awal
for(j=0; j<3; j++){ // perulangan untuk kolom matrix awal
System.out.print(matrix[i][j]+" "); // mencetak nilai matrix awal
}
System.out.println("");
}

//———————————————————————-
System.out.println("\n X\n"); // mencetak operasi X (kali)
//———————————————————————-

// MENCETAK MATRIX HASIL Transpose
for(i=0; i<3; i++){ // perulangan untuk baris matrix transpose
for(j=0; j<2; j++){ // perulangan untuk kolom matrix transpose
System.out.print(matrix[j][i]+" "); // mencetak nilai matrix awal yang di transpose
}
System.out.println("");
}
//———————————————————————-
System.out.println("\n =\n"); // mencetak operasi =
//———————————————————————-
// MENGHITUNG PERKALIAN HASIL MATRIX AWAL DAN MATRIX TRANSPOSE
int[][] matrixKali = new int[2][2]; // array matrix hasil kali
for( i = 0; i<2; i++) { // perulangan untuk jumlah baris matrixKali
for(j = 0; j<2; j++) { // perulangan untuk jumlah kolom matrixKali
for(int a=0; a 1D sementara
int[][] matrixSementara = new int[2][2]; // MatrixKali DIPINDAHKAN KE matrixSementara KARENA AGAR MENJAGA ARRAY YANG DIGUNAKAN UNTUK PENJUMLAHAN NANTI TIDAK BERUBAH NILAINYA
int index=0; // variabel untuk index array 1D (2D->1D)
int index2=0; // variabel untuk index array 1D (1D->2D)
System.out.println(“Sorting Hasil Kali Matrix :\n—————————“);

////////////////////////////////////////////////////////////////////////
// MENGUBAH MARIX HASIL KALI MENJADI 1D
System.out.println(“diubah dalam matrix 1D :”);
for(i=0;i<2;i++){ // perulangan untuk index baris matrixKali
for(j=0;j<2;j++){ // perulangan untuk index kolom matrixKali
matrixSementara[i][j]=matrixKali[i][j];
matrixUrut[index]=matrixSementara[i][j]; // mengisi nilai array 1D matrixUrut dengan nilai matrixKali
System.out.print(matrixUrut[index]+" "); // mencetak nilai array matrixUrut
index++; // perulangan index untuk array 1D matrixUrut
}
}
System.out.println();

////////////////////////////////////////////////////////////////////////
// SORTING ARRAY matrixUrut DENGAN CARA INSERTION SORT
for(i=1; i0 && matrixUrut[j-1] >= temp) { // metode insertion sort : sebelum > NILAI < setelah
matrixUrut[j] = matrixUrut[j-1]; // matrixUrut digeser nialinya 1 index kebelakang
j–; // penurunan nilai variabel j
}
matrixUrut[j] = temp; // jika while tidak terpenuhi matrixUrut[j] diisi dengan variabel temp dan kembali ke for
}

System.out.println("Setelah Sorting :");
for(index=0; index<matrixUrut.length; index++) { // perulangan untuk index matrix
System.out.print(matrixUrut[index] +" "); // mencetak nilai matrixUrut setelah di-sorting
}
System.out.println("");

///////////////////////////////////////////////////////////////////////
// MERUBAH JADI ARRAY 2D LAGI
System.out.println("Kembalikan Matrix jadi 2D :");
for(i=0;i<2;i++){ // perulangan untuk baris matrix
for(j=0;j<2;j++){ // perulangan untuk kolom matrix
matrixSementara[i][j]=matrixUrut[index2]; // mengisi nilai array 2D matrixKali dengan nilai matrixUrut
System.out.print(matrixSementara[i][j]+" "); // mencetak nilai matrixKali yang telah diurutkan
index2++; // perulangan untuk index matrixUrut
}
System.out.println("");
}
///////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MATRIX PENJUMLAHAN
System.out.println("——————————");
System.out.println("4. PENJUMLAHAN MATRIX\n——————————");
////////////////////////////////////////////////////////////////////////
//menjumlahkan halil perkalian dengan dirinya sendiri
int[][] matrixJumlah = new int [2][2]; // array untuk hasil penjumlahan

// mencetak matrixKali1
for( i = 0; i<2; i++) { // perulangan untuk jumlah baris matrixKali
for(j = 0; j<2; j++) { // perulangan untuk jumlah kolom matrixKali
System.out.print(matrixKali[i][j] + " ");
}
System.out.println();
}

////////////////////////////////////////////////////////////////////////
System.out.println("\n +\n"); // mencetak operasi +
////////////////////////////////////////////////////////////////////////

// mencetak matrixKali2
for( i = 0; i<2; i++) { // perulangan untuk jumlah baris matrixKali
for(j = 0; j<2; j++) { // perulangan untuk jumlah kolom matrixKali
System.out.print(matrixKali[i][j] + " ");
}
System.out.println();
}

////////////////////////////////////////////////////////////////////////
System.out.println("\n =\n"); // mencetak operaai =
////////////////////////////////////////////////////////////////////////

// MENGHITUNG HASIL PENJUMLAHAN
for( i = 0; i<2; i++) { // perulangan untuk jumlah baris matrixJumlah
for(j = 0; j1D)
int index4=0; // variabel untuk index array 1D (1D->2D)
System.out.println(“Sorting Hasil Penjumlahan Matrix :\n—————————“);
////////////////////////////////////////////////////////////////////////
// MENGUBAH MARIX HASIL JUMLAH MENJADI 1D
System.out.println(“diubah dalam matrix 1D :”);
for(i=0;i<2;i++){ // perulangan untuk index baris matrixJumlah
for(j=0;j<2;j++){ // perulangan untuk index kolom matrixJumlah
// TIDAK PERLU DIPINDAHKAN KE ARRAY matrixSementara KARENA NILAI HASIL PENJUMLAHAN TIDAK DIGUNAKAN UNTUK LAINNYA.TIDAK SEPERTI PERKALIAN DIATAS YANG DIGUNAKAN UNTUK PENJUMLAHAN, JADI BISA LANGSUNG MENGGUNAKAN ARAY matrixJumlah
matrixUrut[index3]=matrixJumlah[i][j]; // mengisi nilai array 1D matrixUrut dengan nilai matrixJumlah
System.out.print(matrixUrut[index3]+" "); // mencetak nilai array matrixUrut
index3++; // perulangan index untuk array 1D matrixUrut
}
}
System.out.println();

////////////////////////////////////////////////////////////////////////
// SORTING ARRAY matrixUrut DENGAN CARA INSERTION SORT
for(i=1; i0 && matrixUrut[j-1] >= temp) { // metode insertion sort : sebelum > NILAI < setelah
matrixUrut[j] = matrixUrut[j-1]; // matrixUrut digeser nialinya 1 index kebelakang
j–; // penurunan nilai variabel j
}
matrixUrut[j] = temp; // jika while tidak terpenuhi matrixUrut[j] diisi dengan variabel temp dan kembali ke for
}

System.out.println("Setelah Sorting :");
for(index3=0; index3<matrixUrut.length; index3++) { // perulangan untuk index matrix
System.out.print(matrixUrut[index3] +" "); // mencetak nilai matrixUrut setelah di-sorting
}
System.out.println("");

///////////////////////////////////////////////////////////////////////
// MERUBAH JADI ARRAY 2D LAGI
System.out.println("Kembalikan Matrix jadi 2D :");
for(i=0;i<2;i++){ // perulangan untuk baris matrix
for(j=0;j<2;j++){ // perulangan untuk kolom matrix
matrixJumlah[i][j]=matrixUrut[index4]; // mengisi nilai array 2D matrixJumlah dengan nilai matrixUrut
System.out.print(matrixJumlah[i][j]+" "); // mencetak nilai matrixJumlah yang telah diurutkan
index4++; // perulangan untuk index matrixUrut
}
System.out.println("");
}
///////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
System.out.println("——————————");
System.out.println("3. INVERS MATRIX\n——————————");
// MENGHITUNG INVERS matrixKali
float[][] matrixInvers = {{2,0},{0,49}}; // membuat matrix yang akan diInvers
float tukar, determinan; // variabel untuk menghitung determinan dan tempat penukaran
////////////////////////////////////////////////////////////////////////
// MENCETAK NILAI AWAL
System.out.println("Matrix Awal Hasil Kali :");
for(i=0;i<2;i++){
for(j=0;j<2;j++){
System.out.print(matrixInvers[i][j]+" ");
}
System.out.println();
}
System.out.println();

////////////////////////////////////////////////////////////////////////
// MENGHITUNG DETERMINAN MATRIX 2×2 ((a*d)-(c*b))
determinan=(matrixInvers[0][0]*matrixInvers[1][1])-(matrixInvers[1][0]*matrixInvers[0][1]);
System.out.println("Determinanya Adalah :"+"("+matrixInvers[0][0]+" X "+matrixInvers[1][1]+") – ("+matrixInvers[1][0]+" X "+matrixInvers[0][1]+") = "+determinan);
System.out.println("RUMUS INVERS : 1/determinan |-d c|");
System.out.println(" |b -a|");

////////////////////////////////////////////////////////////////////////
// RUMUS MATRIX INVERS (a tukar dengan d), (b dan c di kali – (negatif))
tukar=matrixInvers[0][0]; // memberi nilai variabel tukar = matrixInvers index[0][0] (untuk ditukar)
matrixInvers[0][0]=matrixInvers[1][1]; // index[0][0] diisi nilai index[1][1] (a ditukar dengan d)
matrixInvers[1][1]=tukar; // index [1][1] diisi dengan variabel tukar yang berisi nilai index[0][0] (a ditukar dengan d)
matrixInvers[0][1]=matrixInvers[0][1]*-1; // index[0][1] dikali – (b dikali negatif)
matrixInvers[1][0]=matrixInvers[1][0]*-1; // index[1][0] dikali – (c dikali negatif)

////////////////////////////////////////////////////////////////////////
// MENGHITUNG INVERS
System.out.println("Matriks Inversnya: ");
for (i=0;i<2;i++){ // perulangan untuk baris
for (j=0;j<2;j++){ // perulangan untuk kolom
System.out.print(matrixInvers[i][j]/determinan+" "); // menghitung+mencetak nilai invers
}
System.out.println();
}
System.out.println("——————————\nSELESAI");
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
}

Tinggalkan Balasan

Isikan data di bawah atau klik salah satu ikon untuk log in:

Logo WordPress.com

You are commenting using your WordPress.com account. Logout /  Ubah )

Foto Google

You are commenting using your Google account. Logout /  Ubah )

Gambar Twitter

You are commenting using your Twitter account. Logout /  Ubah )

Foto Facebook

You are commenting using your Facebook account. Logout /  Ubah )

Connecting to %s