PEMROGRAMAN MODULAR adalah suatu teknik pemrograman di mana program yang biasanya cukup besar dibagi-bagi menjadi beberapa bagian program yang lebih kecil . Dalam beberapa bahasa pemrograman disebut : sub-rutin, modul, prosedur, atau fungsi.

STRUKTUR POHONPROGRAM A

SUBPROGRAM A1

SUBPROGRAM A2

SUBPROGRAM A3

SUBPROGRAM A21

SUBPROGRAM A22

ILUSTRASIDEKLARASI A, B, Temp : integer ALGORITMA{ baca nilai A dan B}

read(A) read(B){proses pertukaran}

temp A AB B temp{ tulis nilai A dan B setelah pertukaran }

output(A) output(B)

Dipecah subprogramDEKLARASI A, B : integer Baca(A,B:Integer) ALGORITMA: read(A) read(B) Tukar(A, B:integer) DEKLARASI temp : integer {peubah bantu} ALGORITMA temp A AB B temp Tulis(A,B : integer) ALGORITMA output(A) output(B) ALGORITMA Baca(A,B) Tukar(A,B) Tulis(A,B)

KEUNTUNGAN Pemrogram Modular

1. Program lebih pendek 2. Mudah menulis (banyak programer) 3. Mudah dibaca dan dimengerti (bandingkan dg nonmodular dg banyak instruksi) 4. Mudah didokumentasi 5. Mengurangi kesalahan dan mudah mencari kesalahan(debug) program 6. Kesalahan yang terjadi bersifat lokal

Dua bentuk pemrogram modular : PROSEDUR dan FUNGSI Struktur setiap subprogram tersebut pada hakekatnya sama , yaitu : Nama modul (subprogram) Bagian deklarasi Algoritma (intruksi yg akan dilaksanakan)

Perbedaan penggunaannya dalam bahasa pemrograman Pascal : Prosedur merupakan modul(subprogram) yg melakukan aktifitas tertentu tanpa adanya pengembalian nilai Fungsi terdapat pengembalian nilai

PROSEDUR Dalam bahasa pemrograman Prosedur adalah modul program yang mengerjakan tugas/aktifitas yg spesifik dan menghasilkan suatu efek netto(membandingkan keadaan awal dan keadaan akhir dari suatu aktifitas prosedur)

Setiap prosedur perlu mendefinisikan keadaan awal sebelum rangkaian instruksi di dalam prosedur dilaksanakan, dan keadaan akhir yg diharapkan setelah instruksi di dalam prosedur dilaksanakan

STRUKTUR PROSEDUR JUDUL (header) nama prosedur dan deklarasi parameter(kalau ada) DEKLARASI mengumumkan namanama dan tipe data ALGORITMA badan prosedur (instruksi)

*sama dengan struktur ALGORITMA

Nama Prosedur Nama yang unik Sebaiknya diawali dengan kata kerja karena prosedur berisi suatu aktifitas Misalnya: HitungLuas, Tukar, CariMaks, Tulis, dll.

Parameter Adalah nama-nama peubah (variabel) yang dikdeklarasikan pada bagian header (judul) prosedur dan titik dimana dia dipanggil. Penggunaan parameter menawarkan mekanisme pertukaran informasi (antara yg memanggil (program/algoritma utama) dg prosedur itu sendiri)

Parameter dibedakan menjadi dua : Parameter aktual (argumen) : Parameter yg disertakan pada waktu pemanggilan prosedur (parameter yg ada pada program/algoritma utama).

Parameter formal : Parameter yg dideklarasikan di dalam bagian header prosedur itu sendiri.

Ketika prosedur dipanggil, parameter aktual menggantikan parameter formal. Tiap-tiap parameter aktual berpasangan dengan parameter formal yg bersesuain (berkorespondasi satu satu)

