MENENTUKAN DETERMINAN DAN INVERS

MATRIKS ORDO NxN

LAPORAN

disusun untuk memenuhi Penilaian Tengah Semester

Mata Kuliah Analisis Algoritma

Dosen pengampu : Dr. Alamsyah S. Si., M. Kom.

Disusun oleh : Kelompok 10

Hanief Widya Wardhana (4611420024)

Faiqotuzzulfa (4611420027)

Samudra Arif Putra (4611420037)

Yoga Fatwanto (4611420047)

JURUSAN ILMU KOMPUTER

FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM

UNIVERSITAS NEGERI SEMARANG

2021
 BAB I
PENDAHULUAN
1.1 Latar Belakang
Teknologi digital telah berkembang sangat jauh saat ini dan telah merevolusi cara
hidup, baik terhadap cara berkomunikasi, cara belajar, cara bekerja, cara berbisnis, dan lain
sebagainya. Era digital memberikan ruang lingkup yang sangat besar untuk
mengorganisasikan segala kegiatan melalui cara baru, inovatif, instan, transparan, akurat,
tepat waktu, lebih baik, memberikan kenyamanan yang lebih dalam mengelola dan
menikmati kehidupan. Dengan teknologi, semua proses kerja dan aktivitas manusia akan
ditransformasikan dari fisik dan statis menjadi digital, mobile, virtual dan personal.
Akibatnya kecepatan kinerja bisnis meningkat dengan cepat. Kecepatan proses meningkat
sangat tajam di banyak aktivitas modern manusia.
Menurut Merriam Webster, pengertian teknologi adalah penerapan pengetahuan praktis
khususnya di bidang tertentu; cara menyelesaikan tugas terutama menggunakan proses
teknis, metode, atau pengetahuan; dan aspek khusus dari bidang usaha tertentu. Jadi dapat
diartikan, teknologi merupakan cara melakukan sesuatu untuk memenuhi kebutuhan
manusia dengan bantuan alat dan akal, sehingga seakan-akan memperpanjang,
memperkuat, atau membuat lebih ampuh anggota tubuh, pancaindra, dan otak manusia.
Saat ini teknologi digital sangat dibutuhkan oleh berbagai aktivitas manusia sehari-hari.
Sebagai contoh, dalam bidang pendidikan yang mungkin tak akan lepas dari teknologi
digital. Berbagai sistem maupun aplikasi yang digunakan pada bidang ini, dikembangkan
dari berbagai macam bahasa pemrograman.
Contoh kecilnya adalah kalkulator yang digunakan untuk memecahkan semua masalah
dalam hal perhitungan. Seseorang menggunakan kalkulator bukan hanya untuk sekedar
menghitung angka yang sederhana saja, tapi terkadang juga digunakan untuk memecahkan
angka yang lebih kompleks. Dalam kegunaan inilah maka saat ini banyak sekali alat hitung
yang memiliki fungsi lebih besar dan luas dengan tombol-tombol yang lebih lengkap.
Bahasa pemrograman yang digunakan untuk mengembangkan sistem maupun aplikasi
terus berkembang sejak dikembangkannya bahasa pemrograman untuk pertama kali.
Dimulai dari bahasa pemrograman BASIC yang bersifat modular, kemudian muncul
bahasa PASCAL, FORTRAN, C, dan COBOL sebagai bahasa pemrograman yang bersifat
terstruktur. Sekarang ini telah muncul lagi metodologi pemrograman yang banyak sekali
diimplementasikan ke berbagai aplikasi atau sistem, yaitu metodologi pemrograman
berorientasi objek dengan bahasa pemrogramannya yaitu C++, Java, PHP, dan lain-lain.
1.2 Rumusan Masalah
1) Bagaimana implementasi determinan dan invers dari matriks ordo nxn dalam satu buah
program yang sekaligus?
2) Bagaimana jika program tersebut dibuat bervariasi dalam tigas jenis program yang
berbeda?
3) Bagaimana flowchat dan pseuducode dari ketiga program tersebut?
4) Bagaimana kompleksitas waktu dan memori dari masing-masing 3 kode program?
5) Bagaimana waktu eksekusi program untuk menghasilkan determinan dan invers
matriks untuk n = 256?
6) Bagaimana analisis dari setiap algoritma yang dihasilkan untuk menentukan algoritma
yang paling efektif dan efisien?
1.3 Tujuan
1) Mengetahui implementasi determinan dan invers dari matriks ordo nxn dalam satu
buah program yang sekaligus
2) Mengetahui program tersebut dibuat bervariasi dalam tigas jenis program yang berbeda
3) Mengetahui flowchat dan pseuducode dari ketiga program tersebut
4) Mengetahui kompleksitas waktu dan memori dari masing-masing 3 kode program
5) Mengetahui waktu eksekusi program untuk menghasilkan determinan dan invers
matriks untuk n = 256
6) Mengetahui analisis dari setiap algoritma yang dihasilkan untuk menentukan algoritma
yang paling efektif dan efisien
 BAB II
