Anda di halaman 1dari 11

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 yang diciptakan untuk menyelesaikan


perkalian matriks yaitu :

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

N
C i , j = ∑ ai ,k bk , j
k =1
N N N
Thus T ( N ) = ∑∑∑ c = cN 3 = O( N 3 )
i =1 j =1 k =1

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 A1 B0 B1 A0×B0+A1 A0×B1+A1×B3
×B2
A2 A3 B2 B3
A2×B0+A3 A2×B1+A3×B3
×B2

• Divide matrices into sub-matrices: A0 , A1, A2 etc


• Use blocked matrix multiply equations
• Recursively multiply sub-matrices

TIME ANALYSIS

• analisa Kompleksitas Algoritma Strassen dengan Metode


Divide and Conquer

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 masing-
masing 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

Jumlah Jumlah
Waktu Memory
Perkalian Penjumlahan
NxN

Standard Strassen Standard Strassen Standard Strassen Standard Strassen

8.89301300049E 0.00045418739
2x2 8 7 4 18 12 20
-5 3188

0.000092029571 0.00369310379
4x4 64 49 48 198 48 112
5332 028

0.000648975372 0.02787685394
8x8 512 343 448 1674 192 576
314 29

1
0.004477977752 0.23237299919
6x1 4096 2401 3840 12870 768 2816
69 1
6

32x3 0.0388550758362 1.5009188652 32768 16807 31744 94698 3072 13312


2

64x6 0.320672035217 11.5688068867 262144 117649 258048 681318 12288 61440


4

• memory

standar : 3xnxn memerlukan 3 buah array ukuran nxn untuk menyimpan 2 matriks yang
dikalikan

function strassenMemmory($n) strassen : sesuai dengan algoritma


{ dibawah ini
$sum = $n*$n;
$temp = $n*$n;
$temp2 = 0;

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.