EzMatrix – Unit Perhitungan Matrix Yang Tjanggih (Turbo Pascal)


ezmatrix_tp55

Pernahkan Anda membuat program matrik? Kalau pernah, Anda pasti tahu bagaimana rasanya mengetik program yang panjang dan njelimet. Anda pasti telah merasakan bahwa membuat program matrik tidak hanya memakan waktu, tapi juga ‘memakan’ otak dan pikiran.

Bagi Anda yang belum pernah membuat program matrik, percaya saja deh, program matrik itu nggak ada yang sederhana.ūüėÄ

Namun demikian, meskipun program matrik tergolong program yang tidak mudah dibuat, tapi bukan berarti tidak bisa dibuat mudah. Dengan bantuan sebuah unit yang canggih, kita bisa mengubah kebiasaan memrogram matrik yang lama dan njelimet menjadi cepat dan menyenangkan. Dan itulah yang saya coba tawarkan kepada Anda sekalian. Dengan bantuan sebuah unit matrik yang ‘easy’ (EzMatrix), maka ucapkan selamat tinggal pemrograman matrix yang njelimet. Perhatikan contoh berikut ini.

Misalkan Anda harus menyelesaikan persamaan matrik C=transpose(A).A + 2(A-B), di mana A dan B adalah matrik berorde 3×3. Mengetik sendiri program penyelesaiannya akan sangat panjang dan lama. Setidaknya (minimal) terdapat 4 buah variabel array dua dimensi yang harus Anda deklarasikan. Selain itu Anda juga harus membuat rutin-rutin seperti: transpose, penjumlahan, pengurangan, perkalian, penskalaan, penampil matrik, dan peng-input matrik. Tapi dengan menggunakan EzMatrix, Anda dapat menyelesaikannya dengan lebih mudah dan lebih cepat, sebagai berikut:

uses EzMatrix;

var
M: EzMatrixPtr;

begin
new(M, Init); {Mulai}
with M^ do
begin
{Buat matrik A dan B 3×3}
create(‘A’, 3, 3);
create(‘B’, 3, 3);

{Input matrix A dan B}
input(‘A’);
input(‘B’);

{Solve trans(A).A+2(A-B) dan simpan di C}
copymatrix(add(mul(trans(‘A’),’A’), scale(sub(‘A’,’B’),2)),’C’);

{print matrix:10:4}
print(‘A’, 10, 4); writeln;
print(‘B’, 10, 4); writeln;
print(‘C’, 10, 4);
end;
dispose(M, Done); {Selesai}
readln;
end.

Sangat mudah, dan selamat tinggal Mr. Njelimet! Dengan EzMatrix persamaan matrik di atas dapat diselesaikan dengan satu baris program saja. Anda bahkan tidak perlu mendeklarasikan variabel-variabel array untuk menyimpan data matrik. Matrik C pada program di atas pun diciptakan secara otomatis. Dan, kalau Anda perhatikan, setiap operasi matrik dilakukan berdasarkan nama matrik yang mempunyai tipe data string, bukan parameter bertipe array. Inilah salah satu kemudahan yang ditawarkan oleh EzMatrix.

Fitur-fitur Unit EzMatrix
Untuk lebih mengenal unit EzMatrix, berikut ini adalah fitur-fitur yang dimiliki oleh unit tersebut:

  1. EzMatrix dibuat dengan teknik pemrograman berorientasi objek sehingga mudah digunakan dan mudah dikembangkan.
  2. Dibuat menggunakan Turbo Pascal 5.5 sehingga bisa langsung digunakan pada Turbo Pascal 6.0/7.0, Delphi atau bahkan FreePASCAL (dengan sedikit modifikasi tentunya).
  3. EzMatrix menciptakan matrik secara dinamis sehingga Anda dapat menciptakan dan mengubah orde matrik kapanpun Anda perlukan.
  4. EzMatrix dilengkapi dengan rutin-rutin dasar operasi matrik sehingga Anda dapat langsung menggunakannya untuk memecahkan masalah. Rutin-rutin tersebut meliputi 13 buah rutin pengolah matrik, 7 buah fungsi pengidentifikasi matrik, 5 buah fungsi operasi dasar aljabar matrik, dan sebuah fungsi identitas.
  5. Operasi matrik dilakukan berdasarkan nama matrik yang mempunyai tipe data string8.
  6. EzMatrix menggunakan struktur data singly linked-list untuk menyimpan matrik selama program berlangsung.
  7. Tipe data elemen matrik adalah real.
  8. EzMatrix tidak mendukung pemakaian fungsi bersarang. (Lihat penjelasan di bawah!)