TINJAUAN PUSTAKA
2.1 Algoritma

Algoritma merupakan pola pikir yang terstruktur yang berisi tahap-tahap penyelesaian
suatu masalah, yang nantinya akan diimplementasikan ke dalam suatu bahasa pemrograman.
Algoritma juga merupakan jantung ilmu komputer atau informatika. Banyak cabang ilmu
komputer yang diacu dalam terminology algoritma. Dalam kehidupan sehari-hari banyak
terdapat proses yang digambarkan dalam suatu algoritma. Cara-cara membuat kue atau
masakan, misalnya dinyatakan dalam suatu resep. Resep adalah suatu algoritma.

2.2 Flowchart

Flowchart adalah gambaran dalam bentuk diagram alir dari algoritma-algoritma dalam
suatu program, yang menyatakan arah alur program tersebut. Berikut adalah beberapa simbol
yang digunakan dalam menggambar suatu flowchart.
2.3 Bahasa C++

Bahasa C dan C++ merupakan bahasa yang sangat popular dalam dunia pengembangan
perangkat lunak. Kedua bahasa ini digolongkan kedalam bahasa tingkat menengah. Semenjak
dikembangkan, bahasa C dan C++ banyak digunakan untuk mengembangkan program-
program aplikasi di bidang telekomunikasi financial atau bisnis dan sistem operasi. Bahkan
sampai saat ini, pembuatan program-program untuk permainan komputer (game) sebagian
besar masih menggunakan bahasa C/C++.
 BAB III
HASIL DAN PEMBAHASAN

3.1 Pseuducode, Flowchart dan Analisis Kompleksitas Waktu

A. Program Pertama
1) Pseuducode

Function PrintMatrix

for i=1 to n do

for j=1 to n do

print ar[i][j] O(1)

END Function

Function PrintInverse

for i=1 to n do

for j=1 to n do

print ar[i][j] O(1)

END Function

Function InverseOfMatrix

print "=== Matrix ==="

PrintMatrix (matrix,order,order) // Call Function

for i=1 to order do

for j=1 to 2*order do

if j = i + order, then

matrix[i][j] <- 1 O(1)

END for
for i= order-1 to 0 do

if matrix[i-1][0] < matrix[i][0], then

temp = matrix[i] O(1)

matrix[i] = matrix[i - 1] O(1)

matrix[i - 1] = temp O(1)

END if

DECREAMENT i

END for

print "=== Augmented Matrix ==="

PrintMatrix(matrix, order, order * 2)// Call Function

for i=1 to order do

for j=1 to order do

if j!=1, then

temp = matrix[j][i] / matrix[i][i]

for k=1 to 2*order do

matrix[j][k] -= matrix[i][k] * temp O(1)

END for

for i=1 to order do

temp = matrix[i][i]

for j=1 to 2*order do