Notasi algoritma untuk PROSEDURProcedure NamaProsedur(deklarasi parameter, jika ada){spesifikasi prosedur, berisi penjelasan tentang apa yg dilakukan oleh prosedur ini. K.awal : keadaan sebelum prosedur dilaksanakan. K. akhir : keadaan setelah prosedur dilaksanakan}

DEKLARASI{semua nama yg dipakai di dalam prosedur dan hanya berlaku lokal di dalam prosedur ini}

ALGORITMA{badan prosedur, berisi urutan instruksi}

Pendeklarasian Parameter dalam prosedur bukanlah keharusanContoh : Procedure HitungLuasSegitiga{menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : sembarang} {K.akhir : luas segitiga tercetak}

DEKLARASIAlas, tinggi, luas : real

ALGORITMARead(alas, tinggi) Luas (alas * tingg) / 2 Write(luas)

Pemanggilan Prosedur Prosedur bukan program yg beridiri sendiri Prosedur tidak dapat dieksekusi secara langsung. Instruksi-instruksi di dalam prosedur dapat dilaksanakan bila prosedur itu diakses. Prosedur diakses dg cara memanggil namanya dari program pemanggil (misalnya dari program utama atau modul program lainnya) Jika prosedur tanpa parameter, maka pemanggilannya cukup dg nama prosedurnya saja, contoh : HitungLuasSegitiga

Notasi Algoritma :PROGRAM Segitiga{menghitung luas segitiga}

DEKLARASI Procedure HitungLuasSegitiga{menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : sembarang} {K.akhir : luas segitiga tercetak}

DEKLARASIAlas, tinggi, luas : real

ALGORITMARead(alas, tinggi) Luas (alas * tinggi) / 2 Write(luas)

ALGORITMA HitungLuasSegitiga

KUIS BUATLAH NOTASI ALGORITMA UNTUK MELAKUKAN PEMANGGILAN PROSEDUR LUASSEGITIGA SEBANYAK 3 X

