Algoritma Strassen

Algoritma Strassen dalam matematika, khususnya aljabar linear adalah sebuah algoritma yang dinamakan oleh Volker Strassen yang merupakan sebuah algoritma yang digunakan untuk perkalian matriks yang secara asimtot lebih cepat daripada algoritma perkalian matriks standar dan sangat berguna dalam penggunaanya untuk matriks yang berukuran besar.

Sejarah

Volker Strassen memublikasikan algoritma Strassen tahun 1969. Meskipun algoritma ini hanya sedikit lebih cepat daripada algoritma standar untuk perkalian matriks, dialah yang pertama menjelaskan bahwa eliminasi Gauss adalah tidak optimal. Dalam tulisannya, dia memulai penelitian untuk melengkapi algoritma-algoritma yang lebih cepat seperti algoritme Winograd dari Shmuel Winograd pada 1980, dan yang lebih kompleks algoritme Coppersmith-Winograd dipublikasikan pada 1987.

Algoritma

Misalkan A, B dua matriks persegi pada ring R. Kita ingin menghitung produk matriks C sebagai

𝐂 = 𝐀 𝐁 𝐀, 𝐁, 𝐂 \in R^{2^{n} \times 2^{n}}

Jika matriks A, B bukan bertipe 2ⁿ x 2ⁿ kita isi baris-baris dan kolom-kolom yang kosong dengan nol.

Kita partisi A, B dan C kedalam matriks blok yang berukuran sama.

𝐀 = [\begin{matrix} 𝐀_{1, 1} & 𝐀_{1, 2} \\ 𝐀_{2, 1} & 𝐀_{2, 2} \end{matrix}], 𝐁 = [\begin{matrix} 𝐁_{1, 1} & 𝐁_{1, 2} \\ 𝐁_{2, 1} & 𝐁_{2, 2} \end{matrix}], 𝐂 = [\begin{matrix} 𝐂_{1, 1} & 𝐂_{1, 2} \\ 𝐂_{2, 1} & 𝐂_{2, 2} \end{matrix}]

dengan

𝐀_{i, j}, 𝐁_{i, j}, 𝐂_{i, j} \in R^{2^{n - 1} \times 2^{n - 1}}

lalu

𝐂_{1, 1} = 𝐀_{1, 1} 𝐁_{1, 1} + 𝐀_{1, 2} 𝐁_{2, 1}

𝐂_{1, 2} = 𝐀_{1, 1} 𝐁_{1, 2} + 𝐀_{1, 2} 𝐁_{2, 2}

𝐂_{2, 1} = 𝐀_{2, 1} 𝐁_{1, 1} + 𝐀_{2, 2} 𝐁_{2, 1}

𝐂_{2, 2} = 𝐀_{2, 1} 𝐁_{1, 2} + 𝐀_{2, 2} 𝐁_{2, 2}

Dengan konstruksi ini kita tidak mengurangi jumlah dari perkalian-perkalian. Kita masih memerlukan 8 perkalian-perkalian untuk menghitung matriks-matriks C_i,j, dengan jumlah perkalian yang sama kita perlukan ketika menggunakan matriks perkalian standar.

Sekarang sampai pada bagian terpenting. Kita tetapkan matriks baru

𝐌_{1} := (𝐀_{1, 1} + 𝐀_{2, 2}) (𝐁_{1, 1} + 𝐁_{2, 2})

𝐌_{2} := (𝐀_{2, 1} + 𝐀_{2, 2}) 𝐁_{1, 1}

𝐌_{3} := 𝐀_{1, 1} (𝐁_{1, 2} - 𝐁_{2, 2})

𝐌_{4} := 𝐀_{2, 2} (𝐁_{2, 1} - 𝐁_{1, 1})

𝐌_{5} := (𝐀_{1, 1} + 𝐀_{1, 2}) 𝐁_{2, 2}

𝐌_{6} := (𝐀_{2, 1} - 𝐀_{1, 1}) (𝐁_{1, 1} + 𝐁_{1, 2})

𝐌_{7} := (𝐀_{1, 2} - 𝐀_{2, 2}) (𝐁_{2, 1} + 𝐁_{2, 2})

Yang kemudian digunakan untuk mengekspresikan C_i,j dalam bentuk M_k. Karena kita telah mendefenisikan M_k kita bisa mengeliminasi satu perkalian matriks dan mengurangi jumlah perkalian-perkalian menjadi 7 (satu perkalian matriks untuk tiap M_k) dan ekspresi C_i,j sebagai

𝐂_{1, 1} = 𝐌_{1} + 𝐌_{4} - 𝐌_{5} + 𝐌_{7}

𝐂_{1, 2} = 𝐌_{3} + 𝐌_{5}

𝐂_{2, 1} = 𝐌_{2} + 𝐌_{4}

𝐂_{2, 2} = 𝐌_{1} - 𝐌_{2} + 𝐌_{3} + 𝐌_{6}

Kita iterasikan bagian diatas ke-n kali proses sampai submatriks-submatriks menjadi angka-angka.

Algoritma Strassen pada penerapannya mengubah metode standar dari perkalian matriks agar submatriks-submatriks yang cukup kecil menjadi lebih efisien. Fakta-fakta agar algoritma Strassen lebih efisien bergantung pada implementasi khusus dan hardware.

Analisi Numerik

Perkalian matriks standar melakukan

n^{3} = n^{\log_{2} 8}

perkalian-perkalian dari elemen-elemen dalam ring R. Kita anggap penjumlahan-penjumlahan diperlukan karena bergantung pada R, yang bisa jauh lebih cepat daripada perkalian-perkalian dalam implementasi pada komputer terutama jika ukuran dari entri matriks melebihi ukuran kata dari mesin.

Dengan algoritma Strassen kita bisa mengurangi jumlah perkalian-perkalian

n^{\log_{2} 7} \approx n^{2.807}

.

Pengurangan dalam jumlah perkalian bagaimanapun akan sampai saat pilihan dari sedikit pengurangan kestabilan numerik.

Contoh program sederhana pada Matlab

function c = strass(a,b)
nmin = 2;
%misalkan matriks a dan b berukuran 2 x 2
[n,n] = size(a);
if n <= nmin;
   c = a*b;
else
   %entri matriks a dan b berukuran n x n; n=2^k; k=2,3,...
   %misalkan entri matriks a dan b berukuran n=2^2 atau 4 x 4
   a11=a(1:2,1:2); a12=a(1:2,3:4); a21=a(3:4,1:2); a22=a(3:4,3:4);
   b11=b(1:2,1:2); b12=b(1:2,3:4); b21=b(3:4,1:2); b22=b(3:4,3:4);
   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);
   c = [p1+p4-p5+p7 p3+p5; p2+p4 p1-p2+p3+p6];
end

Catatan: program diatas hanya untuk matriks berukuran 1x1, 2x2, 4x4. Untuk matriks yang berukuran lebih besar, masih diperlukan penyempurnaan. Agar programnya bisa berjalan.

Pranala luar

(also includes formulas for fast matrix inversion)

Sumber dan atribusi

Konten artikel ini diadaptasi dari Wikipedia bahasa Indonesia, revisi 28365219 (2025-11-07T03:40:57Z), yang tersedia berdasarkan lisensi Creative Commons Atribusi-BerbagiSerupa (CC BY-SA). Mohon gunakan konten ini secara bijak serta sesuai dengan ketentuan lisensi yang berlaku.