LAPORAN PRAKTIKUM

ALGORITMA DAN STRUKTUR DATA

Disusun Untuk Memenuhi Tugas Mingguan Mata Kuliah Praktikum
Algoritma Dan Struktur Data

Semester 2 Tahun Akademik 2020/2021

Oleh :
Nama : Popy Anisa

NPM : 207006018

LABORATORIUM INFORMATIKA
PROGRAM STUDI INFORMATIKA
FAKULTAS TEKNIK UNIVERSITAS SILIWANGI
TASIKMALAYA
2021
 Modul V
ADT MATRIKS

5.1 Matriks
Merupakan sekumpulan informasi yang setiap individu elemennya
terdefinisi berdasarkan dua buah indeks (yang biasanya dikonotasikan
dengan baris dan kolom). setiap elemen matriks dapat diakses secara
langsung jika kedua indeks diketahui dan indeksnya harus bertype yang
mempuyai keterurutan (suksesor), misalnya integer.
Sering dikatakan bahwa matriks adalah tabel atau array 2 dimensi.
Tetapi patut diperhatikan, bahwa pengertian “2 dimensi”, “baris dan
kolom” adalah dalam pemikiran kita. Pengaturan letak matriks dalam
memori komputer selalu tetap sebagai deretan sel “linier”. Pengertian 2
dimensi ini hanya untuk mempermudah pemrogram dalam mendesain
programnya. Maka matriks adalah salah satu contoh struktur data “lojik”.

5.2 Struktur Matriks

Ilustrasi di atas dapat kamu baca seperti ini: a11 dibaca baris ke-1 dan
kolom ke-1; a12 dibaca baris ke-1 dan kolom ke-2; atau amn yang berarti
baris ke-m dan kolom ke-n.

V-1
 V-2

Struktur Matriks (3x4)

5.3 Operasi Matematika Matriks

1. Penjumlahan
2. Pengulangan
3. Perkalian
4. Transpose
5. dll

5.4 Transpose Matriks

meletakkan baris pada matriks A menjadi kolom pada matriks A’

 V-3

Contoh :
#include <stdio.h>

int main() {
int i, j, m, n;
int matriks[10][10];
int transpose[10][10];

printf("Masukkan jumlah baris matriks: ");

scanf("%d", &m);
printf("Masukkan jumlah kolom matriks: ");
scanf("%d", &n);

printf("Masukkan elemen matriks:\n");

for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
scanf("%d", &matriks[i][j]);
}
}

for (i = 0; i < m; i++) {

for (j = 0; j < n; j++) {
transpose[j][i] = matriks[i][j];
}
}

printf("Hasil transpose matriks:\n");

for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("%d\t", transpose[i][j]);
}
printf("\n");
}
return 0;
}
 V-4

Tugas !
/* NIM/Nama : 207006018/Popy Anisa
Nama file : P2070060181.h
Topik : Menambahkan function (penjumlahan,pengurangan
dan perkalian)
Tanggal : 04/05/2021
Deskripsi : Implementasi ADT Matriks */
/* Definisi type data boolean */
#ifndef BOOLEAN_H
#define BOOLEAN_H
#define boolean unsigned char
#define true 1
#define false 0
#endif
/* NIM/Nama : 207006018/Popy Anisa
Nama file : P207006018 1.h
Topik : Menambahkan function (penjumlahan,pengurangan
dan perkalian)
Tanggal : 04/05/2021
Deskripsi : Implementasi ADT Matriks */

#ifndef matriks_H
#define matriks_H
#include <stdio.h>
#include "P2070060181.h"
#include <math.h>

/* ********** Definisi TYPE MATRIKS dengan indeks int

********** */
/* Ukuran minimum dan maksimum baris dan kolom */
typedef int indeks; /* indeks baris, kolom */
#define BrsMin 1
#define BrsMax 100
#define KolMin 1
#define KolMax 100
typedef double el_type;
typedef struct
{
el_type Mem[BrsMax+1][KolMax+1];
int NBrsEff; /* banyaknya/ukuran baris yg terdefinisi
*/
int NKolEff; /* banyaknya/ukuran kolom yg terdefinisi
*/
}MATRIKS;
/* NBrsEff ≥ 1 dan NKolEff ≥ 1 */
 V-5

