Task: Kronecker product


C++: #include <cassert>
#include <iomanip>
#include <iostream>
#include <vector>

template <typename scalar_type> class matrix {
public:
    matrix(size_t rows, size_t columns)
        : rows_(rows), columns_(columns), elements_(rows * columns) {}
    matrix(size_t rows, size_t columns,
        const std::initializer_list<std::initializer_list<scalar_type>>& values)
        : rows_(rows), columns_(columns), elements_(rows * columns) {
        assert(values.size() <= rows_);
        size_t i = 0;
        for (const auto& row : values) {
            assert(row.size() <= columns_);
            std::copy(begin(row), end(row), &elements_[i]);
            i += columns_;
        }
    }
    size_t rows() const { return rows_; }
    size_t columns() const { return columns_; }

    const scalar_type& operator()(size_t row, size_t column) const {
        assert(row < rows_);
        assert(column < columns_);
        return elements_[row * columns_ + column];
    }
    scalar_type& operator()(size_t row, size_t column) {
        assert(row < rows_);
        assert(column < columns_);
        return elements_[row * columns_ + column];
    }
private:
    size_t rows_;
    size_t columns_;
    std::vector<scalar_type> elements_;
};


template <typename scalar_type>
matrix<scalar_type> kronecker_product(const matrix<scalar_type>& a,
                                      const matrix<scalar_type>& b) {
    size_t arows = a.rows();
    size_t acolumns = a.columns();
    size_t brows = b.rows();
    size_t bcolumns = b.columns();
    matrix<scalar_type> c(arows * brows, acolumns * bcolumns);
    for (size_t i = 0; i < arows; ++i)
        for (size_t j = 0; j < acolumns; ++j)
            for (size_t k = 0; k < brows; ++k)
                for (size_t l = 0; l < bcolumns; ++l)
                    c(i*brows + k, j*bcolumns + l) = a(i, j) * b(k, l);
    return c;
}

template <typename scalar_type>
void print(std::wostream& out, const matrix<scalar_type>& a) {
    const wchar_t* box_top_left = L"\x250c";
    const wchar_t* box_top_right = L"\x2510";
    const wchar_t* box_bottom_left = L"\x2514";
    const wchar_t* box_bottom_right = L"\x2518";
    const wchar_t* box_vertical = L"\x2502";
    const wchar_t nl = L'\n';
    const wchar_t space = L' ';
    const int width = 2;

    size_t rows = a.rows(), columns = a.columns();
    std::wstring spaces((width + 1) * columns, space);
    out << box_top_left << spaces << box_top_right << nl;
    for (size_t row = 0; row < rows; ++row) {
        out << box_vertical;
        for (size_t column = 0; column < columns; ++column)
            out << std::setw(width) << a(row, column) << space;
        out << box_vertical << nl;
    }
    out << box_bottom_left << spaces << box_bottom_right << nl;
}

void test1() {
    matrix<int> matrix1(2, 2, {{1,2}, {3,4}});
    matrix<int> matrix2(2, 2, {{0,5}, {6,7}});
    std::wcout << L"Test case 1:\n";
    print(std::wcout, kronecker_product(matrix1, matrix2));
}

void test2() {
    matrix<int> matrix1(3, 3, {{0,1,0}, {1,1,1}, {0,1,0}});
    matrix<int> matrix2(3, 4, {{1,1,1,1}, {1,0,0,1}, {1,1,1,1}});
    std::wcout << L"Test case 2:\n";
    print(std::wcout, kronecker_product(matrix1, matrix2));
}

int main() {
    std::wcout.imbue(std::locale(""));
    test1();
    test2();
    return 0;
}









Fortran:       MODULE ARRAYMUSH	
       CONTAINS		
        SUBROUTINE KPRODUCT(A,B,AB)	
Considers the arrays to be addressed as A(row,column), despite any storage order arrangements.        .
Creating array AB to fit here, adjusting the caller's array AB, may not work on some compilers.
         INTEGER A(:,:),B(:,:)		
         INTEGER, ALLOCATABLE:: AB(:,:)	
         INTEGER R,RA,RB,C,CA,CB,I	
          RA = UBOUND(A,DIM = 1)	
          CA = UBOUND(A,DIM = 2)	
          RB = UBOUND(B,DIM = 1)	
          CB = UBOUND(B,DIM = 2)	
          WRITE (6,1) "A",RA,CA,"B",RB,CB,"A.k.B",RA*RB,CA*CB	
    1     FORMAT (3(A," is ",I0,"x",I0,1X))	
          IF (ALLOCATED(AB)) DEALLOCATE(AB)	
          ALLOCATE (AB(RA*RB,CA*CB))		
          R = 0		
          DO I = 1,RA	
            C = 0		
            DO J = 1,CA		
              AB(R + 1:R + RB,C + 1:C + CB) = A(I,J)*B	
              C = C + CB		
            END DO		
            R = R + RB		
          END DO	
        END SUBROUTINE KPRODUCT	

        SUBROUTINE SHOW(F,A)	
         INTEGER F	
         INTEGER A(:,:)	
         INTEGER R	
          DO R = 1,UBOUND(A,DIM = 1)	
            WRITE (F,1) A(R,:)		
    1       FORMAT (666I3)		
          END DO			
        END SUBROUTINE SHOW	
      END MODULE ARRAYMUSH	

      PROGRAM POKE
      USE ARRAYMUSH
      INTEGER A(2,2),B(2,2)		
      INTEGER, ALLOCATABLE:: AB(:,:)	
      INTEGER C(3,3),D(3,4)		
      DATA A/1,3, 2,4/,B/0,6, 5,7/	
      DATA C/0,1,0, 1,1,1, 0,1,0/	
      DATA D/1,1,1, 1,0,1, 1,0,1, 1,1,1/

      WRITE (6,*) "First test..."
      CALL KPRODUCT(A,B,AB)
      CALL SHOW (6,AB)

      WRITE (6,*)
      WRITE (6,*) "Second test..."
      CALL KPRODUCT(C,D,AB)
      CALL SHOW (6,AB)

      END