MODULAR

Fakultas Ilmu Komputer

Universitas Katolik Santo Thomas
Pendahuluan
Persoalan yang besar dan kompleks akan sulit
dipecahkan untuk memperoleh suatu solusi yang layak
Program yang besar dan kompleks akan lebih sulit untuk
ditangani jika dibandingkan dengan suatu program yang
lebih pendek.
Kesulitan yang mungkin timbul diantaranya adalah
kesulitan dalam :
o mencari kesalahan yang terjadi terutama kesalahan logika
o kesulitan dalam dokumentasi
o penulisan kode program yang sama dengan tujuan yang
sama secara berulang-ulang.
Pendahuluan
Untuk mengatasi hal tersebut di atas dapat dilakukan dengan memecah
(decomposition) persoalan atau program menjadi beberapa persoalan
atau program yang lebih kecil-kecil (subprogram atau modul).
Tiap subprogram bersifat independen satu dengan yang lain sehingga
program dapat dirancang tanpa mempertimbangkan dimana kelak akan
digunakan.
Tetapi masing-masing subprogram dapat dipasangkan terhadap
subprogram yang membutuhkannya.
Pemrograman  konsep Modular.
Pemrograman modular adalah teknik pemrograman dengan memecah
program yang cukup besar menjadi beberapa program yang lebih kecil.
Modular  Procedure dan Function
Langkah Pembentukan Modular
1. Mendefinisikan masalah dengan membaginya menjadi
tiga komponen : input, proses dan output.
2. Pengelompokan Kegiatan menjadi beberapa sub-kegiatan
atau fungsi untuk menentukan modul yang akan dibentuk.
3. Buatlah diagram hirarki untuk menggambarkan modul
dan hubungan satu sama lain.
4. Menetapkan logika arus utama dari algoritma dalam
pseudocode.
5. Mengembangkan pseudocode untuk setiap modul
berturut-turut di diagram hirarki.
6. Memeriksa algoritma solusi.
Function
Function adalah subprogram yang menerima harga dengan type data
tertentu dan menghasilkan suatu harga sesuai dengan domain yang
didefinisikan pada spesifikasinya.
Suatu function harus diberi nama dan parameter formal
Parameter formal merupakan masukan yang digunakan untuk
menghasilkan keluaran.
Function harus dideklrasikan dalam Kamus.
Function dapat dibagi atas 2, yaitu :
Function standard adalah function yang sudah disediakan oleh bahasa
pemrograman sehingga pemakai tinggal menggunakan atau memanggil.
Function bentukan adalah function yang dibentuk dan diberi nama oleh
pemrogram. Dalam buku ini yang dibahas adalah function bentukan
karena function standard tergantung bahasa pemrograman.
 Pendefinisian Function
Function Nama_Function ([daftar_parameter_Input:type]): type_hasil
{Spesifikasi fungsi}
Kamus Lokal
{Deklarasi semua nama yang ada dalam algoritma yang tidak ada dalam
daftar_parameter}
Algoritma
{deretan aksi berupa : notasi pemberian harga, Input, Output, test
kondisi, pengulangan, pemanggilan function lain atau pemanggilan diri
sendiri(recursif)}
 Return hasil {pengembalian nilai yang dihasilkan function}
Pendefinisian Function
Dimana :
Nama_Function adalah nama dari function
Daftar_parameter_Input (parameter Formal) adalah
nama variabel yang merupakan harga masukan terhadap
function. Daftar_parameter_Input boleh tidak ada yang
berarti bahwa function tidak membutuhkan harga dari
pemanggilnya, jika ada maka disebutkan type datanya.
Type_hasil adalah type data hasil keluaran dari function
Contoh

Function Fungsi_XY(x,y : integer) : Integer

{fungsi untuk menghitung fungsi f(x,y)=x2y+xy2-2x+3y}
Kamus Lokal
{kosong karena x dan y telah ada pada daftar parameter}
Algoritma
Return x*x*y+x*y*y-2*x+3*y
Contoh

Function Fungsi_XY(x,y : integer) : Integer