/* Memori MATRIKS yang dipakai selalu di "ujung kiri

atas" */
/* ********** DEFINISI PROTOTIPE PRIMITIF **********
*/

/* *** Konstruktor membentuk MATRIKS *** */

void MakeMATRIKS (int NB,int NK,MATRIKS *M);
/* Membentuk sebuah MATRIKS “kosong― berukuran NB
x NK di “ujung kiri― memori */
/* I.S. NB dan NK adalah valid untuk memori MATRIKS
yang dibuat */
/* F.S. MATRIKS M sesuai dengan definisi di atas
terbentuk */

/* *** Selektor "DUNIA MATRIKS" *** */

indeks GetIdxBrsMin();
/* Mengirimkan indeks baris minimum MATRIKS apapun */

indeks GetIdxKolMin();
/* Mengirimkan indeks kolom minimum MATRIKS apapun */

indeks GetIdxBrsMax();
/* Mengirimkan indeks baris maksimum MATRIKS apapun */

indeks GetIdxKolMax();
/* Mengirimkan indeks kolom maksimum MATRIKS apapun */

boolean IsIdxValid (int i,int j);

/* Mengirimkan true jika i, j adalah indeks yang valid
*/

/* *** Untuk sebuah MATRIKS M yang terdefinisi: *** */

indeks FirstIdxBrs (MATRIKS M);
/* Mengirimkan indeks baris terkecil M */

indeks FirstIdxKol (MATRIKS M);

/* Mengirimkan indeks kolom terkecil M */

indeks LastIdxBrs (MATRIKS M);

/* Mengirimkan indeks baris terbesar M */

indeks LastIdxKol (MATRIKS M);

/* Mengirimkan indeks kolom terbesar M */

indeks GetNBrsEff (MATRIKS M);

/* Mengirimkan banyaknya baris efektif M */

indeks GetNKolEff (MATRIKS M);

/* Mengirimkan banyaknya kolom efektif M */
boolean IsIdxEff (MATRIKS M,indeks i,indeks j);
 V-6

/* Mengirimkan true jika i, j adalah indeks efektif

bagi M */

el_type GetElmt (MATRIKS M,indeks i,indeks j);

/* Mengirimkan elemen M dg nomor baris i dan nomor
kolom j */

el_type GetElmtDiagonal (MATRIKS M,indeks i);

/* Mengirimkan elemen M(i,i) */
/* *** Operasi mengubah nilai elemen MATRIKS: Set /
Assign *** */

void SetBrsEff (MATRIKS *M,int NB);

/* I.S. M sudah terdefinisi */
/* F.S. Nilai M.BrsEff diisi dengan NB, */

void SetKolEff (MATRIKS *M,int NK);

/* I.S. M sudah terdefinisi */
/* F.S. Nilai M.NKolEff diisi dengan NK */

void SetEl (MATRIKS *M,int i,int j,el_type X);

/* I.S. M sudah terdefinisi */
/* F.S. M(i,j) bernilai X */
/* Proses: Mengisi M(i,j) dengan X */

/* ********** Assignment MATRIKS ********** */

void CopyMATRIKS (MATRIKS MIn,MATRIKS *MHsl);
/* Melakukan assignment MHsl ↕ Min */

/* ********** KELOMPOK BACA/TULIS ********** */

void BacaMATRIKS (MATRIKS *M,indeks NB,int NK);

/* I.S. IsIdxValid(NB,NK) */
/* F.S. M terdefinisi nilai elemen efektifnya, dan
berukuran NB x NK */
/* Melakukan MakeMATRIKS(M,NB,NK) dan mengisi nilai
efektifnya */
/* dari pembacaan dengan traversal per baris */

void TulisMATRIKS (MATRIKS M);

/* I.S. M terdefinisi */
/* F.S. Sama dengan I.S, dan nilai M(i,j) ditulis ke
layar*/
/* Menulis nilai setiap indeks dan elemen M ke layar
dengan traversal per baris */