Nama Global dan Nama Lokal Nama Lokal :Nama-nama (Konstanta, peubah(variabel), tipe, dll) yang dideklarasikan di dalam prosedur (termasuk parameter, jika ada). (hanya dikenal/digunakan dalam lingkup (scope) prosedur tersebut

Nama Global :Nama-nama (Konstanta, peubah(variabel), tipe, dll) yang dideklarasikan di dalam program utama. (dapat dikenal/digunakan dibagian manapun dalam program (progam utama maupun prosedur).

PROGRAM Segitiga{menghitung luas N buah segitiga}

DEKLARASI I, N : integer alas, tinggi : real Procedure HitungLuasSegitiga{menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : sembarang} {K.akhir : luas segitiga tercetak}

DEKLARASIluas : real

ALGORITMALuas (alas * tinggi) / 2 Write(luas)

ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(alas, tinggi HitungLuasSegitiga endfor _______________________________________________________________ Nama Peubah (variabel) I, N, alas, tinggi variabel GLOBAL Nama Peubah (variabel) luas variabel LOKAl

Menggunakan variabel Global atau variabel Lokal Bila suatu peubah (variabel) digunakan di seluruh bagian program (baik program utama maupun prosedur), maka deklarasikanlah peubah tsb secara Global. Bila suatu peubah (variabel) hanya digunakan di dalam prosedur, maka deklarasikanlah peubah tsb secara Lokal. Gunakan peubah global sedikit mungkin Penggunaan variabel lokal membuat program lebih elegan Penggunaan variabel lokal dapat meminimumkan usaha pencarian kesalahan yg disebabkan oleh nama-nama tsb.

Parameter Prosedur yg baik adalah prosedur yg independen dari program utama/ program yg memanggilnya. Prosedur yg baik tidak menggunakan peubah-peubah global di dalam prosedur. Jika program utama perlu mengomunikasikan nilai peubah Global ke dalam prosedur, maka gunakanlah PARAMETER.

Parameter - next Penggunaan parameter adalah mekanisme pertukaran informasi antara prosedur dengan yang memaggilnya (program utama maupun subprogram lainnya). Prosedur dengan parameternya (Parameter Formal) dapat diakses dg cara memanggil namanya dari program yg memanggilnya yg disertai dg parameter dari program yg memanggil tsb (Parameter Aktual). Contoh: NamaProsedur(parameter aktual)

Tiap parameter aktual berpasangan dg paramater formal yg bersesuaian

Parameter - next Ketika prosedur dipanggil, parameter aktual berkoresponden satu-satu dengan parameter formal (parameter yg dideklarasikan pada bagian header prosedur)

Aturan korespondensi satu satu Jumlah parameter aktual harus sama dengan jumlah parameter formal. Tiap parameter aktual harus bertipe sama dengan tipe parameter formal yg sesuai. Tiap parameter aktual harus diekspresikan dalam cara yg taat azas dg parameter formal yg bersesuaian, bergantung pada jenis parameter formal.

Jenis parameter formal yg disertakan di dalam prosedur : Parameter Masukan (input parameter) :Parameter yg nilainya berlaku sebagai masukan untuk prosedur.

Parameter Keluaran (Output parameter):Parameter menampung keluaran yg dihasilkan oleh prosedur.

Parameter masukan/keluaran (input/output parameter) :Parameter yg berfungsi sebagai masukan sekaligus keluaran bagi prosedur tsb.

Parameter masukan Nilai parameter aktual diisikan ke dalam parameter formal yg sesuai. Perubahan nilai parameter di dalam badan prosedur tidak mengubah nilai parameter aktual. Nama parameter aktual boleh berbeda dg nama parameter formal yg sesuai

Contoh : paramater masukanProcedure HitungLuasSegitiga(input alas, tinggi : real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya} {K.akhir : luas segitiga tercetak}

DEKLARASIluas : real

ALGORITMALuas (alas * tinggi) / 2 Write(luas)

Program utama yg memanggil nama prosedur: harus mendeklarasikan nama prosedur dan memanggilnya dg parameter aktual yg sesuaiPROGRAM Segitiga{menghitung luas N buah segitiga}

DEKLARASI I, N : integer alas, tinggi : real Procedure HitungLuasSegitiga(input alas, tinggi : real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya } {K.akhir : luas segitiga tercetak}

DEKLARASIluas : real

ALGORITMALuas (alas * tinggi) / 2 Write(luas)

ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(alas, tinggi HitungLuasSegitiga(alas,tinggi) endfor

nama parameter aktual tidak harus sama dengan nama parameter formal : yg dipentingkan adalah nilainyaPROGRAM Segitiga{menghitung luas N buah segitiga}

DEKLARASI I, N : integer a, t : real Procedure HitungLuasSegitiga(input alas, tinggi : real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya } {K.akhir : luas segitiga tercetak}

DEKLARASIluas : real

ALGORITMALuas (alas * tinggi) / 2 Write(luas)

ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(a, t) HitungLuasSegitiga(a,t) endfor

Parameter aktual boleh berupa ekspresi atau konstantaContoh : HitungLuasSegitiga(a*0.2, t*0.1) HitungLuasSegitiga(12, 6)

Parameter keluaran Parameter keluaran dideklarasikan di dalam header prosedur, sebagaimana parameter masukan Parameter keluaran dideklarasikan dengan keyword OUTPUT. Ketika prosedur yg mengandung parameter keluaran dipanggil, maka nama parameter aktual menggantikan (substitute) nama parameter formal yg bersesuaian.

Contoh : parameter keluaran-nextPROGRAM Segitiga{menghitung luas N buah segitiga}

DEKLARASI I, N : integer a, t, L : real Procedure HitungLuasSegitiga(input alas, tinggi : real, output luas:real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya } {K.akhir : luas segitiga tercetak}

ALGORITMALuas (alas * tinggi) / 2

ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(a, t) HitungLuasSegitiga(a, t, L)Write(L)

endfor

Parameter masukan/keluaran Prosedur harus dapat mengakomodasi baik masukan dari dan keluaran ke blok program pemanggil Maka gunakan parameter masukan/ keluaran Bila parameter aktual diubah nilainya di dalam badan prosedur, maka sesudah pemanggilan prosedur nilai parameter aktual di titik pemanggilan juga berubah Parameter masukan/keluaran dideklarasikan di dalam header prosedur dengan keyword INPUT/OUTPUT Parameter aktual harus berupa peubah, tidak boleh berupa ekspresi atau konstanta

Contoh : parameter masukan/keluaranPROGRAM Cetak0Sampai10 { mencetak nilai dari 0 sampai 10 }DEKLARASI x : integer procedure Inc(input/output x : integer) {menaikan nilai x sebesar 1} {K.Awal : x sudah terdefinisi nilainya} {K.Akhir : nilai x bertambah 1} DEKLARASI ALGORITMA xx+1 ALGORITMA X0 repeat write(x) inc(x) until x > 10

Parameter masukan

-

parameter masukan/keluaranPROGRAM xyz DEKLARASI a, b : integer Procedure tambah(input/output x,y:integer) Deklarasi Algoritma xx+4 Y y +4 write(nilai x dan y di akhir prosedur tambah:) Write( x=, x) Write( y=, y) ALGORITMA a 15 B 10 Write(nilai a dan b sebelum panggil prosedur tambah:) Write( a=, a) Write( b=, b) Tambah(a,b) Write(nilai a dan b sesudah panggil prosedur tambah:) Write( a=, a) Write( b=, b)

PROGRAM xyz DEKLARASI a, b : integer Procedure tambah(input x,y:integer) Deklarasi Algoritma xx+4 Y y +4 write(nilai x dan y di akhir prosedur tambah:) Write( x=, x) Write( y=, y) ALGORITMA a 15 B 10 Write(nilai a dan b sebelum panggil prosedur tambah:) Write( a=, a) Write( b=, b) Tambah(a,b) Write(nilai a dan b sesudah panggil prosedur tambah:) Write( a=, a) Write( b=, b)

Program dg prosedur atau tanpa prosedur Dianjurkan menulis program yg modular Program yg dipecah menjadi beberapa prosedur menunjukkan teknik pemrograman yg baik dan terstruktur

Prosedur dg parameter atau tanpa parameter Dianjurkan menulis prosedur dg parameter Parameter dapat mengurangi kebutuhan penggunaan peubah (variabel) global

Parameter masukan atau parameter keluaran Bila prosedur menghasilkan keluaran yg digunakan oleh program pemanggil, gunakan parameter keluaran untuk menampung keluaran tsb. Bila prosedur tidak menghasilkan keluaran, atau kalaupun menghasilkan keluaran tapi keluaran tsb hanya digunakan di dalam prosedur itu saja, maka gunakan parameter masukan. Bila prosedur menerima masukan sekaligus keluaran pada parameter yg sama, gunakan parameter masukan/keluaran.

Analisa kasus :menentukan jam berikutnya setelah ditambah satu detik1. Tambah detik dengan 1, jika jumlah detik 0 basis : xy = 1 jika y = 0 rekurens : xy = a x xy-1 }

Deklarasi Algoritma: if y = 0 then return 1 else return x*PangkatRekursif(x, y-1) endif

Pangkat dalam Bahasa Pascalprogram pangkatrekursif; uses wincrt;

var a, n: integer;Function pangkat(a, n : integer ) : integer; Begin If n = 0 then pangkat:= 1 Else pangkat:=a*pangkat(a,n-1); End; begin a:=10; write('masukan pangkat:'); readln(n); writeln(a, pangkat ',n,' adalah: ',pangkat(a,n):10); end.

Procedure rekursif Deklarasi Algoritma: Write(Informatika UHAMKA) rekursif

Program rekursi Deklarasi Batas : word Prosedur rekursif Deklarasi Algoritma: If batas < 7 then Write(Informatika UHAMKA) Batas batas + 1 Rekursif Endif Algoritma: Batas 0 Rekursif

Program urut Deklarasi N:word Prosedur deret(input n word) Deklarasi Algoritma: Write(N:3) If N < 10 then Deret(N+1) endif Algoritma: N0 Deret(N)

Menghitung nilai FAKTORIALFaktorial (0) = 1 : Nilai awal Faktorial (n) = n * faktorial(n-1) : Rekurent faktorial (4) = 4 * faktorial (3) 3 * faktorial (2) 2 * faktorial (1) 1 * faktorial (0) 1 =4*3*2*1*1 = 24 __________________________________________________ function faktorial (input nilai : integer) : integer DEKLARASI

ALGORITMA: if nilai maks? Ya A[5] >maks? Ya A[6] > maks? tidak A[7] > maks? tidak A[8] >maks? Tidak maks A[1] (maks=158) maks tidak berubah maks A[3] (maks=162) maks A[4] (maks=169) maks A[5] (maks=172) maks tidak berubah maks tidak berubah maks tidak berubah

(proses pembandingan selesai) Didapat : maks = 172 (nilai maksimum array yang ditemukan)

Algoritma untuk maks = -999Program NilaiMaksimum DEKLARASI : Const N = 8 A : array[1..N] of integer = (158, 157, 162, 169, 172, 155, 170, 163) I, maks : integer

ALGORITMA : Maks -9999 {nilai maksimum sementara} For i 1 to N do If A[i] > maks then Maks A[i] endif endfor Write(maks)

Cara 2: Mencari nilai Maksimal1. Nilai maksimum sementara diinisialisasikan dengan elemen pertama array. 2. selanjutnya, arrray dikunjungi mulai dari elemen kedua 3. setiap kali mengunjungi elemen array, bandingkan elemen tersebut dengan nilai maksimum sementara. 4. jika elemen array yang sedang dintinjau lebih besar dari nilai maksimum sementara, maka (maks) diganti dengan elemen tersebut. 5. pada akhir kunjungan (setelah seluruh elemen array dikunjungi), nilai maksimum sementara menjadi nilai maksimum sebenarnya.

Ilustrasi untuk maks : elemen pertamaA `158 157 162 169 172 155 170 163

1

2

3

4

5

6

7

8

Asumsi : maks = A[1] (nilai maksimum sementara, maks=158) A[2] >maks? Tidak A[3] > maks? Ya A[4] > maks? Ya A[5] >maks? Ya A[6] > maks? tidak A[7] > maks? tidak A[8] >maks? Tidak maks tidak berubah maks A[3] (maks=162) maks A[4] (maks=169) maks A[5] (maks=172) maks tidak berubah maks tidak berubah maks tidak berubah

(proses pembandingan selesai) Didapat : maks = 172 (nilai maksimum array yang ditemukan)

Algoritma untuk maks = Elemen pertamaProgram NilaiMaksumum DEKLARASI : Const N = 8 A : array[1..N] of integer = (158, 157, 162, 169, 172, 155, 170, 163) I, maks : integer

ALGORITMA : Maks A[1] {nilai maksimum sementara} For i 2 to N do If A[i] > maks then Maks A[i] endif endfor Write(maks)

Cara 3: Mencari nilai Maksimal Mencari nilai maksimal berdasarkan nomor indeks array. Algoritma : idxMaks 1 for I 2 to n do if A[i] > A[idxMaks] then idxMak I endif endfor

Mencari Nilai Minimum Array (Larik) Mencari elemen larik yang mempunyai nilai terkecil di antara elemen larik lainnya. Konsepnya sama dengan Mencari nilai maksimum array

Latihan Buatlah algoritma untuk mencari nilai terbesar dari data yang sudah tersimpan pada elemen array, dimana nilai yang tersimpan pada elemen array tersebut di baca dari inputan eksternal (keyboard). Konversikan algoritma di atas ke dalam Bahasa Pascal

Menyalin Larik (Array)A ` B `1 2 3 4 5 6 7 8

158

157

162

169

172

155

170

163

1

2

3

4

5

6

7

8

Algoritma Menyalin LarikProgram Salin DEKLARASI: Const maks=100 A:array[1..maks] of integer B:array[1..maks] of integer I,n : integer ALGORITMA: Read(n) {menentukan jumlah elemen yang akan digunakan} {membaca nilai dari inputan eksternal (keyboard)} For I 1 to n do read(A[i]) Endfor {menyalin Larik A ke Larik B} for I 1 to n do B[i] A[i] endfor {Menampilkan nilai elemen array B setelah dilakukan penaylinan dari elemen array A} For I 1 to n do write(B[i]) endfor

Menguji kesamaan dua buah Larik Dilakukan dengan membandingkan setiap elemen yang berpadanan pada ke dua larik tersebut Jika ditemukan satu saja elemen yang tidak sama, maka dapat dipastikan dua buah larik tersebut tidak sama. Apabila semua elemen dari larik itu sama, maka dapat dikatakan dua buah larik itu sama.

Menguji kesamaan dua buah Larik - next123 130 140 160 180

A `

1

2

3

4

5

B `

123 130 140

160

180

1

2

3

4

5

Algoritma menguji kesamaan larikProgram uji DEKLARASI Const maks=5 A:array[1..maks] of integer=(123,130,140,160,180) B:array[1..maks] of integer=(123,130,140,160,180) I : integer Sama : boolean ALGORITMA: I 1 Sama true While (I maks) and (sama) do if A[i] = B[i] then I I + 1 {tinjau elemen berikutnya} else sama false endif Endwhile { I > maks or sama=false } {tampilkan hasil} If sama true then write(dua larik sama) Else write(dua larik berbeda) endif

ARRAY DUA DIMENSI (MATRIKS) Pengertian array dua dimensi : Array dua dimensi dapat dipandang sebagai gabungan array satu dimensi. Ilustrasi :Pandanglah tiga buah array satu dimensi yang dibuat dengan: A1[4], A2[4], A3[4] : dengan tipe data yang sama

ARRAY DUA DIMENSI (MATRIKS)-next Ketiga buah array satu dimensi di atas, dapat digabung menjadi satu, sehingga terbentuk sebuah array yang disebut array dua dimensi, yang dapat diilustrasikan sebagai berikut :

Dari ilustrasi diatas, terlihat array tersebut terdiri dari 3 baris, dan 4 kolom, dan jumlah elemennya = 3 x 4 = 12 elemen, karena terdiri dari baris (row) dan kolom (column) maka arrray dua dimensi sering disebut MATRIX. Karena sudah menjadi satu buah array, maka nama array hanya satu buah, Misalnya A[3] [4] yang maksudnya adalah terdiri barisnya ada 3, dan kolomnya ada 4.

Bentuk Umum Array Dua Dimensi

Array konstan untuk array dua dimensi (matriks) Cotoh: Array Dua Dimensi dengan matriks : 3 x 5, dengan tipe data integer dan char :

Mengisi Elemen Array Dua Dimensi (MATRIKS) Diketahui array dua dimensi : A : array[1..3, 1..4] of integer

Untuk keperluan praktis dan keragaman, indeks untuk baris dan kolom menggunakan variabel. Misal : i untuk baris dan J untuk kolom

Algoritmanya : I 2 J3 A[i, j] 17

Isi Elemen Matriks per baris atau per kolom

Pengisian semua elemen Matriks secara baris perbaris :

Algoritmanya : N 1 I1 While (i