matrix[i][j] = matrix[i][j] / temp O(1)

END for
 print "=== Inverse Matrix ==="

PrintInverse(matrix, order, 2 * order)// Call Function

END Function

BEGIN

input pilih O(1)

if pilih=1, then

input p

print "1. Menghitung Determinan" O(1)

print "2. Menghitung Invers" O(1)

print "Masukkan pilihan : " O(1)

N <- P O(1)

print "Masukkan ordo matriks n x n : " O(1)

array[N][N] O(1)

det <- 1 O(1)

print "Masukkan" N 'x' N "matrix : " O(1)

for i=1 to N do

for j=1 to N do

input array[i][j] O(1)

END for

for i=1 to N do

flag = false
 if array[i][i] == 0, then

flag = true

for j = i to N do

if array[j][i] != 0, then

det *= -1

for k=1 to < N do

t = array[i][k]

array[i][k] = array[j][k]

array[j][k] = t O(1)

flag = false

END for

if flag == true, then

det = 0 O(1)

break

else

for j=i+1 to < N do

double store = array[j][i]

for k=i to N do

array[j][k] -= (array[i][k]*store)/array[i][i] O(1)

END for

END for

det *= array[i][i] O(1)

END for

print det
else if pilih==2

print "Masukkan ordo matriks n x n : " O(1)

input order O(1)

float** matrix = new float*[256] O(1)

for i=1 to 256 do

matrix[i] = new float[256] O(1)

END for

for i=1 to order do

for j=1 to order do

input matrix[i][j] O(1)

END for

InverseOfMatrix(matrix, order)// Call Function

else

print "Tidak ada dalam pilihan" O(1)

ENDED

2) Perhitungan Kompleksitas waktu

= O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1)
+ O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) +
O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1)

= 6 O(1) + 2 O(1) + 17 O(1) + 2 O(1) + O(1)

= 6 O(n2) + O(n) + 17 O(1) + 2 O(n3) + O(n3)

 = O(n2) + O(n) + O(1) + O(n3) + O(n3)

= O(n3)

Bedasarkan analisis perhitungan kompleksitas waktu yang telah kami lakukan, pada
program kedua memiliki kompleksitas waktu kubik ( O(n3) )
B. Program Kedua
1) Pseuducode

Function determinan

matriks[10][10] O(1)

det ← 0 O(1)

Submatriks[10][10] O(1)

if n ← 2 then

(matriks[1][1] *matriks[2][2]) - (matriks[2][1] *matriks[1][2]) O(1)

else

for x = 1 to n do

subi ← 1

for i = 2 to n do

subj ← 1

for j = 1 to n do

if (j ← x) then

Continue

submatriks[subi][subj] ← matriks[i][j] O(1)

End for

End for

det ← det + (pow(-1, x) *matriks[1][x] * determinant(submatriks, n - 1 ))*1 O(1)

return det

BEGIN

print "1. Menghitung Determinan" O(1)

print "2. Menghitung Invers" O(1)

print "Masukkan pilihan : " O(1)

input pilih O(1)

if pilih=1, then

matrix[256][256] O(1)

n <- 256 O(1)

for i=1 to n do

for j=1 to n do

matrix[i][j]=rand()%987649+1 O(1)

END for

for i=1 to n do

for j=1 to n do O(1)

END for

print "Determinan matriks A : " determinant(matrix, n) O(1)

else if pilih=2

matrix[256][256] O(1)

n <- 256 O(1)

for i=1 to n do

for j=1 to n do

matrix[i][j]=rand()%987649+1 O(1)

END for
for i=1 to n do

for j=1 to n do O(1)

END for

for i=1 to n do

for j=1 to n do

if i!=(j-n), then

matriks[i][j]=0 O(1)

END for

for i=1 to n do

for j=1 to n do

if i!=j, then

matriks[i][j]= matriks[i][j]/matriks[i][i] O(1)

END for

for j=1 to n do

if i=j, then

matriks[i][j]=1 O(1)