/* ********** KELOMPOK OPERASI ARITMATIKA TERHADAP

TYPE ********** */
MATRIKS tambah (MATRIKS M1,MATRIKS M2);
/* PrekondisiM1 berukuran sama dengan M2 */
/* Mengirim hasil penjumlahan MATRIKS: M1 + M2 */
 V-7

MATRIKS kurang (MATRIKS M1,MATRIKS M2);

/* PrekondisiM berukuran sama dengan M */
/* Mengirim hasil pengurangan MATRIKS: salinan M1 –
M2 */

MATRIKS kalimatriks (MATRIKS M1,MATRIKS M2);

/* PrekondisiUkuran kolom efektif M1 = ukuran baris
efektif M2 */
/* Mengirim hasil perkalian MATRIKS: salinan M1 * M2
*/

MATRIKS kalielemen (MATRIKS M,int X);

/* Mengirim hasil perkalian setiap elemen M dengan X
*/

void kali (MATRIKS *M,int K);

/* Mengalikan setiap elemen M dengan K */

/* ********** Operasi lain ********** */

int NBElmt (MATRIKS M);
/* Mengirimkan banyaknya elemen M */

el_type RataNilai (MATRIKS M,indeks N);

/*Prekondisi: Matriks tidak kosong. */
/*Mengirimkan rata-rata nilai ujian ke-N */

indeks RataTestTertinggi (MATRIKS M);

/*Prekondisi : Matriks tidak kosong */
/*Mengirim nomor test yang memiliki rata-rata kelas
tertinggi*/

void TulisStatistikTest (MATRIKS M);

/*I.S. : M terdefinisi, tidak kosong. */
/*F.S. : Untuk setip test yang pernah dilakukan
ditayangkan nilai*/
/*terkecil dan terbesar yang diperoleh mahasiswa,
berikut*/
/*nilai rata-rata dari seluruh mahasiswa.*/
/*Setiap baris menampilkan data statistik sebuah test.
*/
/*Proses : */

void TulisMatriks1 (MATRIKS M);

/*I.S. : M terdefinisi, tidak kosong */
/*F.S. : Semua elemen matriks tertulis di layar.*/
/*Setiap baris akan menampilkan data satu mahasiswa,
berupa:*/
/*Nomor urut, nilai untuk setiap test, dan rata-rata
nilai dari*/
/*seluruh test. */
/*Proses : */
#endif
 V-8

/* File : “P2070060181.c” */
#include "P207006018 1.h"
/* ********** DEFINISI PROTOTIPE PRIMITIF **********
*/

/* *** Konstruktor membentuk MATRIKS *** */

void MakeMATRIKS(int NB,int NK,MATRIKS *M) {
/* Membentuk sebuah MATRIKS “kosong― berukuran NB
x NK di “ujung kiri― memori */
/* I.S. NB dan NK adalah valid untuk memori MATRIKS
yang dibuat */
/* F.S. MATRIKS M sesuai dengan definisi di atas
terbentuk */
/*algoritma*/
SetBrsEff(M,NB);
SetKolEff(M,NK);
}
/* *** Selektor "DUNIA MATRIKS" *** */
indeks GetIdxBrsMin()
/* Mengirimkan indeks baris minimum MATRIKS apapun */
{
/*kamus lokal*/
/*algoritma*/
return(BrsMin);
}
indeks GetIdxKolMin()
/* Mengirimkan indeks kolom minimum MATRIKS apapun */
{
/*kamus lokal*/
/*algoritma*/
return(KolMin);
}
indeks GetIdxBrsMax()
/* Mengirimkan indeks baris maksimum MATRIKS apapun */
{
/*kamus lokal*/
/*algoritma*/
return(BrsMax);
}
indeks GetIdxKolMax()
/* Mengirimkan indeks kolom maksimum MATRIKS apapun */
{
/*kamus lokal*/
/*algoritma*/
return(KolMax);
}
boolean IsIdxValid (int i,int j)
/* Mengirimkan true jika i, j adalah indeks yang valid
*/
{
/*kamus lokal*/
/*algoritma*/
 V-9

return((BrsMin <= i)&&(i <= BrsMax)&&(KolMin <=

j)&&(j <= KolMax));
}

