P. 1
Perkalian Matrix

Perkalian Matrix

4.14

|Views: 15,911|Likes:
Published by Erika Ariana

More info:

Published by: Erika Ariana on Jan 04, 2009
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as DOC or read online from Scribd
See more
See less

06/14/2013

PERKALIAN MATRIX ALGORITMA STANDAR DAN STRASSEN

Disusun oleh :
Jaladri Abhirama (PA/09970) Didit Yudha S. (PA/10158) Desti Ayu K. (PA/10279) Arshadie Sadrifa (PA/10346) Tarcisus Dimas W. K Rahmad Mulyadi (PA/11056) M. Andi Miftachul H. Erika Ariana (PA/10863) Ary Novianto (PA/10923)

Satryo Puji H. (PA/11280)

Perkalian matriks merupakan suatu operasi yang penting karena banyak digunakan untuk memecahkan masalah yang berkaitan dengan dunia nyata, terutama untuk kepentingan sains dan rekayasa. Aplikasi perkalian matriks secara spesifik misalnya dalam pengolahan suatu citra untuk melakukan perubahan bentuk dari suatu gambar dalam suatu grafik komputer misalnya scalenya, gray levelnya, rotasi gambarnya dan masih banyak lagi perubahan bentuk yang bisa dilakukan dengan menggunakan perkalian matriks. Suatu perkalian matriks juga digunakan dalam menata komposisi satu set persamaan linear, dan penyajian tentang permasalahan alur paling pendek. Perkalian matriks pun biasanya digunakan untuk mengatasi permasalahan dalam linear programming yaitu dalam optimasi manajemen misalnya dalam pengambilan suatu keputusan. Ada beberapa algoritma perkalian matriks yaitu : yang diciptakan untuk menyelesaikan

1. Algoritma Standar

Adalah sebuah perkalian matriks yang dikerjakan dengan cara biasa.

Misalnya :

Perhitungannya :

   

C11 = a11b11 + a12b21 C12 = a11b12 + a12b22 C21 = a21b11 + a22b21 C22 = a21b12 + a22b22

İmplementasi program dari Algoritma biasa ditunjukkan dibwah ini : void matrix_mult (){ for (i = 1; i <= N; i++) { for (j = 1; j <= N; j++) { compute Ci,j } }}

 Time analysis Perhitungan waktu untuk algoritma biasa adalah

C i , j = ∑ ai ,k bk , j
k =1

N

Thus T ( N ) = ∑∑∑ c = cN 3 = O( N 3 )
i =1 j =1 k =1

N

N

N

2. ALGORITMA STRASSEN

Adalah sebuah algoritma untuk perkalian matriks yang terdiri dari 7 perkalian scalar dan 18 penjumlahan scalar untuk matriks berukuran 2X2, mempunyai kompleksitas O(n2.81) atau tepatnya 6n2.81 perkalian scalar dan (6n2.81 + 6n2) penjumlahan. Perumusan perkalian matriks yang digunakan Strassen untuk memperoleh 7 perkalian scalar dan 18 penjumlahan skalar tersebut adalah dengan melakukan perkalian matrik 2x2 yang ditunjukkan pada persamaan berikut :

dengan melakukan pendekatan 11 langkah berikut : P1=(A11+A22)(B11+B22) P2=(A21+A22)*B11 P3=A11*(B12-B22)

P4=A22*(B21-B11) P5=(A11+A12)*B22 P6=(A21-A11)*(B11+B12) P7 = (A12 - A22) * (B21 + B22) Kemudian Strassen melakukan langkah berikutnya dengan menggunakan 7 rumus diatas kedalam matriks C : C11=P1+P4-P5+P7 C12=P3+P5 C21=P2+P4 C22 = P1 + P3 - P2 + P6

Metode divide and conquer Prinsip dasar dari metode ini adalah dengan membagi n input menjadi input yang berbeda ( 1 < k < n ). Dari k subset input yang berbeda akan terdapat k sub-problem. Setiap sub-problem mempunyai solusinya masing-masing, sehingga akan diperoleh k subsolusi. Kemudian, dari k sub-solusi akan

diperoleh solusi yang optimal atau solusi yang diharapkan.

Metode divide and conquer Jika subproblem dianggap masih relatif besar, maka metode Divide and Conquer dapat digunakan lagi. Dalam keadaan tersebut, pemakaian ulang metode ini dinyatakan menggunakan teknik rekursif. Strassen dapat diselesaikan dengan metode divide dan conquer A × B = R A0 A2 A1 A3 B0 B2 B1 B3
A0×B0+A1 ×B2 A2×B0+A3 ×B2 A0×B1+A1×B3

A2×B1+A3×B3

• •