END for

for i=1 to n do

if i!=1, then

for j=i+1 to n+n do

 matriks[l][j]=matriks[l][j]-(matriks[i][j]*matriks[l][i]) O(1)

END for

for k=1 to n do

if i!=k, then

matriks[k][i]=0 O(1)

END for

END for

print "Maka invers dari matriks A adalah : " O(1)

for i=1 to n do

for j=n+1 to n+n do

print " " matriks[i][j] O(1)

END for

else

print "Tidak ada dalam pilihan" O(1)

ENDED

2) Perhitungan Kompleksitas Waktu

= O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1)
+ O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) +
O(1) + O(1) + O(1) + O(1) + O(1) + O(1)

= 15 O(1) + 2 O(1) + 3 O(1) + 7 O(1)

= 15 O(1) + 2 O(n3) + 3 O(n) + 7 O(n2)

 = O(1) + O(n3) + O(n) + O(n2)

= O(n3)

Bedasarkan analisis perhitungan kompleksitas waktu yang telah kami lakukan, pada
program kedua memiliki kompleksitas waktu kubik ( O(n3) )
C. Program Ketiga
1) Pseuducode

N=5 O(1)

funct_cof{

i=0 O(1)

j=0 O(1)

for row = 0 to <n

for col = 0 to <n

if row ≠ p & col ≠ q

temp[i][j++] = A[row][col]; O(1)

if j = n – 1

j=0 O(1)

i++

funct_determinan{

D=0 O(1)

if n = 1

return A[0][0]

temp[N][N] O(1)

sign = 1 O(1)

for f = 0 to < n

funct_cof (A, temp, 0, f, n) O(1)

D += sign * A[0][f] * funct_determinan (temp, n - 1) O(1)

sign = -sign O(1)

return D

}
funct_adjoint{

if N=1

adj[0][0] = 1 O(1)

return

sign = 1 O(1)

temp[N][N] O(1)

for i=0 to i<N

for j=0 to <N

funct_cof(A, temp, i, j, N) O(1)

sign = ((i+j)%2==0)? 1: -1 O(1)

adj[j][i] = (sign)*( funct_determinan(temp, N-1)) O(1)

funct_invers{

det = funct_determinan (A, N) O(1)

if det = 0

print "Matriks singular, tidak memiliki invers" O(1)

return false;

adj[N][N] O(1)

funct_adjoint (A, adj) O(1)

for i=0 to <N

for int j=0 to <N

inverse[i][j] = adj[i][j]/float(det) O(1)

 return true

<class T>

funct_tampilan{

for i=0 to <N

for j=0 to <N;

print A[i][j] O(1)

Begin

Print "Masukkan matriks " N " X " N O(1)

for i = 0 to < N

for j = 0 to < N

input A[i][j] O(1)

print "1. Menghitung Determinan : " O(1)

print "2. Menghitung Invers : " O(1)

print "Masukkan pilihan : " O(1)

input pilih O(1)

if pilih=1

print funct_determinan(A,N) O(1)

if pilih=2

if funct_invers(A, inv) O(1)

funct_tampilan(inv) O(1)

else

print "Tidak ada dalam pilihan" O(1)

ended
 2) Perhitungan Kompleksitas waktunnya

= O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1)
+ O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) +
O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1) + O(1)
+ O(1)

= 21 O(1) + O(𝑛2 ) + O(𝑛2 ) + O(𝑛) + O(𝑛) + O(𝑛) + O(𝑛2 ) + O(𝑛2 )+

O(𝑛2 ) + O(𝑛2 ) + O(𝑛2 ) + O(𝑛2 )

= 21 O(1) + 3O(n) + 8O(𝑛2 )

= O(1) + O(n) + O(𝑛2 )

= O(𝑛2 )

Bedasarkan analisis perhitungan kompleksitas waktu yang telah kami lakukan, pada
program ketiga memiliki kompleksitas waktu kuadratik ( O(n2) )
3.2 Waktu Eksekusi