/* *** Untuk sebuah MATRIKS M yang terdefinisi: *** */

indeks FirstIdxBrs (MATRIKS M)
/* Mengirimkan indeks baris terkecil M */
{
/*kamus lokal*/
/*algoritma*/
return(GetIdxBrsMin(M));
}
indeks FirstIdxKol (MATRIKS M)
/* Mengirimkan indeks kolom terkecil M */
{
/*kamus lokal*/
/*algoritma*/
return(GetIdxKolMin(M));
}
indeks LastIdxBrs (MATRIKS M)
/* Mengirimkan indeks baris terbesar M */
{
/*kamus lokal*/
/*algoritma*/
return(FirstIdxBrs(M)+GetNBrsEff(M)-1);
}
indeks LastIdxKol (MATRIKS M)
/* Mengirimkan indeks kolom terbesar M */
{
/*kamus lokal*/
/*algoritma*/
return(FirstIdxKol(M)+GetNKolEff(M)-1);
}
indeks GetNBrsEff (MATRIKS M)
/* Mengirimkan banyaknya baris efektif M */
{
/*kamus lokal*/
/*algoritma*/
return(M.NBrsEff);
}
indeks GetNKolEff (MATRIKS M)
/* Mengirimkan banyaknya kolom efektif M */
{
/*kamus lokal*/
/*algoritma*/
return(M.NKolEff);
}
boolean IsIdxEff (MATRIKS M,indeks i,indeks j)
/* Mengirimkan true jika i, j adalah indeks efektif
bagi M */
{
 V-10

/*kamus lokal*/
/*algoritma*/
return((FirstIdxBrs(M)<=i)&&(i<=LastIdxBrs(M))&&
(FirstIdxKol(M)<=j)&&(j<=LastIdxKol(M)));
}
el_type GetElmt (MATRIKS M,indeks i,indeks j)
/* Mengirimkan elemen M dg nomor baris i dan nomor

kolom j */
{
/*kamus lokal*/
/*algoritma*/
return(M.Mem[i][j]);
}
el_type GetElmtDiagonal (MATRIKS M,indeks i)
/* Mengirimkan elemen M(i,i) */
/* *** Operasi mengubah nilai elemen MATRIKS: Set /
Assign *** */
{
/*kamus lokal*/
/*algoritma*/
return(GetElmt(M,i,i));
}
void SetBrsEff (MATRIKS *M,int NB)
/* I.S. M sudah terdefinisi */
/* F.S. Nilai M.BrsEff diisi dengan NB, */
{
/*kamus lokal*/
/*algoritma*/
(*M).NBrsEff= NB;
}
void SetKolEff (MATRIKS *M,int NK)
/* I.S. M sudah terdefinisi */
/* F.S. Nilai M.NKolEff diisi dengan NK */
{
/*kamus lokal*/
/*algoritma*/
(*M).NKolEff = NK;
}
void SetEl (MATRIKS *M,int i,int j,el_type X)
/* I.S. M sudah terdefinisi */
/* F.S. M(i,j) bernilai X */
/* Proses: Mengisi M(i,j) dengan X */
{
/*kamus lokal*/
/*algoritma*/
(*M).Mem[i][j] = X;
}
/* ********** Assignment MATRIKS ********** */
void CopyMATRIKS (MATRIKS MIn,MATRIKS *MHsl)
/* Melakukan assignment MHsl ↕ Min */
{
/*kamus lokal*/
 V-11

indeks i,j;
/*algoritma*/
SetBrsEff(MHsl,GetNBrsEff(MIn));
SetKolEff(MHsl,GetNKolEff(MIn));
for(i=FirstIdxBrs(MIn);i<=LastIdxBrs(MIn);i++)
{

for(j=FirstIdxKol(MIn);j<=LastIdxKol(MIn);j++)
SetEl(MHsl,i,j,GetElmt(MIn,i,j));
}
}
/* ********** KELOMPOK BACA/TULIS ********** */
void BacaMATRIKS (MATRIKS *M,indeks NB,indeks NK)
/* I.S. IsIdxValid(NB,NK) */
/* F.S. M terdefinisi nilai elemen efektifnya, dan
berukuran NB x NK */
/* Melakukan MakeMATRIKS(M,NB,NK) dan mengisi nilai
efektifnya */
/* dari pembacaan dengan traversal per baris */
{
/*kamus lokal*/
indeks i,j;
el_type x;
/*algoritma*/
printf("\nmembaca inputan\n");
for(i=FirstIdxBrs(*M);i<=LastIdxBrs(*M);i++)
{
for(j=FirstIdxKol(*M);j<=LastIdxKol(*M);j++)
{
printf("masukkan M[%d][%d] : ",i,j);
scanf("%lf",&x);
SetEl(M,i,j,x);
}
}
}
void TulisMATRIKS (MATRIKS M)
/* I.S. M terdefinisi */
/* F.S. Sama dengan I.S, dan nilai M(i,j) ditulis ke
layar*/
/* Menulis nilai setiap indeks dan elemen M ke layar
dengan traversal per baris */
{
/*kamus lokal*/
indeks i,j;
/*algoritma*/
for(i=FirstIdxBrs(M);i<=LastIdxBrs(M);i++) {
for(j=FirstIdxKol(M);j<LastIdxKol(M);j++)
printf("%.2f, ",GetElmt(M,i,j));
printf("%.2f\n",GetElmt(M,i,LastIdxKol(M)));
}
}
/* ********** TUGAS !. Buat driver untuk operasi di
bawah ini! ********** */
 V-12

