Scribd
Upload
473 views11 pages

Strassens Matrix Multiplication

Strassen's algorithm improves upon basic matrix multiplication by reducing the number of multiplication operations needed to multiply 2x2 matrices from 8 to 7. It achieves this using a divide-and-conquer approach, dividing the matrices into sub-matrices and recursively multiplying the sub-matrices using a technique that requires 7 multiplications rather than the usual 8. This reduces the time complexity of matrix multiplication from O(N^3) to O(N^{2.807}).

Uploaded by

Rohit Kumra
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
473 views11 pages

Strassens Matrix Multiplication

Strassen's algorithm improves upon basic matrix multiplication by reducing the number of multiplication operations needed to multiply 2x2 matrices from 8 to 7. It achieves this using a divide-and-conquer approach, dividing the matrices into sub-matrices and recursively multiplying the sub-matrices using a technique that requires 7 multiplications rather than the usual 8. This reduces the time complexity of matrix multiplication from O(N^3) to O(N^{2.807}).

Uploaded by

Rohit Kumra
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 11

Strassen's Matrix

Multiplication
Basic Matrix Multiplication

Suppose we want to multiply two matrices of


size N x N: for example A x B = C.

C11 = a11b11 + a12b21

C12 = a11b12 + a12b22

C21 = a21b11 + a22b21 2x2 matrix multiplication can be


accomplished in 8 multiplication.(2log28
C22 = a21b12 + a22b22
=23)
Basic Matrix Multiplication
void matrix_mult (){
for (i = 1; i <= N; i++) { algorithm
for (j = 1; j <= N; j++) {
compute Ci,j; }

}}

Time analysis
Strassens’s Matrix Multiplication

Strassen showed that 2x2 matrix


multiplication can be accomplished in 7
multiplication and 18 additions or
subtractions. .(2log27 =22.807)

This reduce can be done by Divide and


Conquer Approach.
Divide-and-Conquer
Divide-and conquer is a general algorithm
design paradigm:
Divide: divide the input data S in two or more
disjoint subsets S1, S2, …
Recur: solve the subproblems recursively
Conquer: combine the solutions for S1, S2, …,
into a solution for S
The base case for the recursion are
subproblems of constant size
Analysis can be done using recurrence
equations
Divide and Conquer Matrix
Multiply
A B=R
A0 A1 B0 B1 A0 B0+A1 B2 A0 B1+A1 B3

A2 A3 B2 B3 = A2 B0+A3 B2 A2 B1+A3 B3

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

Use blocked matrix multiply equations


Recursively multiply sub-matrices
Divide and Conquer Matrix
Multiply

A B=R
a0 b0 a0 b0
=

Terminate recursion with a simple base case


Strassens’s Matrix Multiplication

P1 = (A11+ A22)(B11+B22) C11 = P1 + P4 - P5 + P7


P2 = (A21 + A22) * B11 C12 = P3 + P5
P3 = A11 * (B12 - B22) C21 = P2 + P4
P4 = A22 * (B21 - B11) C22 = P1 + P3 - P2 + P6
P5 = (A11 + A12) * B22
P6 = (A21 - A11) * (B11 + B12)
P7 = (A12 - A22) * (B21 + B22)
Comparison

C11 = P1 + P4 - P5 + P7
= (A11+ A22)(B11+B22) + A22 * (B21 - B11) - (A11 + A12) * B22+
(A12 - A22) * (B21 + B22)
= A11 B11 + A11 B22 + A22 B11 + A22 B22 + A22 B21 – A22 B11 -
A11 B22 -A12 B22 + A12 B21 + A12 B22 – A22 B21 – A22 B22
= A11 B11 + A12 B21
Strassen Algorithm
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); Divide matrices in
} sub-matrices and
recursively
multiply sub-
matrices
Time Analysis

You might also like