{fungsi untuk menghitung fungsi f(x,y)=x2y+xy2-2x+3y}
Kamus Lokal
z : Integer
Algoritma
z  x*x*y+x*y*y-2*x+3*y
Return z

a
t
a
u
Contoh

Function Fungsi_XY(x,y : integer) : integer

{fungsi untuk menghitung fungsi f(x,y)=x2y+xy2-2x+3y}
Kamus Lokal
{kosong karena x dan y telah ada pada daftar parameter}
Algoritma
Return x*x*y+x*y*y-2*x+3*y
Pemanggilan Function
Menyebutkan nama Function yang diikuti dengan
daftar parameter input (parameter aktual) jika ada.
Karena function menghasilkan nilai, maka nilai
tersebut dapat ditampung dalam sebuah nama variabel
yang mempunyai type data yang sama dengan nama
function.
Pemanggilan sebuah function dapat dilakukan pada :
Saat pencetakan,
Suatu ekspresi
Hasil function ditampung dalam suatu variabel
 Pemanggilan Function
Judul
{Spesifikasi algoritma}
Kamus
{semua nama yang digunakan dalam algoritma}
Function
Nama_Function([daftar_parameter_Input]):type_hasil
Algoritma
{deretan aksi berupa : notasi pemberian harga, Input, Output,
test kondisi, pengulangan, pemanggilan function/procedure,
ekspresi}
 OUTPUT(Nama_Function(daftar_parameter_aktual))
Nama  ekspresi
Nama  Nama_Function(daftar_parameter_aktual)
Pemanggilan Function
Daftar_parameter_aktual dapat berupa nama variabel, nama konstanta
atau konstanta.
Pada saat pemanggilan function terjadi korespondensi antara
daftar_parameter_input (daftar_parameter_formal) dengan
daftar_parameter_aktual sesuai dengan urutan penulisan dalam
daftar_parameter_input.
Pemanggilan suatu function, beberapa hal berikut harus diperhatikan :
Banyaknya daftar_parameter_aktual harus sama dengan banyaknya
daftar_parameter_input.
Parameter yang bersesuaian antara daftar_parameter_aktual dengan
daftar_parameter_input harus memiliki tipe data yang sama
Nama daftar_parameter_aktual boleh sama dengan nama
daftar_parameter_input.
Pemanggilan Function
Algoritma_Fungsi1
{algoritma menghitung fungsi f(x,y) =x2y+xy2-2x+3y dimana harga x
dan y dibaca dari media masukan }
Kamus
x,y,z : Integer
FXY : Integer
Function Fungsi_XY(x,y : integer) : Integer
Algoritma
INPUT(x)
INPUT(y)
FXY  Fungsi_XY(x,y) {memanggil function Fungsi_XY}
OUTPUT(FXY)
Procedure
Subprogram yang mengerjakan beberapa aksi dengan tujuan
yang spesifik / tertentu dan menghasilkan satu atau lebih
keluaran.
Procedure dapat mempunyai kamus yang disebut dengan kamus
lokal, yaitu tempat mendefinisikan semua nama yang digunakan
dalam procedure yang tidak terdapat dalam daftar parameter.
Penulisan kamus lokal sama saja dengan penulisan kamus
(kamus global).
Semua nama yang didefinisikan dalam kamus lokal hanya
dikenal dalam procedure itu saja.
Procedure harus memiliki definisi yang jelas dan ruang
lingkupnya agar dapat dipanggil secara independent.
Pendefinisian Procedure
Mendefinisikan suatu procedure berarti menentukan nama procedure
serta parameternya (jika ada)
Parameter formal adalah daftar nama yang akan dipakai pada
procedure
Parameter Formal dapat berupa Input, Output atau Input/Output.
Parameter Input : harga parameter pada parameter aktual diisikan
(assign) ke parameter yang bersesuaian pada parameter formal kemudian
digunakan dalam tubuh procedure. Setelah procedure selesai dikerjakan
maka harga dari parameter tidak akan dikembalikan ke pemanggilnya.
Komunikasi hanya terjadi satu arah saja.
Parameter Output : merupakan kebalikan dari Input.
Parameter Input/Output : merupakan kombinasi dari Input dan Output.
 Pendefinisian Procedure