/* ********** KELOMPOK OPERASI ARITMATIKA TERHADAP

TYPE ********** */
MATRIKS tambah (MATRIKS M1,MATRIKS M2)
/* PrekondisiM1 berukuran sama dengan M2 */
/* Mengirim hasil penjumlahan MATRIKS: M1 + M2 */
{
/*kamus lokal*/
MATRIKS M;
indeks i,j;
/*algoritma*/
MakeMATRIKS(GetNBrsEff(M1),GetNKolEff(M2),&
M);
for(i=FirstIdxBrs(M);i<=LastIdxBrs(M);i++)
{
for(j=FirstIdxKol(M);j<LastIdxKol(M);j++)
{
SetEl(&M,i,j,GetElmt(M1,i,j) +
GetElmt(M2,i,j));
}
}
return(M);
}
MATRIKS kurang (MATRIKS M1,MATRIKS M2)
/* PrekondisiM berukuran sama dengan M */
/* Mengirim hasil pengurangan MATRIKS: salinan M1 –
M2 */
{
/*kamus lokal*/
MATRIKS M;
indeks i,j;
/*algoritma*/
MakeMATRIKS(GetNBrsEff(M1),GetNKolEff(M2),&M);
for(i=FirstIdxBrs(M);i<=LastIdxBrs(M);i++)
{
for(j=FirstIdxKol(M);j<LastIdxKol(M);j++)
{
SetEl(&M,i,j,GetElmt(M1,i,j)+GetElmt(M2,i,j));
}
}
return(M);
}
MATRIKS kalimatriks (MATRIKS M1,MATRIKS M2)
/* Prekondisi : Ukuran kolom efektif M1 = ukuran baris
efektif M2 */
/* Mengirim hasil perkalian MATRIKS: salinan M1 * M2
*/
{
/*kamus lokal*/
MATRIKS M;
el_type sum;
indeks i,j,k;
/*algoritma*/
MakeMATRIKS(GetNBrsEff(M1),GetNKolEff(M2),&M);
 V-13

for(i=FirstIdxBrs(M1);i<=LastIdxBrs(M1);i++)
{
for(j=FirstIdxKol(M2);j<=LastIdxKol(M2);j++)
{

sum = 0;
for(k=FirstIdxKol(M1);k<=LastIdxKol(M1);k++)
sum = sum +
GetElmt(M1,i,k)*GetElmt(M2,k,j);
SetEl(&M,i,j,sum);
}
}
return(M);
}
MATRIKS kalielemen (MATRIKS M,int X)
/* Mengirim hasil perkalian setiap elemen M dengan X
*/
{
/*kamus lokal*/
MATRIKS M1;
indeks i,j;
/*algoritma*/
MakeMATRIKS(GetNBrsEff(M),GetNKolEff(M),&M);
for(i=FirstIdxBrs(M);i<=LastIdxBrs(M);i++)
{
for(j=FirstIdxKol(M);j<LastIdxKol(M);j++)
{
SetEl(&M1,i,j,GetElmt(M,i,j)*X);
}
}
return(M1);
}
void kali (MATRIKS *M,int K)
/* Mengalikan setiap elemen M dengan K */
{
/*kamus lokal*/
indeks i,j;
/*algoritma*/
MakeMATRIKS(GetNBrsEff(*M),GetNKolEff(*M),M);
for(i=FirstIdxBrs(*M);i<=LastIdxBrs(*M);i++)
{
for(j=FirstIdxKol(*M);j<=LastIdxKol(*M);j++)
SetEl(M,i,j,GetElmt(*M,i,j)*K);
}
}
int NBElmt (MATRIKS M)
/* Mengirimkan banyaknya elemen M */
{
/*kamus lokal*/
/*algoritma*/
return(GetNBrsEff(M)*GetNKolEff(M));
}
/* ********** Operasi lain ********** */
 V-14

