Anak Males – kali ini kita akan belajar C++ untuk membuat sebuah program C++ transpose dan determinan pada matrix 3×3.
Karena kemarin kita sudah mencoba membuat sebuah program C++ yang menghitung nilai mean dan kawannya. Kalau belum baca, baca aja dulu.
Pasti udah pada tau kan tentang transpose dan determinan matrix ?. Kalau belum tau, mungkin kita bisa cari tau di tutorial ini.
Apa Itu Transpose Matrix ?
Transpose adalah suatu operasi matematika yang dilakukan terhadap matriks atau vektor, yang memindahkan posisi elemen-elemen dari matriks atau vektor tersebut dengan cara menukar baris dan kolomnya. Contohnya, jika kita memiliki matriks A sebagai berikut:
A = [a1, a2, a3]
[b1, b2, b3]Maka setelah dilakukan transpose, matriks A akan menjadi:
A' = [a1, b1]
[a2, b2]
[a3, b3]Atau dengan kata lain, setiap elemen di baris ke-i dan kolom ke-j dari matriks A akan dipindahkan ke posisi di baris ke-j dan kolom ke-i pada matriks A’.
Transpose juga dapat dilakukan terhadap vektor, dengan cara mengubah vektor tersebut menjadi sebuah matriks yang memiliki satu baris atau satu kolom. Misalnya, jika kita memiliki vektor v sebagai berikut:
v = [v1, v2, v3]Maka setelah dilakukan transpose, vektor v akan menjadi:
v' = [v1]
[v2]
[v3]atau
v' = [v1, v2, v3]Transpose sering digunakan dalam berbagai aplikasi matematika, termasuk linear algebra, dan juga dapat digunakan dalam pemrograman untuk mempermudah penanganan data yang disimpan dalam matriks atau vektor.
Apa Itu Determinan ?
Beda lagi dengan determinan. Determinan matriks adalah angka yang menggambarkan seberapa besar matriks tersebut mempengaruhi perubahan dari ruang yang dimodelkannya.
Determinan matriks juga bisa diartikan sebagai faktor skalar yang dapat digunakan untuk menentukan apakah matriks tersebut memiliki inverse atau tidak.
Determinan matriks dapat dihitung untuk matriks yang memiliki ordo atau ukuran 2×2 atau lebih. Untuk matriks ordo 2×2, determinan dapat dihitung dengan menggunakan rumus:
|A| = a11 x a22 - a12 x a21Di mana a11, a12, a21, dan a22 adalah elemen dari matriks 2×2 tersebut. Untuk matriks ordo lebih dari 2×2, determinan dapat dihitung dengan menggunakan rumus:
|A| = a11 x |A11| - a12 x |A12| + a13 x |A13| + ... + (-1)^n+1 x a1n x |A1n|Di mana a11, a12, a13, …, a1n adalah elemen pertama baris dari matriks tersebut, dan A11, A12, A13, …, A1n adalah matriks minor yang dihasilkan dengan menghapus baris dan kolom pertama dari matriks tersebut.
Determinan matriks memiliki beberapa sifat yang penting, di antaranya:
- Determinan matriks nol jika dan hanya jika matriks tersebut tidak memiliki inverse.
- Determinan matriks kofaktor merupakan faktor skalar yang dapat digunakan untuk menghitung inverse dari matriks tersebut.
- Determinan matriks dapat dihitung dengan mengalikan elemen-elemen di diagonal utama matriks tersebut, dan mengalikan hasilnya dengan (-1)^p, di mana p adalah jumlah pertukaran baris atau kolom yang dilakukan untuk mengelompokkan elemen-elemen diagonal utama tersebut.
Determinan matriks berguna dalam berbagai aplikasi matematika dan ilmu terapan, seperti menentukan invers dari matriks, menyelesaikan sistem persamaan linear, dan menentukan stabilitas sistem dinamik.
Program C++ Mencari Nilai Transpose Matrix 3×3
Berikut ini adalah latihan program C++ mencari nilai transpose matriks 3×3.
#include <iostream>
using namespace std;
int main()
{
cout << "------------------------------------------------------------------------------------------------------------------------" << endl;
cout << "------------------------------------------------Transpose Matrix--------------------------------------------------------" << endl;
cout << "------------------------------------------------------------------------------------------------------------------------" << endl;
int mat[3][3], trans_mat[3][3];
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
cout<<" Input matriks baris ke "<<i<<" kolom ke "<<j<<" = ";cin>>mat[i][j];
}
}
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
trans_mat[j][i] = mat[i][j];
}
}
cout << "Transpos Matriks 3x3 hasilnya: " << endl;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
cout << trans_mat[i][j] << "\t";
}
cout << endl;
}
return 0;
}
Program ini adalah sebuah program C++ yang digunakan untuk mengubah bentuk suatu matriks 3×3 menjadi transpose-nya. Transpose dari suatu matriks adalah matriks yang dihasilkan dari mengganti baris dan kolom dari matriks asal.
Pertama, program ini mencetak beberapa baris teks ke layar menggunakan perintah cout, yang merupakan bagian dari bibliotek iostream.
Kemudian, program ini mendeklarasikan sebuah array multidimensi berukuran 3×3 dengan nama mat dan trans_mat, yang akan digunakan untuk menyimpan matriks asal dan matriks hasil transpose.
Selanjutnya, program ini menggunakan perulangan for untuk meminta input dari pengguna untuk mengisi matriks mat. Setelah itu, program ini menggunakan perulangan for lainnya untuk mengisi matriks trans_mat dengan transpose dari matriks mat.
Terakhir, program ini mencetak matriks trans_mat ke layar dengan menggunakan perulangan for lagi. Setelah itu, program ini mengembalikan nilai 0 ke sistem operasi sebagai tanda bahwa program telah selesai dieksekusi dengan sukses.
Output Program C++ Mencari Nilai Transpose Matrix 3×3
Program C++ Mencari Nilai Determinan Matrix 3×3
#include <iostream>
using namespace std;
int main()
{
cout << "------------------------------------------------------------------------------------------------------------------------" << endl;
cout << "------------------------------------------------Determinan Matrix-------------------------------------------------------" << endl;
cout << "------------------------------------------------------------------------------------------------------------------------" << endl;
int i,j,matriks[3][3]={{0,6,4},{1,1,6},{0,0,1}},det;
for(i=1;i<=3;i++){
for(j=1;j<=3;j++){
cout<<" Input matriks baris ke "<<i<<" kolom ke "<<j<<" = ";cin>>matriks[i-1][j-1];
}
}
cout<<endl<<endl;
cout<<" Tampilan matriks yang terinput :"<<endl;
for(i=1;i<=3;i++){
cout<<endl<<" ";
for(int j=1;j<=3;j++){
cout<<matriks[i-1][j-1]<<" ";
}
}
det
=matriks[0][0]*matriks[1][1]*matriks[2][2]
+matriks[0][1]*matriks[1][2]*matriks[2][0]
+matriks[0][2]*matriks[1][0]*matriks[2][1]
-matriks[0][2]*matriks[1][1]*matriks[2][0]
-matriks[0][0]*matriks[1][2]*matriks[2][1]
-matriks[0][1]*matriks[1][0]*matriks[2][2];
cout<<"\n\n Nilai determinan adalah : "<<det<<endl;
getch();
}
Program di atas adalah program yang ditujukan untuk menghitung determinan dari sebuah matrix 3×3. Matrix merupakan suatu struktur data yang terdiri dari baris dan kolom. Matrix dapat dituliskan dengan menggunakan array 2 dimensi.
Pertama, program ini mencetak beberapa baris teks ke layar yang menjelaskan bahwa program ini akan menghitung determinan matrix 3×3.
Kemudian, program ini mendeklarasikan variabel i, j, dan matriks yang merupakan array 2 dimensi berukuran 3×3, serta variabel det yang akan digunakan untuk menyimpan hasil determinan. Selanjutnya, program ini meminta input dari user untuk setiap elemen dari matrix tersebut.
Setelah itu, program mencetak ke layar matrix yang telah diinput oleh user. Kemudian, program menghitung determinan matrix dengan menggunakan rumus determinan matrix 3×3 yaitu:
det = a * e * i + b * f * g + c * d * h – c * e * g – a * f * h – b * d * i
dimana a, b, c, d, e, f, g, h, dan i adalah elemen-elemen dari matrix tersebut. Kemudian, program mencetak ke layar hasil determinan yang telah dihitung.
Terakhir, program menggunakan perintah getch() yang merupakan perintah untuk menunggu input dari user sebelum menutup program.
Output Program C++ Mencari Nilai Determinan Matrix 3×3
Penutup
Baiklah, mungkin kita cukupkan terlebih dahulu untuk latihan program C++ menghitung transpose dan determinan pada matriks 3×3. Sampai jumpa di tutorial C++ berikutnya.