Perhitungan waktu eksekusinya

A. Program Pertama

#include <iostream>
#include <chrono>
using namespace std;
using namespace std::chrono;

void PrintMatrix(float** ar, int n, int m)

{
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ar[i][j] << " ";
}
cout <<"\n";
}
return;
}

void PrintInverse(float** ar, int n, int m)

{
for (int i = 0; i < n; i++) {
for (int j = n; j < m; j++) {
cout << ar[i][j];
}
cout <<"\n";
}
return;
}

void InverseOfMatrix(float** matrix, int order)

{

float temp;
cout <<" Matrix yang diinput\n";
PrintMatrix(matrix, order, order);
for (int i = 0; i < order; i++) {

for (int j = 0; j < 2 * order; j++) {

if (j == (i + order))
matrix[i][j] = 1;
}
}

for (int i = order - 1; i > 0; i--) {

if (matrix[i - 1][0] < matrix[i][0]) {

float* temp = matrix[i];
matrix[i] = matrix[i - 1];
matrix[i - 1] = temp;
}
}

cout <<"\n Matriks Gauss Jordan \n";

PrintMatrix(matrix, order, order * 2);

for (int i = 0; i < order; i++) {

for (int j = 0; j < order; j++) {

if (j != i) {

temp = matrix[j][i] / matrix[i][i];

for (int k = 0; k < 2 * order; k++) {

matrix[j][k] -= matrix[i][k] * temp;

}
}
}
}
 for (int i = 0; i < order; i++) {

temp = matrix[i][i];
for (int j = 0; j < 2 * order; j++) {

matrix[i][j] = matrix[i][j] / temp;

}
}

cout <<"\n=== Inverse Matrix ===\n";

PrintInverse(matrix, order, 2 * order);

return;
}

int main()
{

int pilih;
cout << "1. Menghitung Determinan : "<< endl;
cout << "2. Menghitung Invers : "<< endl;
cout << "Masukkan pilihan : ";
cin >> pilih;

if (pilih==1)
{

const int N=256;

double array[N][N];
double det = 1;
cout << "Masukkan matriks" << N << "x" << N << " :\n";

for (int i = 0; i < N; ++i) {

for (int j = 0; j < N; ++j) {
array[i][j]=rand()%987650+3;
}
}
auto start = high_resolution_clock::now();
for (int i = 0; i < N; ++i)
{
bool flag = false;
if (array[i][i] == 0)
{
flag = true;
for (int j = i; j < N; ++j)
{
if (array[j][i] != 0) {
det *= -1;
for (int k = 0; k < N; ++k) {
double t = array[i][k];
array[i][k] = array[j][k];
array[j][k] = t;
flag = false;
}
}
}
}
if (flag == true) {
det = 0;
break;
}

else {

for (int j = i+1; j < N; ++j)

{
double store = array[j][i];
for (int k = i; k < N; ++k) {
array[j][k] -= (array[i][k]*store)/array[i][i];
}
}
det *= array[i][i];
}
}
 cout << "Determinant: " << det << endl;
auto stop = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(stop - start);
cout << "Time taken by function: " << duration.count() << " milli seconds"
<< endl;
}

else if (pilih==2)
{

int order=256;

float** matrix = new float*[256];

for (int i = 0; i < 256; i++)
matrix[i] = new float[256];

for (int i = 0; i < order; ++i) {

for (int j = 0; j < order; ++j) {
matrix[i][j]=rand()%987650+3;
}
}
auto start1 = high_resolution_clock::now();
InverseOfMatrix(matrix, order);
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(stop1 - start1);
cout << "Time taken by function: " << duration.count() << " milli seconds"
<< endl;
}
else
cout << "Tidak ada dalam pilihan";
return 0;
}

Determinan
Lama waktu eksekusi dari determinan program di atas adalah 27 ms dan dapat diinput nilai
otomatis menggunakan fungsi random sampai 987650