el_type RataNilai (MATRIKS M,indeks N)

/*Prekondisi: Matriks tidak kosong. */
/*Mengirimkan rata-rata nilai ujian ke-N */
{
/*kamus lokal*/
int i;
double sum = 0;
/*algoritma*/
for(i=FirstIdxBrs(M);i<=LastIdxBrs(M);i++) {
sum += GetElmt(M,i,N);
}
return(sum/GetNBrsEff(M));
}
indeks RataTestTertinggi (MATRIKS M) {
/*Prekondisi : Matriks tidak kosong */
/*Mengirim nomor test yang memiliki rata-rata kelas
tertinggi*/
/*kamus lokal*/
indeks j,jj;
double max,temp;
/*algoritma*/
max = RataNilai(M,FirstIdxKol(M)); jj=1;
for(j=FirstIdxKol(M)+1;j<=LastIdxKol(M);j++) {
temp = RataNilai(M,j);
if(max < temp) {
jj = j;
max = temp;
}
}
return jj;
}
void TulisStatistikTest (MATRIKS M) {
/*I.S. : M terdefinisi, tidak kosong. */
/*F.S. : Untuk setip test yang pernah dilakukan
ditayangkan nilai*/
/*terkecil dan terbesar yang diperoleh mahasiswa,
berikut*/
/*nilai rata-rata dari seluruh mahasiswa.*/
/*Setiap baris menampilkan data statistik sebuah test.
*/
/*Proses : looping kolom, cari max dan min lewat
looping baris */
/*lalu hasil max dan min per looping baris tadi di
cetak melalui indeks kolom*/
/*tapi dicetaknya per baris*/
/*kamus lokal*/
indeks i,j;
el_type max,min,x;
/*algoritma*/
for(j=FirstIdxKol(M);j<=LastIdxKol(M);j++) {
max = GetElmt(M,FirstIdxBrs(M),j);
min = GetElmt(M,FirstIdxBrs(M),j);
for
(i=FirstIdxBrs(M)+1;i<=LastIdxBrs(M);i++) {
 V-15

if (max < GetElmt(M,i,j))

max = GetElmt(M,i,j);
if (min < GetElmt(M,i,j))
min = GetElmt(M,i,j);
}
x = RataNilai (M,j);
printf("test [%d] : %.1lf, %.1lf, %.1lf
\n",j,min,max,x);
}
}
void TulisMatriks1 (MATRIKS M) {
/*I.S. : M terdefinisi, tidak kosong */
/*F.S. : Semua elemen matriks tertulis di layar.*/
/*Setiap baris akan menampilkan data satu mahasiswa,
berupa:*/
/*Nomor urut, nilai untuk setiap test, dan rata-rata
nilai dari*/
/*seluruh test. */
/*Proses : looping baris. cetak indeks, berikut data
nilai melalui looping kolom*/
/*dalam looping kolom kita sematkan variabel untuk
mencari nilai rata2*/
/*setelah looping kolom selesai [semua nilai di
cetak], cetak nilai rata-rata*/
/*kamus lokal*/
indeks i,j;
el_type met;
el_type sum;
/*algoritma*/
for(i=FirstIdxBrs(M);i<=LastIdxBrs(M);i++) {
printf("%d. ",i); sum=0;
for(j=FirstIdxKol(M);j<=LastIdxKol(M);j++) {
met = GetElmt(M,i,j);
printf("%.1lf, ",met);
sum += met;
}
printf("%.1lf \n",sum/GetNKolEff(M));
}}
/* file : “P207006018m1.c” */
#include "P207006018 1.h"
int main() {
/*kamus lokal*/
MATRIKS M;
indeks nbk, nbb;
int i, n, m, j, k,p, q,matriks1[10][10],
matriks2[10][10], hasil[10][10], jumlah=0;

/*algoritma*/
/*membaca inputan*/

// identitas
printf("Nama : %s \n", "Popy Anisa");
 V-16

printf("NPM : %d \n", 207006018);

printf("Kelas : %s \n", "A");
printf("\n\nmasukkan jumlah baris = ");
scanf("%d", &nbb);
printf("masukkan jumlah kolom = ");
scanf("%d", &nbk);
MakeMATRIKS(nbb, nbk, &M);
BacaMATRIKS(&M, nbb, nbk);

/*cetak output*/
printf("\nmencetak matriks\n");
TulisMATRIKS(M);
// operasi penjumlahan
printf("\n\n");
printf(" \n #Penjumlahan Matriks# ");
printf("\nMasukkan jumlah baris matriks: ");
scanf(" %d", &m);
printf(" Masukkan jumlah kolom matriks: ");
scanf(" %d", &n);

printf("Masukkan elemen matrix pertama: \n");

for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
scanf(" %d", &matriks1[i][j]);
}}