Struktur Data EzMatrix
ezmatrix_tp552 EzMatrix memperlakukan matrik sebagai objek yang memiliki data-data dan fungsi-fungsi pemanipulasi yang mendukungnya (method). EzMatrix tersusun dari dua buah objek. Yang pertama adalah objek matrix_ADT yang merupakan tipe data abstrak matrik. Objek ini menampung data-data berupa unsur-unsur matrik yaitu nama matrik, orde matrik dan elemen-elemen matrik. Selain itu, matrix_ADT memiliki fungsi-fungsi pengalokasi memori dan pengakses elemen matrik. Berikut ini adalah pendeklarasian objek matrix_ADT.

type
string8 = string[8];
tipedata = real;

_array = array [1..1] of tipedata;
parray = ^_array;
matrix = array [1..1] of parray;
pmatrix = ^matrix;

{——————————————————-}
{    EzMatrix Abstract Data Type                        }
{——————————————————-}
pmatrix_ADT = ^matrix_ADT;
matrix_ADT = object
{private}
name: string8;
row, col: word;
data: pmatrix;
next: pmatrix_ADT;

{public}
constructor allocate(b, k: word);
destructor deallocate;
procedure reallocate(b, k: word); virtual;
procedure reset; virtual;
procedure putv(b, k: word; value: tipedata); virtual;
function getv(b, k: word): tipedata; virtual;
end;

Variabel name digunakan untuk menyimpan nama matrik. Variabel ini bertipe string dengan lebar 8 karakter. Berdasarkan variabel inilah EzMatrix melakukan operasi-operasi matrik.

Variabel row dan col digunakan untuk menyimpan jumlah baris dan kolom matrik. Kedua variabel ini mewakili orde matrik.

Variabel pointer data digunakan untuk menyimpan elemen-elemen matrik. Variabel ini memiliki tipe data pmatrix yang merupakan pointer dari sebuah array pointer dari sebuah array bertipe real. Dan next adalah variabel pointer yang menunjuk ke matrik berikutnya. EzMatrix menggunakan struktur data singly linked-list untuk menyimpan matrik-matrik yang diciptakan selama program berlangsung.

Konstruktor allocate berfungsi mengalokasikan memori yang dibutuhkan untuk menyimpan elemen-elemen matrik dengan orde tertentu. Sebuah matrik berorde B x K membutuhkan memori sebesar 4B+6BK untuk menyimpan data. Jadi untuk sebuah matrik berorde 7×5, akan dialokasikan memori sebesar (4*7+6*7*5)=238 byte untuk menyimpan elemen-elemennya. Jumlah memori total yang dibutuhkan untuk menampung sebuah matrik dengan orde B x K adalah (4B+6BK)+sizeof(matrix_ADT)=(4B+6BK)+23 byte.

Fungsi berikutnya adalah destruktor deallocate yang berfungsi menghapus memori yang telah digunakan oleh sebuah matrik. Prosedur reallocate berfungsi mengalokasikan kembali memori yang dibutuhkan oleh sebuah matrik karena terjadi perubahan orde matrik.

Prosedur reset berfungsi mereset (mengenolkan) elemen-elemen matrik. Hal ini perlu sekali karena dalam bermain pointer kita harus benar-benar berhati-hati. Turbo Pascal hanya mengalokasikan memori, mengenai isi memori tersebut Turbo Pascal tidak tahu-menahu. Oleh karena itu sudah menjadi kewajiban kita sebagai pemrogram yang baik untuk melakukan inisialisasi nilai setelah memori berhasil dialokasikan dan sebelum memori digunakan.

Untuk mengeset nilai sebuah elemen matrik digunakan prosedur putv (put value). Sedangkan untuk mengambil nilai sebuah elemen matrik digunakan fungsi getv (get value). Anda juga dapat mengakses elemen matrik secara langsung bila diinginkan.

Perintah putv(4, 5, 12.33) sama dengan perintah data^[4]^[5]:=12.33. Dan perintah y:=getv(4,5) sama dengan perintah y:=data^[4]^[5].

ezmatrix_tp553 Objek berikutnya adalah EzMatrixList. Objek inilah yang menjadi inti dari unit EzMatrix. Di dalam objek ini terdapat berbagai fungsi dan prosedur siap pakai yang khusus dirancang dengan tiga tujuan yaitu:

  1. mempermudah
  2. mempercepat
  3. mengurangi kesalahan pemrograman

