Matrix multiplication done right with Go (https://play.golang.org/p/Bab4PmkaOfZ)

matrixMultiplication.go

package main

import (
	"log"
	"strconv"
)

func main() {
	m1 := generateTestMatrix1()
	m2 := generateTestMatrix2()
	m3 := MultiplyMatrix(m1, m2)
	DumpMatrix(m3)
}

// DumpMatrix is delegated to print the given matrix
func DumpMatrix(m [][]int) {
	if m == nil {
		return
	}
	for i := range m {
		log.Println(m[i])
	}
	log.Println("Rows: " + strconv.Itoa(len(m)) + " Columns: " + strconv.Itoa(len(m[0])))
}

// generateTestMatrix1 is delegated to generate a matrix for test purpouse
func generateTestMatrix1() [][]int {
	matrix := make([][]int, 2)
	matrix[0] = []int{1, 2, 3}
	matrix[1] = []int{4, 5, 6}
	return matrix
}

// generateTestMatrix2 is delegated to generate a matrix for test purpouse
func generateTestMatrix2() [][]int {
	matrix := make([][]int, 3)
	matrix[0] = []int{1, 4, 7}
	matrix[1] = []int{2, 5, 8}
	matrix[2] = []int{3, 6, 9}
	return matrix
}

// MultiplyMatrix is delegated to execute the multiplication between the given matrix
func MultiplyMatrix(m1, m2 [][]int) [][]int {
	if m1 == nil || m2 == nil {
		return nil
	}

	if len(m1) == 0 || len(m2) == 0 {
		log.Println("Matrix empty")
		return nil
	}
	if len(m1[0]) != len(m2) {
		log.Println("Different size\nM1:")
		DumpMatrix(m1)
		log.Println("M2:")
		DumpMatrix(m2)
		return nil
	}
	total := InitStaticMatrix(len(m1), len(m2[0]), -1)
	for i := range m1 {
		arrayM1 := m1[i]
		for k := 0; k < len(m2); k++ {
			arrayM2 := make([]int, len(arrayM1))
			for j := range m2 {
				arrayM2[j] = m2[j][k]
			}
			data := MultiplySumArray(arrayM1, arrayM2)
			total[i][k] = data
		}
	}
	//DumpMatrix(total)
	return total
}

// MultiplySumArray is delegated to multiply the given array and sum every number of the result array
func MultiplySumArray(a, b []int) int {
	total := make([]int, len(a))
	for i := range a {
		total[i] = a[i] * b[i]
	}
	return SumIntArray(total)
}

// SumIntArray return the sum of every element contained in the array
func SumIntArray(integers []int) int {
	sum := 0
	for i := range integers {
		sum += integers[i]
	}
	return sum
}

// InitStaticMatrix is delegated to initialize a matrix with the given dimension using the same value for each field
func InitStaticMatrix(r, c, value int) [][]int {
	m := CreateEmptyMatrix(r, c)
	for i := range m {
		m[i] = InitIntArray(c, value)
	}
	return m
}

// InitIntArray is delegated to initialize a new array of the given dimension, populated with the same input value
func InitIntArray(dimension, value int) []int {
	if dimension <= 0 {
		return nil
	}

	array := make([]int, dimension)
	for i := 0; i < dimension; i++ {
		array[i] = value
	}
	return array
}

// CreateEmptyMatrix is delegated to initialize a new empty matrix
func CreateEmptyMatrix(r, c int) [][]int {
	if r <= 1 || c <= 1 {
		return nil
	}
	matrix := make([][]int, r)
	for rowsIndex := range matrix {
		matrix[rowsIndex] = make([]int, c)
	}
	return matrix
}