Procedure Nama_Proc ([Input/Output /Input_Output

daftar_Parameter_Formal])
{Spesifikasi procedure}
Kamus Lokal
{mendefinisikan semua nama yang digunakan dalam procedure yang
tidak ada dalam daftar parameter formal}
Algoritma
{Tubuh procedure berupa deretan aksi yang akan dikerjakan oleh
procedure}
Pendefinisian Procedure
Procedure Persegipanjang (Input panjang, lebar : integer,
Output Luas : Integer)
{menghitung luas persegi panjang dengan mengetahui panjang dan lebar
sebagai masukan}
Kamus Lokal

Algoritma
Luas  panjang * lebar
Pemanggilan Procedure
Memanggil procedure adalah menuliskan nama
procedure yang telah didefinisikan, dan memberikan
harga-harga yang dibutuhkan oleh procedure itu pada
parameter aktual.
Sebuah procedure juga boleh menggunakan atau
memanggil procedure yang lain.
Parameter Aktual adalah daftar nama yang digunakan
ketika procedure dipanggil.
 Pemanggilan Procedure
Judul_algoritma
{spesifikasi algoritma}
Kamus
{deklarasi semua nama yang digunakan dalam algoritma}
Procedure Nama_Proc ([Input/Output
daftar_Parameter_Formal])
Agoritma
{deretan aksi yang akan dikerjakan dalam algoritma}
Nama_Proc(daftar_Parameter_aktual])
Pemanggilan Procedure
Ketentuan :
Banyaknya parameter aktual harus sama dengan
banyaknya parameter formal
Nama parameter dalam daftar parameter aktual boleh
berbeda dengan parameter yang bersesuaian pada daftar
parameter formal
Type data yang bersesuaian pada parameter aktual
dengan parameter formal harus sama
Parameter aktual yang berupa Input dapat nama
variabel, nama konstanta atau konstanta, tetapi jika
berupa Output atau Input/Output harus nama variabel.
Pemanggilan Procedure
Algoritma_Persegipanjang
{menghitung luas persegi panjang dimana menghitung luas dilakukan
dalam fungsi}
Kamus
Panjang, Lebar : Integer
Luas : Integer
Procedure Persegipanjang( Input panjang, lebar : Integer, Output
Luas : Integer)
Agoritma
Input(Panjang)
Input(Lebar)
Persegipanjang(Panjang, Lebar, Luas)
Output(Luas)
Contoh 1.
Buat algoritma untuk membaca tiga buah bilangan
bulat x, y dan z kemudian tentukan bilangan terbesar
dari ketiga bilangan dimana untuk menentukan
bilangan terbesar dari dua buah bilangan tersebut
dilakukan dalam function BESAR.
 Contoh 1.
Function Besar(x,y,z : integer) : Integer
{fungsi untuk menentukan bilangan terbesar dari tiga bilangan}
Kamus Lokal
Max : Integer
Algoritma
If(x>y) Then
Max = x;
Else
Max = y;
E-If
If(Max>z) Then
Return Max;
Else
Return z;
E-If
 Contoh 1.
Algoritma_Maksimum
{algoritma membaca tiga bilangan bulat kemudian menentukan
bilangan terbesar dari ketiga bilangan }
Kamus
x,y,z : Integer
Hasil : Integer;
 Function Besar(x,y,z : integer) : Integer
Algoritma
INPUT(x)
INPUT(y)
INPUT(z)
Hasil  Besar(x,y,z)) {memanggil function Besar}
OUTPUT(Hasil)
Contoh 2.
Soal : Buatlah algoritma untuk membaca dua buah (x dan y)
bilangan bulat kemudian hitung perpangkatan kedua bilangan
dengan melakukan perkalian x sebanyak y, dimana untuk menghitung
perpangkatan kedua bilangan dilakukan dalam function PANGKAT

Penyelesaian : perpangkatan dua bua bilangan x dan y dapat

dilakukan dengan perkalian x sebanyak y, dengan kemungkinan
bahwa :
Jika y positip maka lakukan perkalian x sebanyak y khusus y=1 maka x
pangkat y sama dengan x)
Jika y = 0 maka x pangkat y sama dengan 1
Jika y negatip maka x pangkat y adalah (1 /x^y) dimana x^y dilakukan
dengan perkalian x sebanyak y juga
 Contoh 2.