printf("Masukkan elemen matrix kedua: \n");

for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
scanf(" %d", &matriks2[i][j]);
}
}
printf("Penjumlahan matriks:\n");
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
hasil[i][j] = matriks1[i][j] +
matriks2[i][j];
printf(" %d \t", hasil[i][j]);
} }

// operasi pengurangan
printf("\n\n");
printf(" \n #Pengurangan Matriks# ");
printf("\nMasukkan jumlah baris matriks: ");
scanf(" %d", &m);
printf(" Masukkan jumlah kolom matriks: ");
scanf(" %d", &n);

printf("Masukkan elemen matrix pertama: \n");

for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
scanf(" %d", &matriks1[i][j]);
}}
 V-17

printf("Masukkan elemen matrix kedua: \n");

for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
scanf(" %d", &matriks2[i][j]);
}
}
printf("Pengurangan matriks:\n");
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
hasil[i][j] = matriks1[i][j] -
matriks2[i][j];
printf(" %d \t", hasil[i][j]);
} }

// operasi perkalian
printf("\n\n");
printf(" \n #Perkalian Matriks# ");
printf("\nMasukkan jumlah baris matriks
pertama: ");
scanf("%d", &m);
printf("Masukkan jumlah kolom matriks pertama: ");
scanf("%d", &n);

printf("Masukkan jumlah baris matriks kedua: ");

scanf("%d", &p);
printf("Masukkan jumlah kolom matriks kedua: ");
scanf("%d", &q);

if (n != p) {
printf("Matriks tidak dapat dikalikan satu
sama lain.\n");
} else {

printf("Masukkan elemen matriks pertama: \n");

for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
scanf("%d", &matriks1[i][j]);
}
}
printf("Masukkan elemen matriks kedua: \n");
for (i = 0; i < p; i++) {
for (j = 0; j < q; j++) {
scanf("%d", &matriks2[i][j]);
}
}
for (i = 0; i < m; i++) {
for (j = 0; j < q; j++) {
for (k = 0; k < p; k++) {
jumlah = jumlah + matriks1[i][k] *
matriks2[k][j];
}
hasil[i][j] = jumlah;
jumlah = 0;
} }
 V-18

printf("Hasil perkalian matriks: \n");

for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
printf("%d\t", hasil[i][j]);
}
}printf("\n");
}
return 0;
}
Tampilan dilayar
file : “P2070060181.h”