Invers

Lama waktu eksekusi dari invers program di atas adalah 49456 ms dan dapat diinput nilai
otomatis menggunakan fungsi random sampai 987650

B. Program Kedua

#include <iostream>
#include<math.h>
#include <chrono>
using namespace std::chrono;
using namespace std;

int determinant( int matrix[256][256], int n) {

int det = 0;
int submatrix[256][256];
if (n == 2)
return ((matrix[1][1] * matrix[2][2]) - (matrix[2][1] * matrix[1][2]));
else {
for (int x = 1; x <= n; x++) {
int subi = 1;
for (int i = 2; i <= n; i++) {
int subj = 1;
 for (int j = 1; j <= n; j++) {
if (j == x)
continue;
submatrix[subi][subj] = matrix[i][j];
subj++;
}
subi++;
}
det = det + (pow(-1, x) * matrix[1][x] * determinant( submatrix, n -
1 ))*-1;
}
}
return det;
}

int main(){
int pilih;
cout << "1. Menghitung Determinan"<< endl;
cout << "2. Menghitung Invers"<< endl;
cout << "Masukkan pilihan : ";
cin >> pilih;

if (pilih==1)
{
int n, i, j;
int matrix[256][256];
n=7;
for (i=1;i<=n;i++){
for (j=1;j<=n;j++){
matrix[i][j]=rand()%987649+1;
}
}
cout<<endl;
auto start = high_resolution_clock::now();
cout<<"Determinan matriks A : "<< determinant(matrix, n) << endl;
auto stop = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(stop - start);
 cout << "Time taken by function: " << duration.count() << " milli seconds"
<< endl;
}

else if (pilih==2)
{
int n,i,j,k,l;
float matriks[256][256];
n=250;
cout <<endl;
for (i=1;i<=n;i++){
for (j=1;j<=n;j++){
matriks[i][j]=rand()%987649+1;
}
}

auto start1 = high_resolution_clock::now();

for (j=n+1;j<=n+n;j++){
i=j-n;
matriks[i][j]=1;
}
for (j=n+1;j<=n+n;j++){
for (i=1;i<=n;i++){
if (i!=(j-n)) matriks[i][j]=0;
}
}
for (i=1;i<=n;i++){
for (j=1;j<=n+n;j++){
if (i!=j) matriks[i][j]=matriks[i][j]/matriks[i][i];
}
for (j=1;j<=n+n;j++){
if (i==j) matriks[i][j]=1;
}
for (l=1;l<=n;l++){
if (i!=l) {
for (j=i+1;j<=n+n;j++){
matriks[l][j]=matriks[l][j]-(matriks[i][j]*matriks[l][i]);
 }
}
}
for (k=1;k<=n;k++){
if (i!=k) {
matriks[k][i]=0;
}
}
}
cout <<"Maka invers dari matriks A adalah : "<<endl;
for (i=1;i<=n;i++){
for (j=n+1;j<=n+n;j++)
cout <<" "<<matriks[i][j];
cout <<endl;
}
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(stop1 - start1);
cout << "Time taken by function: " << duration.count() << " milli seconds"
<< endl;
}
else
cout << "Tidak ada dalam pilihan" << endl;
return 0;

Determinan

Lama waktu eksekusi dari determinan program di atas adalah 3 ms namun tidak bisa diinput
otomatis menggunakan fungsi random. Hanya terbatas sampai 7x7

Invers
Lama waktu eksekusi dari determinan program di atas adalah 13711 ms namun tidak bisa
diinput otomatis menggunakan fungsi random. Hanya terbatas sampai 250 x 25

C. Program Ketiga

#include <iostream>
using namespace std;
#include <chrono>
using namespace std::chrono;
#define N 12

void getCofactor(double A[N][N], double temp[N][N], int p, int q, int n)

{
int i = 0, j = 0;
for (int row = 0; row < n; row++)
{
for (int col = 0; col < n; col++)
{
if (row != p && col != q)
{
temp[i][j++] = A[row][col];
if (j == n - 1)
{
j = 0;
 i++;
}
}
}
}
}

int determinant(double A[N][N], int n)

{
double D = 0;
if (n == 1)
return A[0][0];
double temp[N][N];
double sign = 1;
for (int f = 0; f < n; f++)
{
getCofactor(A, temp, 0, f, n);
D += sign * A[0][f] * determinant(temp, n - 1);
sign = -sign;
}

return D;
}

void adjoint(double A[N][N],double adj[N][N])

{
if (N == 1)
{
adj[0][0] = 1;
return;
}
double sign = 1, temp[N][N];
for (int i=0; i<N; i++)
{
for (int j=0; j<N; j++)
{
getCofactor(A, temp, i, j, N);
 sign = ((i+j)%2==0)? 1: -1;
adj[j][i] = (sign)*(determinant(temp, N-1));
}
}
}

bool inverse(double A[N][N], double inverse[N][N])

{
double det = determinant(A, N);
if (det == 0)
{
cout << "Matriks singular, tidak memiliki invers";
return false;
}

double adj[N][N];
adjoint(A, adj);
for (int i=0; i<N; i++)
for (int j=0; j<N; j++)
inverse[i][j] = adj[i][j]/float(det);

return true;
}

template<class T>
void tampilan(T A[N][N])
{
for (int i=0; i<N; i++)
{
for (int j=0; j<N; j++)
cout << A[i][j] << " ";
cout << endl;
}
}

int main()
{
 int n, pilih;
double A[N][N];
double inv[N][N];
cout << "Masukkan matriks " << N << " X " << N<< endl;
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
A[i][j]=rand()%20+1;
}

cout << "1. Menghitung Determinan : "<< endl;

cout << "2. Menghitung Invers : "<< endl;
cout << "Masukkan pilihan : ";
cin >> pilih;
if (pilih==1){
auto start = high_resolution_clock::now();
cout <<"Detrminan matriksnya adalah : " << determinant(A,N) << endl;
auto stop = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(stop - start);
cout << "Time taken by function: " << duration.count() << " milli seconds"
<< endl;
}
else if (pilih==2)
{
auto start1 = high_resolution_clock::now();
cout << "\nInvers matriksnya adalah : \n";
if (inverse(A, inv)){
tampilan(inv);
}
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(stop1 - start1);
cout << "Time taken by function: " << duration.count() << " milli seconds"
<< endl;
}
else
cout << "Tidak ada dalam pilihan";
return 0;
}
Determinan