Function Pangkat(x,y : integer) : Integer
{fungsi menghitung x pangkat y}
Kamus Lokal
i : Integer
z : Real
Algoritma
If (y=0) Then Return 1;
Else If(y=1) Then Return x;
Else If(y>1) Then
For i1 To y Do z=z*x;
return z;
Else If(y<0) Then
y = -y; //pangkat minus menjadi positip
For i1 To y Do z=z*x;
Return (1.0/z);
E-If
Contoh 2.
Algoritma_Hitung_Pangkat
{fungsi untuk membaca dua buah bilangan bulat x dan y
kemudian menghitung x pangkat y}
Kamus
x, y : Integer
Algoritma
INPUT(x)
INPUT(y)
OUTPUT(Pangkat(x,y))
Contoh 3.
Soal :Buatlah algoritma untuk membaca sebuah
bilangan bulat n, kemudian hitunglah factorial dari
bilangan n. menghitung factorial dilakukan dalam
Function FAKTORIAL.

 Penyelesaian : Suatu bilangan yang dibaca dihitung

Faktorialnya. Jika bilangan = 0 atau bilangan = 1maka
Faktorialnya sama dengan 1 (0!=1!=1), tetapi untuk
bilangan lebih besar dari 1 sama dengan perkalian
bilangan mulai satu hingga n (1x2x3x..xn). Misalnya
n=5, maka 5!=1x2x3x4x5 = 120
Contoh 3.
Function Faktorial(n : integer) : Integer
{fungsi untuk menghitung factorial suatu bilangan yang
dibaca dari media masukan}
Kamus Lokal
Faktor, i : Integer
Algoritma
Faktor  1
if(n=0 OR n=1)
return 1
else
for(i=1; i<=n; i++)
Faktor=Faktor*i
End For
return Faktor;
E-If
Contoh 3.
Algoritma_Faktorial
{algoritma membaca sebuah bilangan bulat n, kemudian
menghitung factorial dari n}
Kamus
n : Integer
 Function Faktorial(n : integer) : Integer
Algoritma
INPUT(n)
OUTPUT(Faktorial(n))
Contoh 4.
 
Soal : Buatlah algoritma untuk menghitung nilai
dimana menghitung xn dilakukan dalam Function
PANGKAT dan menghitung factorial dari bilangan (n!)
dilakukan di Function FAKTORIAL.

Penyelesaian : kalau diperhatikan suku demi suku,

maka suku pertama adalah =1. Berarti perulangan
dapat kita mulai dari 0 (nol) hingga n, dimana nilai x
dan n dibaca dari media masukan. Function
PANGKAT dan Function FAKTORIAL dapat
menggunakan function pada contoh sebelumnya
Contoh 4.
Algoritma_Deret
{algoritma menghitung deret }
Kamus
Kamus
n, i : Integer
n, i : Integer
Hasil : Real
Hasil : Real
 Function Faktorial(n : integer) : Integer
 Function Faktorial(n : integer) : Integer
Function Pangkat(x integer, y : integer) : Integer
Function Pangkat(x integer, y : integer) : Integer
Algoritma
Algoritma
INPUT(n)
INPUT(x)
INPUT(n)
For i 0 To n Do
INPUT(x)
Hasil
For i = Hasil
0 To + (Pangkat(x,i)/Faktorial(i))
n Do
E-For
Hasil = Hasil + (Pangkat(x,i)/Faktorial(i))
OUTPUT(Hasil)
E-For
OUTPUT(Hasil)
Contoh 5.
Soal : Buatlah algoritma untuk membaca dua buah
bilangan bulat M dan N, kemudian lakukanlah
pertukaran harga kedua bilangan. Pertukaran kedua
bilangan dilakukan dalam procedure TUKAR.
Penyelesaian : karena kedua buah bilangan yang akan
dipertukarkan didalam kedua nama variabel sehingga
mengakibatkan harga yang berubah dalam modul
harus juga berubah di fungsi yang memanggilnya.
Dengan demikian karena yang berubah adalah harga
dari kedua nama, maka kedua nama adalah sebagai
berupa input sekaligus output (input/output)
Contoh 5.

