Возврат массива типа array из функции

template<typename T, size_t r1, size_t c1, size_t r2, size_t c2, size_t r3, size_t c3>
static array<array<T, c3>, r3> matrices_mutltiplication(array<array<T, c1>, r1> &x, array<array<T, c2>, r2> &y);

template<typename T, size_t r1, size_t c1, size_t r2, size_t c2, size_t r3, size_t c3>
inline array<array<T, c3>, r3> ArraysStaticStdLibrary::matrices_mutltiplication(array<array<T, c1>, r1>& x, array<array<T, c2>, r2>& y)
    {
        //size_t r3 = r1, c3 = c2;
        array<array<T, c3>, r3> multy;
 
        // dimension check
        if (r1 == 0 || c1 == 0 || r2 == 0 || c2 == 0) throw MyException("one of the dimentions of incoming matrices is 0");
        if (c1 != r2) throw MyException("the number of columns in the first matrix is not equal the number of rows in the second matrix");
        //// Next requirements are always true, cause there is initialization vector multy
        //if (rows_x != rows_multy) throw MyException("the number of rows in the first matrix is not equal the number of rows in the result matrix");
        //if (cols_y != cols_multy) throw MyException("the number of columns in the second matrix is not equal the number of columns in the result matrix");
 
 
        T sum = 0;
 
        for (size_t i = 0; i < r1; i++) {
            for (size_t j = 0; j < c2; j++) {
                for (size_t k = 0; k < c1; k++)
                    sum += x[i][k] * y[k][j];
                multy[i][j] = sum;
                sum = 0;
            }
        }
 
        return multy;
    }

    // Initialization
    const size_t rows1 = 3, cols1 = 3;
    const size_t rows2 = 3, cols2 = 3;
    const size_t rows3 = 3, cols3 = 3;
 
    array < array <int, cols1>, rows1> a1;
    array < array <int, cols2>, rows2> a2;
    array < array <int, cols3>, rows3> a3;
 
    // Filling
    ArraysStaticStdLibrary::filling_array_2D(a1, 0, 1);
    ArraysStaticStdLibrary::filling_array_2D(a2, 0, 1);
 
    // Operation
    a3 = ArraysStaticStdLibrary::matrices_mutltiplication(a1, a2);

template<class T, size_t m, size_t n>
using matrix = std::array<std::array<T, n>, m>;
 
template<class T, size_t m, size_t n, size_t k>
matrix<T, m, n> multiply(const matrix<T, m, k>& lh, const matrix<T, k, n>& rh);

template<class T, size_t m, size_t n>
using matrix = std::array<std::array<T, n>, m>;
 
template<class T, size_t m, size_t n, size_t k>
matrix<T, m, n> multiply(const matrix<T, m, k>& lh, const matrix<T, k, n>& rh);

template<class T, size_t m, size_t n, size_t k, size_t r3, size_t c3>
matrix<T, r3, c3> multiply(const matrix<T, m, k>& lh, const matrix<T, k, n>& rh);

matrix<int, 100, 100> c;
c = multiply<int, 10, 5, 8, 100, 100>(a, b);

template<size_t r3, size_t c3, class T, size_t m, size_t n, size_t k>
matrix<T, r3, c3> multiply(const matrix<T, m, k>& lh, const matrix<T, k, n>& rh);

matrix<int, 100, 100> c;
c = multiply<100, 100>(a, b);

matrix<int, 100, 100> c;