Lama waktu eksekusi dari determinan program di atas adalah 43 ms namun tidak bisa diinput
otomatis menggunakan fungsi random. Hanya terbatas sampai 12x12.

Invers

Lama waktu eksekusi dari determinan program di atas adalah 43 ms namun tidak bisa diinput
otomatis menggunakan fungsi random. Hanya terbatas sampai 12x12.
 BAB IV
PENUTUP

Kesimpulan

Bedasarkan analisis dan pengujian ketiga program yang telah kami buat, program yang
paling efektif dan efisien adalah program pertama karena dapat menghitung matriks hingga
256 x 256 walaupun tidak memiliki kompleksitas waktu yang paling kecil. Sedangkan program
ketiga memiliki kompleksitas waktu terkecil namun tidak efisien karena hanya terbatas hingga
12 x 12 saja jika diinput secara otomatis.
 DAFTAR PUSTAKA

Ensmenger, N. (2016). The multiple meanings of a flowchart. Information & Culture, 51(3),
321-351.

Ghofar, Z. A. (2011). Makalah Perkembangan Teknologi Informatika. KARYA ILMIAH

MAHASISWA S1 SISTEM INFORMASI.

Munir, R., & Lidya, L. (2016). Algoritma dan Pemrograman dalam bahasa pascal, C, dan
C++.

Wardiana, W. (2002). Perkembangan teknologi informasi di Indonesia.