Untuk keperluan pengolahan matrik, EzMatrixList menyediakan 13 buah fungsi pengolah matrik. Ketigabelas fungsi tersebut adalah:

  • create untuk menciptakan matrik,
  • reorde untuk mengubah orde matrik,
  • destroy untuk menghapus sebuah matrik dari list,
  • destroyall untuk menghapus semua matrik yang ada di list,
  • input untuk memasukkan data elemen matrik,
  • successor untuk mendapatkan pointer matrik berikutnya,
  • predecessor untuk mendapatkan pointer matrik sebelumnya,
  • search untuk mendapatkan pointer sebuah matrik,
  • put untuk memasukkan sebuah nilai pada baris dan kolom tertentu,
  • get untuk mengambil sebuah elemen pada baris dan kolom tertentu,
  • print untuk mencetak sebuah matrik ke layar,
  • reset untuk mengeset semua elemen matrik menjadi nol, dan
  • copymatrix untuk mengkopi matrik.

Selain itu terdapat 7 buah fungsi pengidentifikasi matrik yang bertipe boolean, yaitu:

  • issameorde untuk mengetahui apakah orde dari sebuah matrik sama dengan orde matrik yang lain,
  • issquare untuk mengetahui apakah matrik merupakan matrik bujursangkar,
  • isequal untuk mengetahui apakah sebuah matrik sama dengan matrik yang lain,
  • isuppertriangular untuk mengetahui apakah matrik merupakan matrik segitiga-atas,
  • islowertriangular untuk mengetahui apakah matrik merupakan matrik segitiga-bawah,
  • isdiagonal untuk mengetahui apakah matrik merupakan matrik diagonal, dan
  • isidentity untuk mengetahui apakah matrik merupakan matrik identitas.

Untuk operasi dasar aljabar matrik, EzMatrixList menyediakan 5 buah fungsi dasar, yaitu:

  • scale untuk mengalikan matrik dengan suatu nilai konstanta,
  • add untuk menjumlahkan dua buah matrik,
  • sub untuk mengurangkan sebuah matrik dari matrik lainnya,
  • trans untuk menghitung transpose matrik, dan
  • mul untuk mengalikan dua buah matrik.

EzMatrix menyediakan sebuah fungsi untuk menciptakan matrik identitas dengan orde tertentu yaitu ID. Fungsi ini menghasilkan sebuah matrik bernama ‘ID’. Contoh, pada perintah print(mul(‘A’, ID(3)), 8, 2), dengan A sebuah matrik bujursangkar berorde 3×3, akan dihasilkan tampilan matrik hasil perkalian matrik A dengan matrik identitasnya yang mana hasilnya adalah sama dengan matrik A (perkalian sebuah matrik dengan matrik identitas tidak mengubah nilai-nilai matrik tersebut).

Untuk mempelajari lebih lanjut tentang algoritma pemrograman unit ini, Anda dapat mempelajari listing prorgam EZMATRIX.PAS yang terlampir pada bagian listing program.

Dan untuk mengetahui penerapan unit ini dalam pemrograman matrik, Anda dapat mencoba dan mempelajari contoh program EZMATX#1.PAS, EZMATX#2.PAS, dan EZMATX#3.PAS.

Ketiga contoh program ini telah dibuat sedemikian rupa sehingga Anda dapat memahami proses-proses yang terjadi. Ketiganya juga dilengkapi dengan komentar program yang akan membantu Anda memahami perintah-perintah yang digunakan. Gunakan tombol F7/F8 untuk menelusuri jalannya program dan melihat efek dari setiap perintah yang terdapat dalam program. Ini cara terbaik untuk mengetahui penerapan fungsi-fungsi yang ada dalam unit EzMatrix.

Prosedur CopyMatrix
Dalam unit EzMatrix terdapat sebuah prosedur yang sangat berperan dalam proses penyelesaian persamaan matrik. Prosedur itu adalah copymatrix(S, D: string8), dengan S adalah nama matrik sumber (source) dan D adalah nama matrik tujuan (destination). Prosedur ini berfungsi menciptakan matrik D yang sama orde dan elemen-elemennya dengan matrik S. Jadi sesuai namanya yakni copymatrix.

Jika matrik tujuan sudah ada dalam daftar dan memiliki orde sama dengan matrik sumber, maka prosedur akan langsung menyalin data matrik sumber ke matrik tujuan.