Divide matrices into sub-matrices: A0 , A1, A2 etc Use blocked matrix multiply equations Recursively multiply sub-matrices

TIME ANALYSIS • analisa Kompleksitas Divide and Conquer Algoritma Strassen dengan Metode

Dalam suatu perkalian matriks misal dua buah matriks A dan B dimana dua matriks tersebut berordo N X N . kemudian misalkan C merupakan hasil kali matriks A dan B . dimaNA C=AB Apabila kita membagi n x n matriks ke dalam 4 submatriks yang sama, dimana masing-masing adalah : n/2 x n/2 matriks (berturut-turut untuk membagi B ), dimana akan menghasilkan matriks c. metode divide dan conquer bisa digunakan untuk operasi perkalian matriks karena masingmasing hasil operasi itu akan menghasilkan suatu submatriks C. lebih jelasnya akan dijelaskan :

Lakukan perhitungan yang sama untuk mencari C12 , C21 , dan C22 . Dari persamaan diatas, maka kesulitan sebenarnya adalah membagi menjadi 8 bagian subproblem yang sama. Namun bisa diselesaikan dengan persamaan berikut :

dimana nilai c adalah konstan , cn2 merupakan persamaan yang digunakan untuk biaya penjumlahan ( terdiri dari n/2 x n/2 penjumlahan) . dan terdapat 8 perkalian n/2 x n/2 matriks . waktu Maka akan menghasilkan kompleksitas waktu sebesar O( n3 ). • Metode Divide dan Conquer untuk Penyelesaian Algoritma Strassen

Dari hasil algoritma tersebut diatas maka dengan metoda divide dan conquer akan diperoleh running timenya yaitu T(n) = 7T(n/2 ) − Θ (n2) karena hanya dibutuhkan dilakukannya 7 perkalian secara berulang

selanjutnya

atau dalam bentuk umumnya : alog k pangkat n = nlog k pangkat a Maka kompleksitas Algoritma Strassen tersebut adalah : Θ(nlog 7 ) = Θ(n2,81... )
Implementasi program algoritma strassen seperti di bawah ini : void matmul(int *A, int *B, int *R, int n) { if (n == 1) { (*R) += (*A) * (*B);

} else { matmul(A, B, R, n/4); matmul(A, B+(n/4), R+(n/4), n/4); matmul(A+2*(n/4), B, R+2*(n/4), n/4); matmul(A+2*(n/4), B+(n/4), R+3*(n/4), n/4); matmul(A+(n/4), B+2*(n/4), R, n/4); matmul(A+(n/4), B+3*(n/4), R+(n/4), n/4); matmul(A+3*(n/4), B+2*(n/4), R+2*(n/4), n/4); matmul(A+3*(n/4), B+3*(n/4), R+3*(n/4), n/4);}

analisa perbandingan
Waktu NxN Standard 8.89301300049E -5 0.000092029571 5332 0.000648975372 314 0.004477977752 69 0.0388550758362 0.320672035217 Strassen 0.00045418739 3188 0.00369310379 028 0.02787685394 29 0.23237299919 1 1.5009188652 11.5688068867 Jumlah Perkalian Jumlah Penjumlahan Memory

Standard Strassen Standard Strassen Standard Strassen

2x2

8

7

4

18

12

20

4x4

64

49

48

198

48

112

8x8 1 6x1 6 32x3 2 64x6 4

512

343

448

1674

192

576

4096

2401

3840

12870

768

2816

32768 262144

16807 117649

31744 258048

94698 681318

3072 12288

13312 61440

• memory
standar : 3xnxn memerlukan 3 buah array ukuran nxn untuk menyimpan 2 matriks yang dikalikan
function strassenMemmory($n) { $sum = $n*$n; $temp = $n*$n; $temp2 = 0;

strassen : sesuai dengan algoritma dibawah ini

while ($n >= 1) { $temp2 = $temp2 + $temp; $n = $n/2; } $sum = $sum + 2*($temp2); return $sum; }

Implementasi

Kemudahan Implementasi

Algoritma Brute Force 1. lebih sederhana, karena mencoba semua secara berurutan 2. cocok untuk matrik berukuran kecil

Algoritma Strassen 1. lebih rumit, 2. cocok untuk matrik yang berukuran besar

Kesimpulan
Algoritma strassen lebih lambat dari algoritma standar karena memang algo strassen mengurangi jumlah perkalian tetapi pengurangan jumlah perkalian itu harus diganti dengan menambah operasi penjumlahan dan pengurangan yang jumlahnya lebih banyak, misal pada matrix 2x2 jumlah perkalian dengan algoritma strassen turun 1 buah tetapi jumlah penambahan/pengurangan naik 14 buah.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->