feat: Implement Matrix , its Methods and Some Functions including Strassen Matrix Multiplication in Go

math/matrix/strassenmatrixmultiply.go

@@ -0,0 +1,138 @@
+// filename: main.go
+// description: Implements matrix multiplication using the Strassen algorithm.
+// details:
+// This program takes two matrices as input and performs matrix multiplication
+// using the Strassen algorithm, which is an optimized divide-and-conquer
+// approach. It allows for efficient multiplication of large matrices.
+// author(s): Mohit Raghav(https://github.com/mohit07raghav19)
+// See strassenmatrixmultiply_test.go for test cases
+package matrix
+
+// Perform matrix multiplication using Strassen's algorithm
+func strassenMatrixMultiply(A, B [][]int) [][]int {
+	n := len(A)
+
+	// Check if matrices are 2x2 or smaller
+	if n <= 2 {
+		return standardMatrixMultiply(A, B)
+	}
+
+	// Calculate the size of submatrices
+	mid := n / 2
+
+	// Create submatrices
+	A11 := make([][]int, mid)
+	A12 := make([][]int, mid)
+	A21 := make([][]int, mid)
+	A22 := make([][]int, mid)
+
+	B11 := make([][]int, mid)
+	B12 := make([][]int, mid)
+	B21 := make([][]int, mid)
+	B22 := make([][]int, mid)
+
+	for i := 0; i < mid; i++ {
+		A11[i] = make([]int, mid)
+		A12[i] = make([]int, mid)
+		A21[i] = make([]int, mid)
+		A22[i] = make([]int, mid)
+
+		B11[i] = make([]int, mid)
+		B12[i] = make([]int, mid)
+		B21[i] = make([]int, mid)
+		B22[i] = make([]int, mid)
+
+		for j := 0; j < mid; j++ {
+			A11[i][j] = A[i][j]
+			A12[i][j] = A[i][j+mid]
+			A21[i][j] = A[i+mid][j]
+			A22[i][j] = A[i+mid][j+mid]
+
+			B11[i][j] = B[i][j]
+			B12[i][j] = B[i][j+mid]
+			B21[i][j] = B[i+mid][j]
+			B22[i][j] = B[i+mid][j+mid]
+		}
+	}
+
+	// Recursive steps
+	M1 := strassenMatrixMultiply(addMatrices(A11, A22), addMatrices(B11, B22))
+	M2 := strassenMatrixMultiply(addMatrices(A21, A22), B11)
+	M3 := strassenMatrixMultiply(A11, subtractMatrices(B12, B22))
+	M4 := strassenMatrixMultiply(A22, subtractMatrices(B21, B11))
+	M5 := strassenMatrixMultiply(addMatrices(A11, A12), B22)
+	M6 := strassenMatrixMultiply(subtractMatrices(A21, A11), addMatrices(B11, B12))
+	M7 := strassenMatrixMultiply(subtractMatrices(A12, A22), addMatrices(B21, B22))
+
+	// Calculate result submatrices
+	C11 := subtractMatrices(addMatrices(addMatrices(M1, M4), M7), M5)
+	C12 := addMatrices(M3, M5)
+	C21 := addMatrices(M2, M4)
+	C22 := subtractMatrices(addMatrices(addMatrices(M1, M3), M6), M2)
+
+	// Combine submatrices into the result matrix
+	C := make([][]int, n)
+	for i := 0; i < n; i++ {
+		C[i] = make([]int, n)
+		for j := 0; j < n; j++ {
+			if i < mid && j < mid {
+				C[i][j] = C11[i][j]
+			} else if i < mid && j >= mid {
+				C[i][j] = C12[i][j-mid]
+			} else if i >= mid && j < mid {
+				C[i][j] = C21[i-mid][j]
+			} else {
+				C[i][j] = C22[i-mid][j-mid]
+			}
+		}
+	}
+
+	return C
+}
+
+// Add two matrices element-wise
+func addMatrices(A, B [][]int) [][]int {
+	n := len(A)
+	result := make([][]int, n)
+
+	for i := 0; i < n; i++ {
+		result[i] = make([]int, n)
+		for j := 0; j < n; j++ {
+			result[i][j] = A[i][j] + B[i][j]
+		}
+	}
+
+	return result
+}
+
+// Subtract one matrix from another element-wise
+func subtractMatrices(A, B [][]int) [][]int {
+	n := len(A)
+	result := make([][]int, n)
+
+	for i := 0; i < n; i++ {
+		result[i] = make([]int, n)
+		for j := 0; j < n; j++ {
+			result[i][j] = A[i][j] - B[i][j]
+		}
+	}
+
+	return result
+}
+
+// Perform standard matrix multiplication
+func standardMatrixMultiply(A, B [][]int) [][]int {
+	n := len(A)
+	result := make([][]int, n)
+
+	for i := 0; i < n; i++ {
+		result[i] = make([]int, n)
+		for j := 0; j < n; j++ {
+			for k := 0; k < n; k++ {
+				result[i][j] += A[i][k] * B[k][j]
+			}
+		}
+	}
+
+	return result
+}