Namun jika ordenya tidak sama maka terlebih dahulu akan dilakukan pengubahan orde sebelum dilakukan penyalinan data.

Dan jika matrik tujuan belum ada dalam daftar, maka akan dilakukan penciptaan matrik terlebih dahulu sebelum proses penyalinan data dilakukan. Dari cara kerjanya bisa kita lihat bahwa prosedur ini sangat handy dan aman.

Dalam pemakaiannya prosedur ini sangat cocok digunakan untuk melakukan proses perhitungan matrik karena prosedur ini dapat menghasilkan matrik baru dengan nama yang dapat kita tentukan. Contoh program di bagian awal artikel telah menunjukkan bagaimana prosedur ini meng-kopi matrik hasil perhitungan trans(A).A + 2(A-B) ke dalam matrik C.

Perhatikan baris perintah berikut ini:

C:= add(mul(trans(‘A’),’A’), scale(sub(‘A’,’B’),2));

dengan C adalah variabel bertipe string8.

Perintah tersebut juga menyelesaikan persamaan matrik dalam satu baris program, namun, dalam hal ini, hasil perhitungan bukanlah sebuah matrik baru yang unik seperti jika kita melakukan perhitungan menggunakan prosedur copymatrix. Baris perintah tersebut tak lebih dari sebuah operasi pemasukan nilai string ‘VRAdd’ ke dalam variabel C, karena setiap fungsi operasi matrik dalam unit EzMatrix menghasilkan sebuah matrik dengan nama-nama tertentu.

Fungsi add, dalam hal ini, menghasilkan sebuah matrik yang berisi hasil penjumlahan dengan nama ‘VRAdd’. Jika Anda tidak berhati-hati, sangat boleh jadi akan terjadi kesalahan perhitungan jika program Anda melakukan operasi penjumlahan berulang-kali, sebab matrik VRAdd akan berubah setiap kali fungsi add dipanggil. Oleh karena itu saya anjurkan Anda menggunakan prosedur copymatrix. Dan buatlah nama matrik seunik mungkin!

Penggunaan Fungsi Bersarang
Telah disebutkan pada bagian fitur unit EzMatrix bahwa unit ini tidak mendukung penggunaan fungsi bersarang. Sebagai contoh, misalkan Anda mempunyai persamaan matrik Y=ABC. Untuk menyelesaikannya, Anda harus membuat perhitungan secara bertahap (bukan bersarang), yaitu menghitung terlebih dahulu AB, kemudian hasilnya dikalikan dengan C sehingga menjadi (AB)C, sebagai berikut:

copymatrix(mul(‘A’,’B’),’AxB’);
copymatrix(mul(‘AxB’,’C’),’Y’);

Atau dengan menghitung terlebih dahulu BC, dan kemudian menghitung perkalian A(BC) sebagai berikut:

copymatrix(mul(‘B’,’C’),’BxC’);
copymatrix(mul(‘A’,’BxC’),’Y’);

Anda tidak dapat menyelesaikan persamaan tersebut dalam satu baris perintah seperti:

copymatrix(mul(mul(‘A’,’B’),’C’),’Y’);

Jika Anda melakukannya, maka akan didapat hasil perhitungan yang salah. Ini disebabkan (lagi-lagi) karena setiap fungsi operasi perhitungan matrik pada unit EzMatrix menghasilkan sebuah matrik dengan nama-nama tertentu. Fungsi mul akan menghasilkan matrik bernama ‘VRMul’, ‘VRScale’ untuk fungsi scale, ‘VRAdd’ untuk fungsi add, ‘VRSub’ untuk fungsi sub, dan ‘VRTrans’ untuk fungsi trans.

Jika Anda menggunakan fungsi yang sama secara bersarang, maka yang terjadi adalah perhitungan matrik di mana hasil dan operand adalah matrik yang sama, sehingga elemen matrik operand akan berubah sesuai dengan perubahan elemen matrik hasil. Hal ini tentu akan mempengaruhi hasil perhitungan selanjutnya mengingat proses perhitungan matrik bukanlah proses perhitungan yang sekali jalan terhadap sebuah nilai melainkan proses perhitungan yang dilakukan pada elemen-elemennya menggunakan proses perulangan.