Procedure Tukar(Input/Output X, Y : Integer)

{procedure menukarkan dua buah harga}
Kamus Lokal
Temp : Integer
Algoritma
Temp = X
X=Y
Y = Temp
Contoh 5.
Algoritma_Tukar
{membaca dua bilangan kemudian saling menukarkan kedua
bilangan}
Kamus
M, N : Integer
Procedure Tukar(Input/Output X, Y : Integer)
Algoritma
Input(M)
Input(N)
Tukar(M, N)
Output(M, N)
Contoh 6.
Soal : Buatlah algoritma untuk membaca dua buah bilangan bulat M
dan N (M≥N), jika M<N maka lakukan terlebih dahulu pertukaran
harga. Hitunglah pembagi bersama terbesar dari kedua bilangan bulat

Penyelesaian : dalam menghitung Pembagi Bersama Terbesar dari dua

buah bilangan maka bilangan pertama harus lebih besar dari bilangan
kedua. Jika bilangan pertama lebih kecil dari bilangan kedua maka
lakukan pertukaran terlebih dahulu. Parameter pada Procedure
Hitung_PBT ada tiga yaitu M dan N adalah harga yang akan diproses,
perubahan nilai M dan N dalam Procedure tidak harus diikuti perubahan
M dan N dalam modul pemanggil, sehingga parameter M dan N berupa
input. Sedangkan parameter Pbt adalah merupakan parameter hasil
artinya perubahan harga dalam procedure juga harus berubah di dalam
modul pemanggil, sehingga parameter Pbt harus berupa Output.
Contoh 6.
Procedure Hitung_PBT(Input M : Integer, Input N : Integer,
Output Pbt : Integer)
{procedure menghitung PBT dari M dan N}
Kamus Lokal
R : Integer
Algoritma
Repeat
R  M Mod N
IF (R=0) Then
Pbt  N
Else
MN
NR
End If
Until R=0
 Contoh 6.
Algoritma_Hitung_PBT
{algoritma menghitung pembagi bersama terbesar dari dua bilangan
bulat}
Kamus
M, N, Pbt, Temp : Integer
Procedure Hitung_PBT(Input M : Integer, Input N : Integer,
Output Pbt : Integer)
Algoritma
Input(M, N)
If(M<N) Then
Temp  M
MN
N  Temp
End If
Hitung_PBT(M, N, Pbt)
Output(Pbt)
Contoh 6.
Perhatikan algoritma di atas, bahwa jika harga M<N
maka dilakukan terlebih dahulu pertukaran harga.
Karena contoh satu di atas telah ada Procedure
TUKAR untuk menukarkan dua buah harga maka kita
tidak perlu lagi menuliskan algoritma pertukaran harga
tetapi langsung memanggil procedure TUKAR di atas,
maka algoritma di atas menjadi seperti berikut.
Contoh 6.
Procedure Tukar(Input/Output X, Y : Integer)
{procedure menukarkan dua buah harga}
Kamus Lokal
Temp : Integer
Algoritma
Temp = X
X=Y
Y = Temp
Contoh 6.
Procedure Hitung_PBT(Input M : Integer, Input N : Integer,
Output Pbt : Integer)
{procedure menghitung PBT dari M dan N}
Kamus Lokal
R : Integer
Algoritma
Repeat
R  M Mod N
IF (R=0) Then
Pbt  N
Else
MN
NR
End If
Until R=0
 Contoh 6.