file : “P207006018 1.h”

V-19
 V-20

file : “P2070060181.c”
V-21
V-22
V-23
V-24
 V-25

file : “P207006018m1.c”
V-26
 V-27

Tampilan Outputnya :
 V-28

Analisis :
Gambar diatas merupakan program dari ADT matriks.
ADT hanya terdapat 3 file modul yaitu Type dan prototype,
Realisasi (body) dan Main program untuk mentest beberapa fungsi
atau prosedur. Gambar ADT dengan nama matriks terdapat 4 file
yaitu : P2070060181.h, P207006018 1.h, P2070060181.c,
P207006018m1.c.
 V-29

ADT Matriks fungsinya untuk menyimpan data, ADT

Matriks pada file P207006018m1.c merupakan file main (driver)
dimana terdapat penambahan function dengan perintah
penjumlahan, pemhurangan dan perkalian. Dimana pada
penjumlahan itu jumlah baris dan kolom matriks tersebut
dijumlahkan sehingga menampilkan hasil seperti tampilan di atas 2
+ 2 yang menampilkan elemen matrix pertama dan kedua sebanyak
4 angka dan dari elemen elemen tersebut ditambahkan contohnya
elemen pertama (1,2,3,4) dan elemen kedua (1,2,3,4) maka
hasilnya (2,4,6,8).
Pada pengurangan sama seperti penjumlahan dimana
jumlah matriks dan kolom matriks tersebut dijumlahkan sehingga
menampilkan hasil seperti tampilan di atas 2 + 2 yang
menampilkan elemen matrix pertama dan kedua sebanyak 4 angka
dan dari elemen elemen tersebut dikurang contohnya elemen
pertama (4,5,6,7) dan elemen kedua (1,2,3,4) maka hasilnya
(3,3,3,3).
Pada perkalian dimana jumlah baris dan kolom matriks
tersebut dikalikan sehingga menampilkan hasil seperti tampilan di
atas pada perintah masukkan elemen matriks pertama dapat
memasukan nilai sebanyak 4 angka karena hasil dari perkalian 2 x
2 antara baris matriks pertama dan kolom matriks ke 2. Untuk
perintah masukkan elemen matriks kedua sama seperti pertama
memasukkan nilai sebanyak 4 angka, karenakan pada perintah
masukkan jumlah baris dan kolom matriks kedua diinputkan nilai 2
dan 2 dimana bernilai 2 x 2.
 V-30

1. Int main() adalah fungsi utama dari sebuah kode Bahasa C.

2. Boolean merupakan tipe data yang memiliki dua nilai yaitu
benar (true) atau salah (false). Nilai yang digunakan pada tipe
ini sangat penting dalam mengambil keputusan suatu kejadian
tertentu.
3. #ifndef memeriksa apakah token yang diberikan #defined lebih
awal dalam file atau dalam file disertakan; jika tidak, itu
termasuk kode antara itu dan penutup #else atau, jika #else
ada, #endif pernyataan.
4. #define digunakan untuk mendefinisikan suatu nilai tertentu
kepada suatu nama konstanta.
5. #include adalah sebuah prosesor pengarah yang mengatakan
kepada compiler untuk meletakan kode dari header file
iostream.h kedalam program.
6. Typedef adalah perintah atau keyword Bahasa C yang dipakai
untuk memberikan nama lain atau alias dari tipe data. Struct
merupakan perintah yang dapat digunakan untuk membuat
struktur dari suatu record.
7. Void artinya kosong. Fungsi yang diawali dengan kata kunci
void memiliki makna tidak menghasilkan nilai yang dapat
dikembalikan jika meng-assign fungsi tersebut ke sebuah
variable.
8. Endif digunakan untuk memilih suatu kondisi apakah bernilai
benar (true) atau salah (false).
9. Printf() merupakan fungsi untuk menampilkan output ke layar
komputer.
10. Else adalah pernyataan yang berarti “jika tidak “.
11. Scanf adalah perintah Bahasa C untuk menerima masukan ke
dalam program, yakni sebagai sarana input dari pengguna.
12. Return 0 berarti nilai balik dari suatu fungsi sebuah bilangan 0.