Pelacakan Kesalahan
Sebagai unit bantu, EzMatrix juga dilengkapi dengan rutin pengecek kesalahan meskipun ala kadarnya. Hampir setiap fungsi dalam objek EzMatrixList dilengkapi dengan rutin ini. Jika terjadi kesalahan maka rutin ini akan mengeset variabel errorflag menjadi TRUE dan menampilkan pesan kesalahan dengan memanggil prosedur ERROR.

procedure ERROR(msg: string);
begin
errorflag:= TRUE;
errorstr:= msg;
writeln(#7, msg);
end;

Pesan kesalahan yang ditampilkan terdiri dari nama prosedur atau fungsi di mana kesalahan terjadi diikuti dengan pesan kesalahannya. Sebagai contoh misalnya dalam program Anda terdapat perintah:

create(‘MatA’, 3, 3);
input(‘matA’);
print(‘MatA’, 4, 1);

Maka pada saat dijalankan program akan menampilkan hasil sebagai berikut:

InputError: Can’t find matrix matA!
Matrix MatA(3,3) :
0.0  0.0  0.0
0.0  0.0  0.0
0.0  0.0  0.0

Dengan mengetahui bahwa kesalahan terjadi pada perintah input, maka dengan cepat dapat ditemukan kesalahan yang terjadi adalah adanya kesalahan pengetikan nama matrik yang seharusnya ‘MatA’ akan tetapi diketik ‘matA’.

Perintah print pada baris ketiga tetap dijalankan walaupun terjadi kesalahan pada baris kedua. Inilah keunikan EzMatrix! Walaupun terjadi kesalahan pada baris sebelumnya, program akan terus berjalan hingga akhir program. Terus-terang, saya sendiri bingung apakah ini merupakan kelebihan atau kekurangan. Oleh karena itu saya sebut saja hal ini sebagai suatu keunikan. Tapi terlepas dari itu, yang terpenting adalah unit EzMatrix sangat aman dan nyaman digunakan baik bagi pemula, menengah maupun kalangan mahir.

Mengembangkan EzMatrix
Untuk mengembangkan unit EzMatrix tentu tidak semudah menggunakannya. Pertama Anda harus menguasai teknik pemrograman berorientasi objek. Kedua Anda harus menguasai pemrograman pointer, dan ketiga Anda harus memahami struktur data dan cara kerja unit EzMatrix. Contoh pengembangan unit ini dapat Anda lihat pada contoh program EZMATX#3.PAS yang terdapat pada bagian listing program. Program tersebut menambahkan sebuah fungsi dekomposisi LU menggunakan metode DOOLITTLE.

ezmatrix_tp55LU

Nah, semoga unit EZMATRIX versi Turbo Pascal ini dapat memberikan manfaat kepada kita sekalian.

Kepustakaan
¬†¬†¬† “Matrix Computations and Mathematical Software”, John R. Rice, McGraw Hill.
“Fundamentals of Matrix Computations”, David S. Watkins, John Wiley & Sons.
“Perhitungan Matriks Dengan Fortran”, Dr. Suprajitno Munadi, Andi Offset.

—(0)—

Listing program EZMATRIX.PAS
Karena listing program unit ini cukup panjang (710 baris), maka tidak saya tampilkan di sini. Anda bisa mendapatkan listing program Unit EZMATRIX.PAS dengan memberikan sedikit donasi (Rp. 25.000,-)

Listing program EZMATX#1.PAS

(**********************************************************)
{                                                          }
{   EZMATX#1.PAS                                           }
{   Contoh pemakaian fungsi-fungsi dasar unit EzMatrix     }
{   Chandra MDE Рchandra@teknikelektrolinks.com           }
{   Saran: Gunakan F7/F8 untuk meng-trace jalannya program }
{                                                          }
(**********************************************************)

uses EzMatrix;

var
M: EzMatrixList;
MPtr, SPtr, PPtr: pmatrix_ADT;
baris, kolom: word;
matname: string8;
i, j: word;
value: real;

begin
writeln(‘EZMATX#1 – Contoh program 1’, #13#10);
writeln;

M.Init; { Begin }
with M do begin
{——————————————————-}
{  Fungsi-fungsi dasar matrik dinamis                   }
{——————————————————-}
writeln(‘Fungsi-fungsi dasar matrik dinamis’);
writeln(‘———————————-‘);
write(‘Masukkan nama matrik: ‘); readln(matname);
write(‘Masukkan jumlah baris: ‘); readln(baris);
write(‘Masukkan jumlah kolom: ‘); readln(kolom);
writeln;

create(matname, baris, kolom);  { Ciptakan matrik    }
input(matname);             { Masukkan data          }
print(matname, 8, 2);       { Tampilkan matrik A:8:2 }
writeln;
writeln(‘Ubah ordenya menjadi 4×4 dan isi data’);
reorde(matname, 4, 4);¬†¬†¬†¬†¬† { Ubah orde matrik A 4×4 }
put(matname, 1, 1, 100);    { Buat matrik diagonal   }
put(matname, 2, 2, 100);
put(matname, 3, 3, 100);
put(matname, 4, 4, 100);
print(matname, 10, 4);      { Tampilkan matrik A:8:4 }
readln;

{——————————————————-}
{  Mengakses pointer matrik secara langsung             }
{——————————————————-}
writeln(‘Mengakses pointer matrik secara langsung’);
writeln(‘—————————————-‘);
MPtr:= search(matname);  { Dapatkan pointer matrik   }
if MPtr <> NIL then
with MPtr^ do begin
for i:= 1 to row do   { Tampilkan matrik data:8:2 }
begin                 { secara manula, eh manual. }
for j:= 1 to col do
begin
{Pake GetV} value:= getv(i, j);
{Bisa juga pake value:= data^[i]^[j];}
if abs(value) < 1E-10 then value:= 0;
write(data^[i]^[j]:8:2);
end;
writeln;
end;
writeln;
writeln(‘Ubah ordenya menjadi 2×2 dan isi data.’);
reallocate(2, 2);¬†¬†¬†¬†¬†¬†¬†¬† { Ubah ordenya jadi 2×2 }
putv(1, 1, 3); putv(1, 2, 5);  { Isi baris kesatu }
putv(2, 1, 7); putv(2, 2, 9);  { Isi baris kedua  }
end;
print(matname, 8, 2);    { Tampilkan matrik A:8:2    }
destroy(matname);        { Hapus matrik              }
readln;

{——————————————————-}
{  Successor, Predecessor dan CopyMatrix                }
{——————————————————-}
writeln(‘Successor, Predecessor dan CopyMatrix’);
writeln(‘————————————-‘);
writeln(‘Ciptakan matrik A, B, dan C. Orde 3×3’);
create(‘A’, 3, 3);¬†¬†¬†¬†¬†¬† { Ciptakan matrik A 3×3¬†¬†¬†¬† }
create(‘B’, 3, 3);¬†¬†¬†¬†¬†¬† { Ciptakan matrik B 3×3¬†¬†¬†¬† }
create(‘C’, 3, 3);¬†¬†¬†¬†¬†¬† { Ciptakan matrik C 3×3¬†¬†¬†¬† }

MPtr:= search(‘B’);
PPtr:= predecessor(‘B’);
SPtr:= successor(‘B’);

writeln(‘MPtr^.Name = ‘, MPtr^.Name);
writeln(‘Pred(B) = ‘, PPtr^.Name);
writeln(‘Succ(B) = ‘, SPtr^.Name);
writeln(‘Succ(C) = ‘, successor(‘C’)^.name);
writeln(‘Pred(C) = ‘, predecessor(‘C’)^.name);
if successor(‘A’)=NIL then
writeln(‘Succ(A) = NIL’)
else
writeln(‘Succ(A) = ‘, successor(‘A’)^.name);
writeln(‘Pred(A) = ‘, predecessor(‘A’)^.name);
writeln(‘NB: Matrik yang terakhir diciptakan adalah’);
writeln(‘pointer kepala dari daftar matrik. Dalam’);
writeln(‘hal ini matrik C adalah kepala list.’);
writeln;

writeln(‘Prosedur CopyMatrix’);
writeln(‘——————-‘);
input(‘B’);¬†¬†¬†¬†¬†¬†¬†¬†¬†¬†¬†¬†¬†¬†¬†¬† { Masukkan data¬†¬†¬†¬†¬†¬†¬†¬†¬† }
print(‘B’, 8, 2);¬†¬†¬†¬†¬†¬†¬†¬†¬†¬† { Tampilkan matrik B:8:2 }

copymatrix(‘B’, ‘Kopian’);¬† { Copy matrik B->Kopian¬† }

writeln(‘matrik Kopian = matrik B’);
print(‘Kopian’, 8, 2);
readln;

{——————————————————-}
{  Put, Get dan Reset                                   }
{——————————————————-}
writeln(‘Put, Get dan Reset’);
writeln(‘——————‘);
writeln(‘Set elemen diagonal matrik A = 5’);
put(‘A’, 1, 1, 5);¬†¬†¬† { Set elemen A[1, 1] = 5¬†¬†¬†¬†¬†¬† }
put(‘A’, 2, 2, 5);¬†¬†¬† { Set elemen A[2, 2] = 5¬†¬†¬†¬†¬†¬† }
put(‘A’, 3, 3, 5);¬†¬†¬† { Set elemen A[3, 3] = 5¬†¬†¬†¬†¬†¬† }

writeln(‘Matrik A sebelum direset.’);
print(‘A’, 8, 2);
writeln(‘A[2, 2] = ‘, get(‘A’, 2, 2):8:2);¬†¬† { Get¬†¬† }
reset(‘A’); writeln;
writeln(‘Matrik A setelah direset.’);
print(‘A’, 8, 2);
end;
M.Done; { Destroy All }
writeln(‘Selesai’);
readln;
end.

Listing program EZMATX#2.PAS

(**********************************************************)
{                                                          }
{   EZMATX#2.PAS                                           }
{   Contoh pemakaian fungsi boolean dan fungsi operasi     }
{   perhitungan matrik                                     }
{   Chandra MDE Рchandra@teknikelektrolinks.com           }
{   Saran: Gunakan F7/F8 untuk meng-trace jalannya program }
{                                                          }
(**********************************************************)

uses EzMatrix;

function getname(s: string): string8;
var
name: string8;
begin
write(s); readln(name);
getname:= name;
end;

function getint(s: string): word;
var
n: word;
begin
write(s); readln(n);
getint:= n;
end;

var
M: EzMatrixList;
matA, matB: string8;
baris, kolom: word;

begin
writeln(‘EZMATX#2 – Contoh program 2’, #13#10);
writeln(‘Penggunaan fungsi-fungsi EzMatrix’, #7);
writeln;

M.Init; { Mulai }
with M do begin
{ Matrik 1 }
matA:= getname(‘Masukkan nama matrik1: ‘);
baris:= getint(‘Masukkan jumlah baris matrik1: ‘);
kolom:= getint(‘Masukkan jumlah kolom matrik1: ‘);
create(matA, baris, kolom);
input(matA);

{ Matrik 2 }
matB:= getname(‘Masukkan nama matrik2: ‘);
baris:= getint(‘Masukkan jumlah baris matrik2: ‘);
kolom:= getint(‘Masukkan jumlah kolom matrik2: ‘);
create(matB, baris, kolom);
input(matB);

{ Fungsi-fungsi perbandingan matrik }
if issameorde(matA, matB) then
writeln(‘Orde matrik ‘, matA, ‘ = orde matrik ‘,
matB) else
writeln(‘Orde matrik ‘, matA, ‘ # orde matrik ‘,
matB);
if isequal(matA, matB) then
writeln(‘Matrik ‘, matA, ‘ = matrik ‘, matB)
else
writeln(‘Matrik ‘, matA, ‘ # matrik ‘, matB);

{ Fungsi-fungsi pengidentifikasi matrik }
if issquare(matA) then
writeln(matA, ‘ adalah matrik bujursangkar’);
if issquare(matB) then
writeln(matB, ‘ adalah matrik bujursangkar’);
if isuppertriangular(matA) then
writeln(matA, ‘ adalah matrik segitiga atas’);
if isuppertriangular(matB) then
writeln(matB, ‘ adalah matrik segitiga atas’);
if islowertriangular(matA) then
writeln(matA, ‘ adalah matrik segitiga bawah’);
if islowertriangular(matB) then
writeln(matB, ‘ adalah matrik segitiga bawah’);
if isdiagonal(matA) then
writeln(matA, ‘ adalah matrik diagonal’);
if isdiagonal(matB) then
writeln(matB, ‘ adalah matrik diagonal’);
if isidentity(matA) then
writeln(matA, ‘ adalah matrik identitas’);
if isidentity(matB) then
writeln(matB, ‘ adalah matrik identitas’);
writeln;

{ Fungsi-fungsi operasi perhitungan matrik }
writeln(‘Penjumlahan ‘, matA, ‘ + ‘, matB);
print(add(matA, matB), 8, 2); readln;

writeln(‘Pengurangan ‘, matA, ‘ – ‘, matB);
print(sub(matA, matB), 8, 2); readln;

writeln(‘Perkalian ‘, matA, ‘ * ‘, matB);
print(mul(matA, matB), 8, 2); readln;

writeln(‘Penskalaan: 3(‘, matA, ‘)’);
print(scale(matA, 3), 8, 2);
writeln(‘Penskalaan: 2(‘, matB, ‘)’);
print(scale(matB, 2), 8, 2); readln;

writeln(‘Matrik transpose(‘, matA, ‘)’);
print(trans(matA), 8, 2);
writeln(‘Matrik transpose(‘, matB, ‘)’);
print(trans(matB), 8, 2); readln;

writeln(‘Fungsi matrik identitas’);
print(ID(3), 8, 2);
end;
M.Done; { Destroy All }
writeln(‘Selesai’);
readln;
end.

Listing program EZMATX#3.PAS

(**********************************************************)
{                                                          }
{   EZMATX#3.PAS                                           }
{   Contoh pengembangan unit EzMatrix dengan menambahkan   }
{   fungsi Dekomposisi LU menggunakan metode DOOLITTLE     }
{   Chandra MDE Рchandra@teknikelektrolinks.com           }
{                                                          }
(**********************************************************)

uses EzMatrix;

type
MyMatrix = object(EzMatrixList)
procedure LU(mat: string8); virtual;
end;

procedure MyMatrix.LU(mat: string8);
var
T: pmatrix_ADT;
i, j, k: byte;
value: tipedata;

begin
errorflag:= false;
T:= search(mat);   { Dapatkan pointer matrik }
if T=NIL then
begin
ERROR(‘LUError: Can”t find matrix ‘+mat+’!’);
exit;
end;
if T^.row<>T^.col then
begin
ERROR(‘LUError: Matrix ‘+ mat +
‘ isn”t a square matrix!’);
exit;
end;
if search(‘_L’)=NIL then
create(‘_L’, T^.row, T^.row)
else
reorde(‘_L’, T^.row, T^.row);

copymatrix(ID(T^.row), ‘_U’);

for i:= 1 to T^.row do
put(‘_L’, i, 1, T^.getv(i, 1));

for i:= 2 to T^.row do
begin
if get(‘_L’,1,1)=0 then
begin
ERROR(‘LUError: Matrix ‘+mat+’ is singular!’);
exit;
end;
put(‘_U’,1,i,(T^.getv(1,i)/get(‘_L’,1,1)));
end;

for i:= 2 to T^.row-1 do
begin
for j:= i to T^.row do
begin
value:= 0;
for k:= 1 to j-1 do
value:= value+get(‘_L’,j,k)*get(‘_U’,k,i);
put(‘_L’, j, i, T^.getv(j,i)-value);
end;
for k:= i+1 to T^.row do
begin
value:= 0;
for j:= 1 to i-1 do
value:= value + get(‘_L’,i,j)*get(‘_U’,j,k);
if get(‘_L’, i, i)=0 then
begin
ERROR(‘LUError: Matrix ‘+ mat +
‘ is singular!’);
exit;
end;
put(‘_U’, i, k,
(T^.getv(i,k)-value)/get(‘_L’, i, i));
end;
value:= 0;
for k:= 1 to T^.row-1 do
value:= value +
get(‘_L’,T^.row,k)*get(‘_U’,k,T^.row);
put(‘_L’, T^.row, T^.row,
T^.getv(T^.row,T^.row)-value);
end;
end;

var
M: MyMatrix;

begin
writeln(‘EZMATX#3 –¬† Contoh program 3’);
writeln(‘Penambahan prosedur Dekomposisi LU’);
writeln;

M.Init;
with M do begin
create(‘A’, 4, 4);
input(‘A’);
LU(‘A’);
if NOT errorflag then
begin
print(‘_L’, 8, 2);
print(‘_U’, 8, 2);
copymatrix(mul(‘_L’, ‘_U’), ‘LU’);
print(‘LU’, 8, 2);
print(‘A’, 8, 2);
writeln(‘Perhatikan! Matrik A = Matrik LU’);
end;
end;
M.Done;
readln;
end.

Nah, semoga bermanfaat.

Selamat belajar dan selamat berkarya!

ūüėÄ

Tinggalkan Balasan

Isikan data di bawah atau klik salah satu ikon untuk log in:

Logo WordPress.com

You are commenting using your WordPress.com account. Logout / Ubah )

Gambar Twitter

You are commenting using your Twitter account. Logout / Ubah )

Foto Facebook

You are commenting using your Facebook account. Logout / Ubah )

Foto Google+

You are commenting using your Google+ account. Logout / Ubah )

Connecting to %s