Algoritma_Hitung_PBT
{algoritma menghitung pembagi bersama terbesar dari dua bilangan bulat}
Kamus
M, N, Pbt : Integer
Temp : Integer
 Procedure Hitung_PBT(Input M : Integer, Input N : Integer, Output Pbt :
Integer)
Procedure Tukar(Input/Output X, Y : Integer)
Algoritma
Input(M)
Input(N)
If(M<N) Then
Tukar(M, N)
End IF
Hitung_PBT(M, N, Pbt)
Output(Pbt)
Contoh 7.
Buatlah algoritma untuk membaca sederetan bilangan
bulat kemudian hitunglah jumlah dan rata-rata
sederetan bilangan, Tentukan bilangan genap dan
bilangan ganjil dari sederetan bilangan, hitung jumlah
dan rata-rata bilangan ganjil dan bilangan genap serta
cetak semua bilangan genap dan bilangan Ganjil
jumlah dan rata-rata.
Contoh 7.
Procedure Baca(Input/Output Nilai : Data,
Input N : Integer)
{procedure untuk membaca sederetan bilangan}
Kamus Lokal
i : integer
Algoritma
For i1 To N Do
Input(Nilai[i])
End For
Contoh 7.

Procedure Cetak(Input Nilai : Data,

Input N : Integer)
{procedure untuk mencetak sederetan bilangan}
Kamus Lokal
i : integer
Algoritma
For i1 To N Do
Output(Nilai[i])
End For
Contoh 7.
Procedure Jumlah(Input Nilai : Data, Input N : Integer,
Output Jum : Integer)
{procedure untuk menghitung jumlah sederetan bilangan}
Kamus Lokal
i : integer
Algoritma
For i1 To N Do
Jum <- Jum + Nilai[i]
End For
 Contoh 7.
Procedure Genap_Ganjil(Input Nilai : Data, Input N : Integer,
Output Genap,Ganjil : Data, Output
Byk_Gjl,Byk_Gnp:Integer)
{procedure untuk menentukan bilangan genap dan bilangan ganjil}
Kamus Lokal
i : integer
Algoritma
FOR i  1 TO N DO
IF (Nilai[i] MOD 2 = 0) THEN
Byk_GnpByk_Gnp + 1 {Banyak Bilangan Genap}
Genap[Byk_Gnp]  Nilai[i] {Bilangan Genap}
ELSE
Byk_GjlByk_Gjl + 1 {Banyak Bilangan Ganjil}
Ganjil[Byk_Ganjil] Nilai[i] {Bilangan Ganjil}
END IF
END FOR
Algoritma_Genap_Ganjil
{membaca sederetan bilanga kemudian hitung jumlah dan rata-rata, menentukan bilangan genap dan bilangan,
menghitung jumlah dan rata-rata bilangan genap dan bilangan ganjil}
Kamus
Data : ARRAY[1..N] OF Integer
Nilai, Genap, Ganjil : Data
N, Byk_Gnp, Byk_Gjl,Jum, Jum_Gnp, Jum_Gjl : Integer
Rata, Rata_Gnp, Rata_Gjl : Real
Procedure Baca(Input/Output Nilai : Data, Input N : Integer)
Procedure Cetak(Input Nilai : Data, Input N : Integer)
Procedure Jumlah(Input Nilai : Data,Input N : Integer, Output Jum : Integer)
Procedure Genap_Ganjil(Input Nilai : Data, Input N : Integer, Output Genap,Ganjil : Data,
Output Byk_Gjl,Byk_Gnp:Integer)
Algoritma
INPUT(N) {Banyak bilangan yang akan dibaca}
Baca(Nilai, N) {memanggil procedure Baca}
Cetak(Nilai, N) {memanggil procedure Cetak}
Jumnlah(Nilai, N, Jum) {memanggil procedure Jumlah}
Rata  Jum / N
Output(Jum, Rata)
Genap_Ganjil(Nilai, N, Genap, Ganjil, Byk_Gnp,Byk_Gjl)
Cetak(Genap, Byk_Gnp)
Jumlah(Genap, Byk_Gnp, Jum_Gnp) {Jumlah Bilangan Genap}
Rata_Gnp  Jum_Gnp / Byk_Gnp {Rata Bilangan Genap}
Output(Jum_Gnp, Rata_Gnp)
Cetak(Ganjil, Byk_Gjl)
Jumlah(Ganjil, Byk_Gjl, Jum_Gjl) {Jumlah Bilangan Ganjil}
Rata_Gjl  Jum_Gjl / Byk_Gjl {Rata Bilangan Ganjil}
Output(Jum_Gjl, Rata_Gjl)