math/matrix/strassenmatrixmultiply_test.go

@@ -0,0 +1,91 @@
+package matrix
+
+import (
+	"fmt"
+	"math/rand"
+	"os"
+	"testing"
+	"time"
+)
+
+// Example usage of the matrix multiplication function
+func Example() {
+	matrixA := [][]int{
+		{1, 2},
+		{3, 4},
+	}
+
+	matrixB := [][]int{
+		{5, 6},
+		{7, 8},
+	}
+
+	result := strassenMatrixMultiply(matrixA, matrixB)
+	printMatrix(result)
+
+	// Output:
+	// [19 22]
+	// [43 50]
+}
+
+// TestMatrixMultiplication performs a test on matrix multiplication.
+func TestMatrixMultiplication(t *testing.T) {
+	rand.Seed(time.Now().UnixNano())
+
+	// Generate random matrices for testing
+	size := 4
+	matrixA := makeRandomMatrix(size)
+	matrixB := makeRandomMatrix(size)
+
+	// Calculate the expected result using the standard multiplication
+	expected := standardMatrixMultiply(matrixA, matrixB)
+
+	// Calculate the result using the Strassen algorithm
+	result := strassenMatrixMultiply(matrixA, matrixB)
+
+	// Check if the result matches the expected result
+	for i := 0; i < size; i++ {
+		for j := 0; j < size; j++ {
+			if result[i][j] != expected[i][j] {
+				t.Errorf("Mismatch at position (%d, %d). Expected %d, but got %d.", i, j, expected[i][j], result[i][j])
+			}
+		}
+	}
+}
+
+// Generate a random matrix of the given size
+func makeRandomMatrix(size int) [][]int {
+	matrix := make([][]int, size)
+	for i := 0; i < size; i++ {
+		matrix[i] = make([]int, size)
+		for j := 0; j < size; j++ {
+			matrix[i][j] = rand.Intn(10) // Generate random integers between 0 and 9
+		}
+	}
+	return matrix
+}
+
+func TestMain(m *testing.M) {
+	// Run the tests
+	code := m.Run()
+	os.Exit(code)
+}
+
+// BenchmarkStrassenMatrixMultiply benchmarks the strassenMatrixMultiply function.
+func BenchmarkStrassenMatrixMultiply(b *testing.B) {
+	size := 128 // Change the size as needed for your benchmark
+	matrixA := makeRandomMatrix(size)
+	matrixB := makeRandomMatrix(size)
+
+	b.ResetTimer() // Reset the benchmark timer before the actual benchmark
+	for i := 0; i < b.N; i++ {
+		_ = strassenMatrixMultiply(matrixA, matrixB)
+	}
+}
+
+// Print a matrix
+func printMatrix(matrix [][]int) {
+	for _, row := range matrix {
+		fmt.Println(row)
+	}
+}