Kronecker product

From Rosetta Code
This page uses content from Wikipedia. The original article was at Kronecker product. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance)
Task
Kronecker product
You are encouraged to solve this task according to the task description, using any language you may know.


Task

Implement the   Kronecker product   of two matrices (arbitrary sized) resulting in a block matrix.


Test cases

Show results for each of the following two samples:


Sample 1 (from Wikipedia):



          ┌   ┐     ┌   ┐     ┌           ┐
          │1 2│     │0 5│     │ 0  5  0 10│
          │3 4│  x  │6 7│  =  │ 6  7 12 14│
	  └   ┘     └   ┘     │ 0 15  0 20│
	                      │18 21 24 28│
                              └           ┘ 

Sample 2:

          ┌     ┐     ┌       ┐     ┌                       ┐       
          │0 1 0│     │1 1 1 1│     │0 0 0 0 1 1 1 1 0 0 0 0│
          │1 1 1│  x  │1 0 0 1│  =  │0 0 0 0 1 0 0 1 0 0 0 0│
          │0 1 0│     │1 1 1 1│     │0 0 0 0 1 1 1 1 0 0 0 0│
	  └     ┘     └       ┘     │1 1 1 1 1 1 1 1 1 1 1 1│
                                    │1 0 0 1 1 0 0 1 1 0 0 1│
                                    │1 1 1 1 1 1 1 1 1 1 1 1│
                                    │0 0 0 0 1 1 1 1 0 0 0 0│
                                    │0 0 0 0 1 0 0 1 0 0 0 0│
                                    │0 0 0 0 1 1 1 1 0 0 0 0│
                                    └                       ┘


See implementations and results below in JavaScript and PARI/GP languages.


Related task



11l

Translation of: Python
V a1 = [[1, 2], [3, 4]]
V b1 = [[0, 5], [6, 7]]

V a2 = [[0, 1, 0], [1, 1, 1], [0, 1, 0]]
V b2 = [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]]

F kronecker(matrix1, matrix2)
   [[Int]] final_list
   [Int] sub_list
   V count = matrix2.len

   L(elem1) matrix1
      V counter = 0
      V check = 0
      L check < count
         L(num1) elem1
            L(num2) matrix2[counter]
               sub_list.append(num1 * num2)
         counter++
         final_list.append(sub_list)
         sub_list.drop()
         check++

   R final_list

V result1 = kronecker(a1, b1)
L(elem) result1
   print(elem)

print(‘’)

V result2 = kronecker(a2, b2)
L(elem) result2
   print(elem)
Output:
[0, 5, 0, 10]
[6, 7, 12, 14]
[0, 15, 0, 20]
[18, 21, 24, 28]

[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]

360 Assembly

*        Kronecker product         06/04/2017
KRONECK  CSECT
         USING  KRONECK,R13        base register
         B      72(R15)            skip savearea
         DC     17F'0'             savearea
         STM    R14,R12,12(R13)    save previous context
         ST     R13,4(R15)         link backward
         ST     R15,8(R13)         link forward
         LR     R13,R15            set addressability
         LA     R1,1               first example
         BAL    R14,PRODUCT        call product(a1,b1)
         BAL    R14,PRINT          call print(r)
         XPRNT  =C'---',3          separator
         LA     R1,2               second example
         BAL    R14,PRODUCT        call product(a2,b2)
         BAL    R14,PRINT          call print(r)
         L      R13,4(0,R13)       restore previous savearea pointer
         LM     R14,R12,12(R13)    restore previous context
         XR     R15,R15            rc=0
         BR     R14                exit
*------- ----   ----------------------------------------
PRODUCT  EQU    *                  product(o)
         STC    R1,OO              store o
       IF CLI,OO,EQ,X'01' THEN     if o=1 then
         MVC    MM(8),DIM1           (m,n)=hbound(a1) (p,q)=hbound(b1)
         LA     R1,A1                @a1
         LA     R2,B1                @b1
       ELSE     ,                  else
         MVC    MM(8),DIM2           (m,n)=hbound(a2) (p,q)=hbound(b2)
         LA     R1,A2                @a2
         LA     R2,B2                @b2
       ENDIF    ,                  endif
         ST     R1,ADDRA           addra=@a1
         ST     R2,ADDRB           addrb=@b1
         LH     R1,MM              m
         MH     R1,PP              p
         STH    R1,RI              ri=m*p
         LH     R2,NN              n
         MH     R2,QQ              *q
         STH    R2,RJ              rj=n*q
         LA     R6,1               i=1
       DO WHILE=(CH,R6,LE,MM)      do i=1 to m
         LA     R7,1                 j=1
       DO WHILE=(CH,R7,LE,NN)        do j=1 to n
         LA     R8,1                   k=1
       DO WHILE=(CH,R8,LE,PP)          do k=1 to p
         LA     R9,1                     l=1
       DO WHILE=(CH,R9,LE,QQ)            do l=1 to q
         LR     R1,R6                      i
         BCTR   R1,0
         MH     R1,NN                      *hbound(a,2)
         AR     R1,R7                      j
         BCTR   R1,0
         SLA    R1,2
         L      R4,ADDRA                   @a
         L      R2,0(R4,R1)                r2=a(i,j)
         LR     R1,R8                      k
         BCTR   R1,0
         MH     R1,QQ                      *hbound(b1,2)
         AR     R1,R9                      l
         BCTR   R1,0
         SLA    R1,2
         L      R4,ADDRB                   @b
         L      R3,0(R4,R1)                r3=b(k,l)
         LR     R5,R2                      r2
         MR     R4,R3                      *r3
         LR     R0,R5                      r0=a(i,j)*b(k,l)
         LR     R1,R6                      i
         BCTR   R1,0                       i-1
         MH     R1,PP                      *p
         AR     R1,R8                      r1=p*(i-1)+k
         LR     R2,R7                      j
         BCTR   R2,0                       j-1
         MH     R2,QQ                      *q
         AR     R2,R9                      r2=q*(j-1)+l
         BCTR   R1,0
         MH     R1,=AL2(NR)                *nr
         AR     R1,R2                      r1=r1+r2
         SLA    R1,2
         ST     R0,R-4(R1)                 r(p*(i-1)+k,q*(j-1)+l)=r0
         LA     R9,1(R9)                   l++
       ENDDO    ,                        enddo l
         LA     R8,1(R8)                 k++
       ENDDO    ,                      enddo k
         LA     R7,1(R7)               j++
       ENDDO    ,                    enddo j
         LA     R6,1(R6)             i++
       ENDDO    ,                  enddo i
         BR     R14                return
*------- ----   ----------------------------------------
PRINT    EQU    *                  print
         LA     R6,1               i
       DO WHILE=(CH,R6,LE,RI)      do i=1 to ri
         MVC    PG,=CL80' '          init buffer
         LA     R10,PG               pgi=0
         LA     R7,1                 j
       DO WHILE=(CH,R7,LE,RJ)        do j=1 to rj
         LR     R1,R6                  i
         BCTR   R1,0
         MH     R1,=AL2(NR)            *nr
         AR     R1,R7                  +j
         SLA    R1,2
         L      R2,R-4(R1)             r(i,j)
         XDECO  R2,XDEC                edit
         MVC    0(ND,R10),XDEC+12-ND   output
         LA     R10,ND(R10)            pgi=pgi+nd
         LA     R7,1(R7)               j++
       ENDDO    ,                    enddo j
         XPRNT  PG,L'PG              print buffer
         LA     R6,1(R6)             i++
       ENDDO    ,                  enddo j
         BR     R14                return
*        ----   ----------------------------------------
NR       EQU    32                 dim result max
ND       EQU    3                  digits to print
A1       DC     F'1',F'2'              a1(2,2)
         DC     F'3',F'4'
B1       DC     F'0',F'5'              b1(2,2)
         DC     F'6',F'7'
DIM1     DC     H'2',H'2',H'2',H'2'    dim a1 , dim b1
A2       DC     F'0',F'1',F'0'         a2(3,3)
         DC     F'1',F'1',F'1'  
         DC     F'0',F'1',F'0'
B2       DC     F'1',F'1',F'1',F'1'    b2(3,4)
         DC     F'1',F'0',F'0',F'1'
         DC     F'1',F'1',F'1',F'1'
DIM2     DC     H'3',H'3',H'3',H'4'    dim a2 , dim b2
ADDRA    DS     A                  @a
ADDRB    DS     A                  @b
RI       DS     H                  ri
RJ       DS     H                  rj
MM       DS     H                  m
NN       DS     H                  n
PP       DS     H                  p
QQ       DS     H                  q
OO       DS     X                  o
PG       DS     CL80               buffer
XDEC     DS     CL12
         LTORG
R        DS     (NR*NR)F           r(nr,nr)
         YREGS
         END    KRONECK
Output:
  0  5  0 10
  6  7 12 14
  0 15  0 20
 18 21 24 28
---
  0  0  0  0  1  1  1  1  0  0  0  0
  0  0  0  0  1  0  0  1  0  0  0  0
  0  0  0  0  1  1  1  1  0  0  0  0
  1  1  1  1  1  1  1  1  1  1  1  1
  1  0  0  1  1  0  0  1  1  0  0  1
  1  1  1  1  1  1  1  1  1  1  1  1
  0  0  0  0  1  1  1  1  0  0  0  0
  0  0  0  0  1  0  0  1  0  0  0  0
  0  0  0  0  1  1  1  1  0  0  0  0

Action!

The user must type in the monitor the following command after compilation and before running the program!
SET EndProg=*
CARD EndProg ;required for ALLOCATE.ACT

INCLUDE "D2:ALLOCATE.ACT" ;from the Action! Tool Kit. You must type 'SET EndProg=*' from the monitor after compiling, but before running this program!

DEFINE PTR="CARD"
DEFINE MATRIX_SIZE="4"
TYPE Matrix=[
  BYTE width,height
  PTR data]

PTR FUNC CreateEmpty(BYTE w,h)
  Matrix POINTER m

  m=Alloc(MATRIX_SIZE)
  m.width=w
  m.height=h
  m.data=Alloc(2*w*h)
RETURN (m)

PTR FUNC Create(BYTE w,h INT ARRAY a)
  Matrix POINTER m

  m=CreateEmpty(w,h)
  MoveBlock(m.data,a,2*w*h)
RETURN (m)

PROC Destroy(Matrix POINTER m)
  Free(m.data,2*m.width*m.height)
  Free(m,MATRIX_SIZE) 
RETURN

PTR FUNC Product(Matrix POINTER m1,m2)
  Matrix POINTER m
  BYTE x1,x2,y1,y2,i1,i2,i
  INT ARRAY a1,a2,a

  m=CreateEmpty(m1.width*m2.width,m1.height*m2.height)
  a1=m1.data
  a2=m2.data
  a=m.data
  i=0
  FOR y1=0 TO m1.height-1
  DO
    FOR y2=0 TO m2.height-1
    DO
      FOR x1=0 TO m1.width-1
      DO
        FOR x2=0 TO m2.width-1
        DO
          i1=y1*m1.width+x1
          i2=y2*m2.width+x2
          a(i)=a1(i1)*a2(i2)
          i==+1
        OD
      OD
    OD
  OD
RETURN (m)

PROC PrintMatrix(Matrix POINTER m BYTE x,y,colw)
  BYTE i,j
  CHAR ARRAY tmp(10)
  INT ARRAY d

  d=m.data
  FOR j=0 TO m.height-1
  DO
    Position(x,y+j)
    IF j=0 THEN
      Put($11)
    ELSEIF j=m.height-1 THEN
      Put($1A)
    ELSE
      Put($7C)
    FI

    FOR i=0 TO m.width-1
    DO
      StrI(d(j*m.width+i),tmp)
      Position(x+1+(i+1)*colw+i-tmp(0),y+j)
      Print(tmp)
    OD
    
    Position(x+1+m.width*colw+(m.width-1),y+j)
    IF j=0 THEN
      Put($05)
    ELSEIF j=m.height-1 THEN
      Put($03)
    ELSE
      Put($7C)
    FI
  OD
RETURN

PROC Test1()
  Matrix POINTER m1,m2,m3
  INT ARRAY a1=[1 2 3 4],a2=[0 5 6 7]
  
  m1=Create(2,2,a1)
  m2=Create(2,2,a2)
  m3=Product(m1,m2)

  PrintMatrix(m1,0,2,1)
  Position(5,3) Put('x)
  PrintMatrix(m2,6,2,1)
  Position(11,3) Put('=)
  PrintMatrix(m3,12,1,2)

  Destroy(m1)
  Destroy(m2)
  Destroy(m3)
RETURN

PROC Test2()
  Matrix POINTER m1,m2,m3
  INT ARRAY a1=[0 1 0 1 1 1 0 1 0],
    a2=[1 1 1 1 1 0 0 1 1 1 1 1]

  m1=Create(3,3,a1)
  m2=Create(4,3,a2)
  m3=Product(m1,m2)

  PrintMatrix(m1,0,7,1)
  Position(7,8) Put('x)
  PrintMatrix(m2,8,7,1)
  Position(17,8) Put('=)
  PrintMatrix(m3,2,11,1)

  Destroy(m1)
  Destroy(m2)
  Destroy(m3)
RETURN

PROC Main()

  AllocInit(0)
  Put(125) ;clear the screen
  Test1()
  Test2()
RETURN
Output:

Screenshot from Atari 8-bit computer

            ┌ 0  5  0 10┐
┌1 2┐ ┌0 5┐ │ 6  7 12 14│
└3 4┘x└6 7┘=│ 0 15  0 20│
            └18 21 24 28┘


┌0 1 0┐ ┌1 1 1 1┐
│1 1 1│x│1 0 0 1│=
└0 1 0┘ └1 1 1 1┘

  ┌0 0 0 0 1 1 1 1 0 0 0 0┐
  │0 0 0 0 1 0 0 1 0 0 0 0│
  │0 0 0 0 1 1 1 1 0 0 0 0│
  │1 1 1 1 1 1 1 1 1 1 1 1│
  │1 0 0 1 1 0 0 1 1 0 0 1│
  │1 1 1 1 1 1 1 1 1 1 1 1│
  │0 0 0 0 1 1 1 1 0 0 0 0│
  │0 0 0 0 1 0 0 1 0 0 0 0│
  └0 0 0 0 1 1 1 1 0 0 0 0┘

Ada

Works with: Ada version 83
with Ada.Text_IO;
with Ada.Integer_Text_IO;

procedure Kronecker_Product is
   type Matrix is array (Positive range <>, Positive range <>) of Integer;

   function "*"(Left, Right : in Matrix) return Matrix is
      result : Matrix
        (1 .. Left'Length(1) * Right'Length(1),
         1 .. Left'Length(2) * Right'Length(2));
      LI : Natural := 0;
      LJ : Natural := 0;
   begin
      for I in 0 .. result'Length(1) - 1 loop
         for J in 0 .. result'Length(2) - 1 loop
            result (I + 1, J + 1) :=
              Left(Left'First(1) + (LI), Left'First(2) + (LJ))
              * Right
                (Right'First(1) + (I mod Right'Length(1)),
                 Right'First(2) + (J mod Right'Length(2)));
            if (J+1) mod Right'Length(2) = 0 then
               LJ := LJ + 1;
            end if;
         end loop;
         if (I+1) mod Right'Length(1) = 0 then
            LI := LI + 1;
         end if;
         LJ := 0;
      end loop;
      return result;
   end "*";

   Left1   : constant Matrix := ((1, 2), (3, 4));
   Right1  : constant Matrix := ((0, 5), (6, 7));
   result1 : constant Matrix := Left1 * Right1;
   Left2   : constant Matrix := ((0, 1, 0), (1, 1, 1), (0, 1, 0));
   Right2  : constant Matrix := ((1, 1, 1, 1), (1, 0, 0, 1), (1, 1, 1, 1));
   result2 : constant Matrix := Left2 * Right2;
begin
   for I in result1'Range(1) loop
      for J in result1'Range(2) loop
         Ada.Integer_Text_IO.Put(Ada.Text_IO.Standard_Output, result1(I, J));
      end loop;
      Ada.Text_IO.New_Line;
   end loop;

   Ada.Text_IO.New_Line;

   for I in result2'Range(1) loop
      for J in result2'Range(2) loop
         Ada.Integer_Text_IO.Put(Ada.Text_IO.Standard_Output, result2(I, J));
      end loop;
      Ada.Text_IO.New_Line;
   end loop;
end Kronecker_Product;
Output:
          0          5          0         10
          6          7         12         14
          0         15          0         20
         18         21         24         28

          0          0          0          0          1          1          1          1          0          0          0          0
          0          0          0          0          1          0          0          1          0          0          0          0
          0          0          0          0          1          1          1          1          0          0          0          0
          1          1          1          1          1          1          1          1          1          1          1          1
          1          0          0          1          1          0          0          1          1          0          0          1
          1          1          1          1          1          1          1          1          1          1          1          1
          0          0          0          0          1          1          1          1          0          0          0          0
          0          0          0          0          1          0          0          1          0          0          0          0
          0          0          0          0          1          1          1          1          0          0          0          0

ALGOL 68

BEGIN
    # multiplies in-place the elements of the matrix a by the scaler b #
    OP *:= = ( REF[,]INT a, INT b )REF[,]INT:
    BEGIN
        FOR i FROM 1 LWB a TO 1 UPB a DO
            FOR j FROM 2 LWB a TO 2 UPB a DO
                a[ i, j ] *:= b
            OD
        OD;
        a
    END # *:= # ;
    # returns the Kronecker Product of the two matrices a and b #
    # the result will have lower bounds of 1                    #
    PRIO X = 6;
    OP   X = ( [,]INT a, b )[,]INT:
    BEGIN
        # normalise the matrices to have lower bounds of 1 #
        [,]INT l = a[ AT 1, AT 1 ];
        [,]INT r = b[ AT 1, AT 1 ];
        # construct the result #
        INT r 1 size = 1 UPB r;
        INT r 2 size = 2 UPB r;
        [ 1 : 1 UPB l * 1 UPB r, 1 : 2 UPB l * 2 UPB r ]INT k;
        FOR i FROM 1 LWB l TO 1 UPB l DO
            FOR j FROM 2 LWB l TO 2 UPB l DO
                ( k[ 1 + ( ( i - 1 ) * r 1 size ) : i * r 1 size
                   , 1 + ( ( j - 1 ) * r 2 size ) : j * r 2 size
                   ] := r
                ) *:= l[ i, j ]
            OD
        OD;
        k
    END # X # ;
    # prints matrix a with the specified field width #
    PROC print matrix = ( [,]INT a, INT field width )VOID:
    FOR i FROM 1 LWB a TO 1 UPB a DO
        FOR j FROM 2 LWB a TO 2 UPB a DO
            print( ( " ", whole( a[ i, j ], field width ) ) )
        OD;
        print( ( newline ) )
    OD # print matrix # ;
    # task test cases #
    print matrix( [,]INT( ( 1, 2 )
                        , ( 3, 4 )
                        )
                X [,]INT( ( 0, 5 )
                        , ( 6, 7 )
                        )
                , -2
                );
    print( ( newline ) );
    print matrix( [,]INT( ( 0, 1, 0 )
                        , ( 1, 1, 1 )
                        , ( 0, 1, 0 )
                        )
                X [,]INT( ( 1, 1, 1, 1 )
                        , ( 1, 0, 0, 1 )
                        , ( 1, 1, 1, 1 )
                        )
                , -1
                )
END
Output:
  0  5  0 10
  6  7 12 14
  0 15  0 20
 18 21 24 28

 0 0 0 0 1 1 1 1 0 0 0 0
 0 0 0 0 1 0 0 1 0 0 0 0
 0 0 0 0 1 1 1 1 0 0 0 0
 1 1 1 1 1 1 1 1 1 1 1 1
 1 0 0 1 1 0 0 1 1 0 0 1
 1 1 1 1 1 1 1 1 1 1 1 1
 0 0 0 0 1 1 1 1 0 0 0 0
 0 0 0 0 1 0 0 1 0 0 0 0
 0 0 0 0 1 1 1 1 0 0 0 0

APL

Works with: Dyalog APL
kprod   (,/ ( ([3 4] ∘.×)))
Output:
      a←2 2⍴ 1 2 3 4
      b←2 2⍴ 0 5 6 7
      a b (a kprod b)
┌───┬───┬───────────┐
│1 2│0 5│ 0  5  0 10│
│3 4│6 7│ 6  7 12 14│
│   │   │ 0 15  0 20│
│   │   │18 21 24 28│
└───┴───┴───────────┘
      x ← 3 3⍴ 0 1 0 1 1 1 0 1 0
      y ← 3 4⍴ 1 1 1 1 1 0 0 1 1 1 1 1
      x y (x kprod y)
┌─────┬───────┬───────────────────────┐
│0 1 0│1 1 1 1│0 0 0 0 1 1 1 1 0 0 0 0│
│1 1 1│1 0 0 1│0 0 0 0 1 0 0 1 0 0 0 0│
│0 1 0│1 1 1 1│0 0 0 0 1 1 1 1 0 0 0 0│
│     │       │1 1 1 1 1 1 1 1 1 1 1 1│
│     │       │1 0 0 1 1 0 0 1 1 0 0 1│
│     │       │1 1 1 1 1 1 1 1 1 1 1 1│
│     │       │0 0 0 0 1 1 1 1 0 0 0 0│
│     │       │0 0 0 0 1 0 0 1 0 0 0 0│
│     │       │0 0 0 0 1 1 1 1 0 0 0 0│
└─────┴───────┴───────────────────────┘

AppleScript

------------ KRONECKER PRODUCT OF TWO MATRICES -------------

-- kprod :: [[Num]] -> [[Num]] -> [[Num]]
on kprod(xs, ys)
    script concatTranspose
        on |λ|(m)
            map(my concat, my transpose(m))
        end |λ|
    end script
    
    script
        -- Multiplication by N over a list of lists    
        -- f :: [[Num]] -> Num -> [[Num]]
        on f(mx, n)
            script go
                on product(a, b)
                    a * b
                end product
                
                on |λ|(xs)
                    map(curry(product)'s |λ|(n), xs)
                end |λ|
            end script
            
            map(go, mx)
        end f
        
        on |λ|(zs)
            map(curry(f)'s |λ|(ys), zs)
        end |λ|
    end script
    
    concatMap(concatTranspose, map(result, xs))
end kprod

--------------------------- TEST ---------------------------
on run
    unlines(map(show, ¬
        kprod({{1, 2}, {3, 4}}, ¬
            {{0, 5}, {6, 7}}))) & ¬
        linefeed & linefeed & ¬
        unlines(map(show, ¬
            kprod({{0, 1, 0}, {1, 1, 1}, {0, 1, 0}}, ¬
                {{1, 1, 1, 1}, {1, 0, 0, 1}, {1, 1, 1, 1}})))
end run


-------------------- GENERIC FUNCTIONS ---------------------

-- concat :: [[a]] -> [a] | [String] -> String
on concat(xs)
    if length of xs > 0 and class of (item 1 of xs) is string then
        set acc to ""
    else
        set acc to {}
    end if
    repeat with i from 1 to length of xs
        set acc to acc & item i of xs
    end repeat
    acc
end concat


-- concatMap :: (a -> [b]) -> [a] -> [b]
on concatMap(f, xs)
    concat(map(f, xs))
end concatMap


-- curry :: (Script|Handler) -> Script
on curry(f)
    script
        on |λ|(a)
            script
                on |λ|(b)
                    |λ|(a, b) of mReturn(f)
                end |λ|
            end script
        end |λ|
    end script
end curry


-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
    tell mReturn(f)
        set v to startValue
        set lng to length of xs
        repeat with i from 1 to lng
            set v to |λ|(v, item i of xs, i, xs)
        end repeat
        return v
    end tell
end foldl


-- intercalate :: Text -> [Text] -> Text
on intercalate(strText, lstText)
    set {dlm, my text item delimiters} to {my text item delimiters, strText}
    set strJoined to lstText as text
    set my text item delimiters to dlm
    return strJoined
end intercalate


-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
    tell mReturn(f)
        set lng to length of xs
        set lst to {}
        repeat with i from 1 to lng
            set end of lst to |λ|(item i of xs, i, xs)
        end repeat
        return lst
    end tell
end map


-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
    if class of f is script then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn


-- show :: a -> String
on show(e)
    set c to class of e
    if c = list then
        script serialized
            on |λ|(v)
                show(v)
            end |λ|
        end script
        
        "{" & intercalate(", ", map(serialized, e)) & "}"
    else if c = record then
        script showField
            on |λ|(kv)
                set {k, v} to kv
                k & ":" & show(v)
            end |λ|
        end script
        
        "{" & intercalate(", ", ¬
            map(showField, zip(allKeys(e), allValues(e)))) & "}"
    else if c = date then
        ("date \"" & e as text) & "\""
    else if c = text then
        "\"" & e & "\""
    else
        try
            e as text
        on error
            ("«" & c as text) & "»"
        end try
    end if
end show


-- transpose :: [[a]] -> [[a]]
on transpose(xss)
    script column
        on |λ|(_, iCol)
            script row
                on |λ|(xs)
                    item iCol of xs
                end |λ|
            end script
            
            map(row, xss)
        end |λ|
    end script
    
    map(column, item 1 of xss)
end transpose


-- unlines :: [String] -> String
on unlines(xs)
    intercalate(linefeed, xs)
end unlines
Output:
{0, 5, 0, 10}
{6, 7, 12, 14}
{0, 15, 0, 20}
{18, 21, 24, 28}

{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0}
{0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0}
{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0}
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
{1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1}
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0}
{0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0}
{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0}

Arturo

Translation of: Kotlin
define :matrix [X][
    print: [
        result: ""
        loop this\X 'arr [
            result: result ++ "[" ++ 
                        (join.with:" " map to [:string] arr 'item -> pad item 3) ++ 
                    "]\n"
        ]
        return result
    ]
]

kroneckerProduct: function [a,b][
    M: size a\X, N: size first a\X
    P: size b\X, Q: size first b\X
    result: to :matrix @[new array.of:M*P array.of:N*Q 0]

    loop 0..dec M 'i [
        loop 0..dec N 'j [
            loop 0..dec P 'k [
                loop 0..dec Q 'l [
                    result\X\[k + i * P]\[l + j * Q]: a\X\[i]\[j] * b\X\[k]\[l]
                ]
            ]
        ]
    ]
    return result
] 
 
A1: to :matrix [[[1 2] [3 4]]]
B1: to :matrix [[[0 5] [6 7]]]

print "Matrix A:"
print A1

print "Matrix B:"
print B1

print "Kronecker Product:"
print kroneckerProduct A1 B1

A2: to :matrix [[[0 1 0] [1 1 1] [0 1 0]]]
B2: to :matrix [[[1 1 1 1] [1 0 0 1] [1 1 1 1]]]

print "Matrix A:"
print A2

print "Matrix B:"
print B2

print "Kronecker Product:"
print kroneckerProduct A2 B2
Output:
Matrix A:
[  1   2]
[  3   4]

Matrix B:
[  0   5]
[  6   7]

Kronecker Product:
[  0   5   0  10]
[  6   7  12  14]
[  0  15   0  20]
[ 18  21  24  28]

Matrix A:
[  0   1   0]
[  1   1   1]
[  0   1   0]

Matrix B:
[  1   1   1   1]
[  1   0   0   1]
[  1   1   1   1]

Kronecker Product:
[  0   0   0   0   1   1   1   1   0   0   0   0]
[  0   0   0   0   1   0   0   1   0   0   0   0]
[  0   0   0   0   1   1   1   1   0   0   0   0]
[  1   1   1   1   1   1   1   1   1   1   1   1]
[  1   0   0   1   1   0   0   1   1   0   0   1]
[  1   1   1   1   1   1   1   1   1   1   1   1]
[  0   0   0   0   1   1   1   1   0   0   0   0]
[  0   0   0   0   1   0   0   1   0   0   0   0]
[  0   0   0   0   1   1   1   1   0   0   0   0]

AutoHotkey

KroneckerProduct(a, b){
    prod := [], r:= 1, c := 1
    for i, aa in a
        for j, bb in b
        {
            for k, x in aa
                for l, y in bb
                    prod[R , C++] := x * y
            r++, c:= 1
        }
    return prod
}
Examples:
a := [[1, 2], [3, 4]]
b := [[0, 5], [6, 7]]
P := KroneckerProduct(a, b)

a :=[[0,1,0], [1,1,1], [0,1,0]]
b := [[1,1,1,1], [1,0,0,1], [1,1,1,1]]
Q := KroneckerProduct(a, b)

; show results
for row, obj in P
{
    for col, v in obj
        result .= v "`t"
    result .= "`n"
}
result .= "`n"
for row, obj in Q
{
    for col, v in obj
        result .= v "`t"
    result .= "`n"
}
MsgBox % result
return
Output:
0	5	0	10	
6	7	12	14	
0	15	0	20	
18	21	24	28	

0	0	0	0	1	1	1	1	0	0	0	0	
0	0	0	0	1	0	0	1	0	0	0	0	
0	0	0	0	1	1	1	1	0	0	0	0	
1	1	1	1	1	1	1	1	1	1	1	1	
1	0	0	1	1	0	0	1	1	0	0	1	
1	1	1	1	1	1	1	1	1	1	1	1	
0	0	0	0	1	1	1	1	0	0	0	0	
0	0	0	0	1	0	0	1	0	0	0	0	
0	0	0	0	1	1	1	1	0	0	0	0	

AWK

# syntax: GAWK -f KRONECKER_PRODUCT.AWK
BEGIN {
    A[++a] = "1 2" ; B[++b] = "0 5"
    A[++a] = "3 4" ; B[++b] = "6 7"
    main("sample 1",1234)
    A[++a] = "0 1 0" ; B[++b] = "1 1 1 1"
    A[++a] = "1 1 1" ; B[++b] = "1 0 0 1"
    A[++a] = "0 1 0" ; B[++b] = "1 1 1 1"
    main("sample 2",3)
    exit(0)
}
function main(desc,option) {
#
# option: allows complete flexibility of output; they may be combined
#   1  show A and B matrix
#   2  show A x B
#   3  show product
#   4  show Arow,Acol x Brow,Bcol
#
    printf("%s\n\n",desc)
    if (option ~ /[1234]/) {
      a_rows = show_array(A,"A",option)
      b_rows = show_array(B,"B",option)
      if (option ~ /2/) { prn("A x B",2) }
      if (option ~ /3/) { prn("Product",3) }
      if (option ~ /4/) { prn("Arow,Acol x Brow,Bcol",4) }
    }
    else {
      print("nothing to print")
    }
    print("")
    a = b = 0 # reset
    delete A
    delete B
}
function prn(desc,option,  a_cols,b_cols,w,x,y,z,AA,BB) {
    printf("%s:\n",desc)
    for (w=1; w<=a_rows; w++) {
      a_cols = split(A[w],AA," ")
      for (x=1; x<=b_rows; x++) {
        b_cols = split(B[x],BB," ")
        printf("[ ")
        for (y=1; y<=a_cols; y++) {
          for (z=1; z<=b_cols; z++) {
            if (option ~ /2/) { printf("%sx%s ",AA[y],BB[z]) }
            if (option ~ /3/) { printf("%2s ",AA[y] * BB[z]) }
            if (option ~ /4/) { printf("%s,%sx%s,%s ",w,y,x,z) }
          }
        }
        printf("]\n")
      }
    }
}
function show_array(arr,desc,option,  i,n) {
    for (i in arr) {
      n++
    }
    if (option ~ /1/) {
      printf("Matrix %s:\n",desc)
      for (i=1; i<=n; i++) {
        printf("[ %s ]\n",arr[i])
      }
    }
    return(n)
}
Output:
sample 1

Matrix A:
[ 1 2 ]
[ 3 4 ]
Matrix B:
[ 0 5 ]
[ 6 7 ]
A x B:
[ 1x0 1x5 2x0 2x5 ]
[ 1x6 1x7 2x6 2x7 ]
[ 3x0 3x5 4x0 4x5 ]
[ 3x6 3x7 4x6 4x7 ]
Product:
[  0  5  0 10 ]
[  6  7 12 14 ]
[  0 15  0 20 ]
[ 18 21 24 28 ]
Arow,Acol x Brow,Bcol:
[ 1,1x1,1 1,1x1,2 1,2x1,1 1,2x1,2 ]
[ 1,1x2,1 1,1x2,2 1,2x2,1 1,2x2,2 ]
[ 2,1x1,1 2,1x1,2 2,2x1,1 2,2x1,2 ]
[ 2,1x2,1 2,1x2,2 2,2x2,1 2,2x2,2 ]

sample 2

Product:
[  0  0  0  0  1  1  1  1  0  0  0  0 ]
[  0  0  0  0  1  0  0  1  0  0  0  0 ]
[  0  0  0  0  1  1  1  1  0  0  0  0 ]
[  1  1  1  1  1  1  1  1  1  1  1  1 ]
[  1  0  0  1  1  0  0  1  1  0  0  1 ]
[  1  1  1  1  1  1  1  1  1  1  1  1 ]
[  0  0  0  0  1  1  1  1  0  0  0  0 ]
[  0  0  0  0  1  0  0  1  0  0  0  0 ]
[  0  0  0  0  1  1  1  1  0  0  0  0 ]

BQN

KProd  ·<2 ×

or

KProd   ×<

Example:

l  >12, 34
r  >05, 67

l KProd r
┌─             
╵  0  5  0 10  
   6  7 12 14  
   0 15  0 20  
  18 21 24 28  
              ┘

(online REPL)

C

Entering and printing matrices on the console is tedious even for matrices with 4 or more rows and columns. This implementation reads and writes the matrices from and to files. Matrices are taken as double type in order to cover as many use cases as possible.

#include<stdlib.h>
#include<stdio.h>

int main(){
	
	char input[100],output[100];
	int i,j,k,l,rowA,colA,rowB,colB,rowC,colC,startRow,startCol;
	double **matrixA,**matrixB,**matrixC;
	
	printf("Enter full path of input file : ");
	fscanf(stdin,"%s",input);
	
	printf("Enter full path of output file : ");
	fscanf(stdin,"%s",output);
	
	FILE* inputFile = fopen(input,"r");
	
	fscanf(inputFile,"%d%d",&rowA,&colA);
	
	matrixA = (double**)malloc(rowA * sizeof(double*));
	
	for(i=0;i<rowA;i++){
		matrixA[i] = (double*)malloc(colA*sizeof(double));
		for(j=0;j<colA;j++){
			fscanf(inputFile,"%lf",&matrixA[i][j]);
		}
	}
	
	fscanf(inputFile,"%d%d",&rowB,&colB);
	
	matrixB = (double**)malloc(rowB * sizeof(double*));
	
	for(i=0;i<rowB;i++){
		matrixB[i] = (double*)malloc(colB*sizeof(double));
		for(j=0;j<colB;j++){
			fscanf(inputFile,"%lf",&matrixB[i][j]);
		}
	}
	
	fclose(inputFile);
	
	rowC = rowA*rowB;
	colC = colA*colB;
	
	matrixC = (double**)malloc(rowC*sizeof(double*));
	
	for(i=0;i<rowA*rowB;i++){
		matrixC[i] = (double*)malloc(colA*colB*sizeof(double));
	}
	
	for(i=0;i<rowA;i++){
		for(j=0;j<colA;j++){
			startRow = i*rowB;
			startCol = j*colB;
			for(k=0;k<rowB;k++){
				for(l=0;l<colB;l++){
					matrixC[startRow+k][startCol+l] = matrixA[i][j]*matrixB[k][l];
				}
			}
		}
	}

	FILE* outputFile = fopen(output,"w");
	
	for(i=0;i<rowC;i++){
		for(j=0;j<colC;j++){
			fprintf(outputFile,"%lf\t",matrixC[i][j]);
		}
		fprintf(outputFile,"\n");
	}
	
	fclose(outputFile);
	
	printf("\n\n\nKronecker product of the two matrices written to %s.",output);
}

Input file :

3 3
0 1 0
1 1 1
0 1 0
3 4
1 1 1 1
1 0 0 1
1 1 1 1

Console interaction :

Enter full path of input file : input3.txt
Enter full path of output file : output3.txt



Kronecker product of the two matrices written to output3.txt.

Output file :

0.000000	0.000000	0.000000	0.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	
0.000000	0.000000	0.000000	0.000000	1.000000	0.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	
0.000000	0.000000	0.000000	0.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	
1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	
1.000000	0.000000	0.000000	1.000000	1.000000	0.000000	0.000000	1.000000	1.000000	0.000000	0.000000	1.000000	
1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	
0.000000	0.000000	0.000000	0.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	
0.000000	0.000000	0.000000	0.000000	1.000000	0.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	
0.000000	0.000000	0.000000	0.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	

C#

using System;
using System.Collections;
using System.Collections.Generic;
using static System.Linq.Enumerable;

public static class KroneckerProduct
{
    public static void Main() {
        int[,] left = { {1, 2}, {3, 4} };
        int[,] right = { {0, 5}, {6, 7} };
        Print(Multiply(left, right));

        left = new [,] { {0, 1, 0}, {1, 1, 1}, {0, 1, 0} };
        right = new [,] { {1, 1, 1, 1}, {1, 0, 0, 1}, {1, 1, 1, 1} };
        Print(Multiply(left, right));
    }

    static int[,] Multiply(int[,] left, int[,] right) {
        (int lRows, int lColumns) = (left.GetLength(0), left.GetLength(1));
        (int rRows, int rColumns) = (right.GetLength(0), right.GetLength(1));
        int[,] result = new int[lRows * rRows, lColumns * rColumns];

        foreach (var (r, c) in from r in Range(0, lRows) from c in Range(0, lColumns) select (r, c)) {
            Copy(r * rRows, c * rColumns, left[r, c]);
        }
        return result;
        
        void Copy(int startRow, int startColumn, int multiplier) {
            foreach (var (r, c) in from r in Range(0, rRows) from c in Range(0, rColumns) select (r, c)) {
                result[startRow + r, startColumn + c] = right[r, c] * multiplier;
            }
        }
    }

    static void Print(int[,] matrix) {
        (int rows, int columns) = (matrix.GetLength(0), matrix.GetLength(1));
        int width = matrix.Cast<int>().Select(LengthOf).Max();
        for (int row = 0; row < rows; row++) {
            Console.WriteLine("| " + string.Join(" ", Range(0, columns).Select(column => (matrix[row, column] + "").PadLeft(width, ' '))) + " |");
        }
        Console.WriteLine();
    }

    private static int LengthOf(int i) {
        if (i < 0) return LengthOf(-i) + 1;
        int length = 0;
        while (i > 0) {
            length++;
            i /= 10;
        }
        return length;
    }

}
Output:
|  0  5  0 10 |
|  6  7 12 14 |
|  0 15  0 20 |
| 18 21 24 28 |

| 0 0 0 0 1 1 1 1 0 0 0 0 |
| 0 0 0 0 1 0 0 1 0 0 0 0 |
| 0 0 0 0 1 1 1 1 0 0 0 0 |
| 1 1 1 1 1 1 1 1 1 1 1 1 |
| 1 0 0 1 1 0 0 1 1 0 0 1 |
| 1 1 1 1 1 1 1 1 1 1 1 1 |
| 0 0 0 0 1 1 1 1 0 0 0 0 |
| 0 0 0 0 1 0 0 1 0 0 0 0 |
| 0 0 0 0 1 1 1 1 0 0 0 0 |

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_;
};

// See https://en.wikipedia.org/wiki/Kronecker_product
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;
}
Output:
Test case 1:
┌            ┐
│ 0  5  0 10 │
│ 6  7 12 14 │
│ 0 15  0 20 │
│18 21 24 28 │
└            ┘
Test case 2:
┌                                    ┐
│ 0  0  0  0  1  1  1  1  0  0  0  0 │
│ 0  0  0  0  1  0  0  1  0  0  0  0 │
│ 0  0  0  0  1  1  1  1  0  0  0  0 │
│ 1  1  1  1  1  1  1  1  1  1  1  1 │
│ 1  0  0  1  1  0  0  1  1  0  0  1 │
│ 1  1  1  1  1  1  1  1  1  1  1  1 │
│ 0  0  0  0  1  1  1  1  0  0  0  0 │
│ 0  0  0  0  1  0  0  1  0  0  0  0 │
│ 0  0  0  0  1  1  1  1  0  0  0  0 │
└                                    ┘

D

Translation of: Go
import std.stdio, std.outbuffer;

alias Matrix = uint[][];

string toString(Matrix m) {
    auto ob = new OutBuffer();
    foreach(row; m) {
        //The format specifier inside the %(...%) is 
        //automatically applied to each element of a range
        //Thus prints each line flanked by |
        ob.writefln("|%(%2d %)|", row);
    }
    return ob.toString;
}

Matrix kronecker(Matrix m1, Matrix m2) {
    Matrix p = new uint[][m1.length*m2.length];
    foreach(r1i, r1; m1) {
        foreach(r2i, r2; m2) {
            auto rp = new uint[r1.length*r2.length];
            foreach(c1i, e1; r1) {
                    foreach(c2i, e2; r2) {
                        rp[c1i*r2.length+c2i] = e1*e2;
                    }
            }
            p[r1i*m2.length+r2i] = rp;
        }
    }
    return p;
}

void sample(Matrix m1, Matrix m2) {
    auto res = kronecker(m1, m2);
    writefln("Matrix A:\n%s\nMatrix B:\n%s\nA (X) B:\n%s", m1.toString, m2.toString, res.toString);
}

void main() {
    Matrix A = [[1,2],[3,4]];
    Matrix B = [[0,5],[6,7]];
    
    sample(A,B);
    
    Matrix C = 
    [[0,1,0],
     [1,1,1],
     [0,1,0]];
    Matrix D = 
    [[1,1,1,1],
     [1,0,0,1],
     [1,1,1,1]];
    
    sample(C,D);
}

Output:

Matrix A:                                     
| 1  2|                                       
| 3  4|                                       
                                              
Matrix B:                                     
| 0  5|                                       
| 6  7|                                       
                                              
A (X) B:                                      
| 0  5  0 10|                                 
| 6  7 12 14|                                 
| 0 15  0 20|                                 
|18 21 24 28|                                 
                                              
Matrix A:                                     
| 0  1  0|                                    
| 1  1  1|                                    
| 0  1  0|                                    
                                              
Matrix B:                                     
| 1  1  1  1|                                 
| 1  0  0  1|                                 
| 1  1  1  1|                                 
                                              
A (X) B:                                      
| 0  0  0  0  1  1  1  1  0  0  0  0|         
| 0  0  0  0  1  0  0  1  0  0  0  0|         
| 0  0  0  0  1  1  1  1  0  0  0  0|         
| 1  1  1  1  1  1  1  1  1  1  1  1|         
| 1  0  0  1  1  0  0  1  1  0  0  1|         
| 1  1  1  1  1  1  1  1  1  1  1  1|         
| 0  0  0  0  1  1  1  1  0  0  0  0|         
| 0  0  0  0  1  0  0  1  0  0  0  0|         
| 0  0  0  0  1  1  1  1  0  0  0  0|         

F#

// Kronecker product. Nigel Galloway: August 31st., 2023
open MathNet.Numerics
open MathNet.Numerics.LinearAlgebra
let m1,m2,m3,m4=matrix [[1.0;2.0];[3.0;4.0]],matrix [[0.0;5.0];[6.0;7.0]],matrix [[0.0;1.0;0.0];[1.0;1.0;1.0];[0.0;1.0;0.0]],matrix [[1.0;1.0;1.0;1.0];[1.0;0.0;0.0;1.0];[1.0;1.0;1.0;1.0]]
printfn $"{(m1.KroneckerProduct m2).ToMatrixString()}"
printfn $"{(m3.KroneckerProduct m4).ToMatrixString()}"
Output:
 0   5   0  10
 6   7  12  14
 0  15   0  20
18  21  24  28

0  0  0  0  1  1  1  1  0  0  0  0
0  0  0  0  1  0  0  1  0  0  0  0
0  0  0  0  1  1  1  1  0  0  0  0
1  1  1  1  1  1  1  1  1  1  1  1
1  0  0  1  1  0  0  1  1  0  0  1
1  1  1  1  1  1  1  1  1  1  1  1
0  0  0  0  1  1  1  1  0  0  0  0
0  0  0  0  1  0  0  1  0  0  0  0
0  0  0  0  1  1  1  1  0  0  0  0

Factor

Works with: Factor version 0.99 2020-01-23
USING: kernel math.matrices.extras prettyprint ;

{ { 1 2 } { 3 4 } }
{ { 0 5 } { 6 7 } }
{ { 0 1 0 } { 1 1 1 } { 0 1 0 } }
{ { 1 1 1 1 } { 1 0 0 1 } { 1 1 1 1 } }
[ kronecker-product . ] 2bi@
Output:
{ { 0 5 0 10 } { 6 7 12 14 } { 0 15 0 20 } { 18 21 24 28 } }
{
    { 0 0 0 0 1 1 1 1 0 0 0 0 }
    { 0 0 0 0 1 0 0 1 0 0 0 0 }
    { 0 0 0 0 1 1 1 1 0 0 0 0 }
    { 1 1 1 1 1 1 1 1 1 1 1 1 }
    { 1 0 0 1 1 0 0 1 1 0 0 1 }
    { 1 1 1 1 1 1 1 1 1 1 1 1 }
    { 0 0 0 0 1 1 1 1 0 0 0 0 }
    { 0 0 0 0 1 0 0 1 0 0 0 0 }
    { 0 0 0 0 1 1 1 1 0 0 0 0 }
}

Fortran

The plan is to pass the two arrays to a subroutine, which will return their Kronecker product as a third parameter. This relies on the expanded array-handling facilities introduced with F90, especially the ability of a subroutine to allocate an array of a size of its choosing, this array being a parameter to the subroutine. Some compilers offering the "allocate" statement do not handle this! Further features of the MODULE protocol of F90 allow arrays passed to a subroutine to have their sizes ascertained in the subroutine (via function UBOUND, etc.) rather than this information being supplied via the programmer coding additional parameters. This is not all to the good: multi-dimensional arrays must therefore be the actual size of their usage rather than say A(100,100) but only using the first fifty elements (in one place) and the first thirty in another. Thus, for such usage the array must be re-allocated the correct size each time, and, the speed of access to such arrays is reduced - see Sequence_of_primorial_primes#Fixed-size_data_aggregates for an example. Similarly, suppose a portion of a large array is to be passed as a parameter, as is enabled by F90 syntax such as A(3:7,9:12) to select a 5x4 block: those elements will not be in contiguous memory locations, as is expected by the subroutine, so they will be copied into a temporary storage area that will become the parameter and their values will be copied back on return. Copy-in copy-out, instead of by reference. With large arrays, this imposes a large overhead. A further detail of the MODULE protocol when passing arrays is that if the parameter's declaration does not specify the lower bound, it will be treated as if it were one even if the actual array is declared otherwise - see Array_length#Fortran for example.

In older-style Fortran, the arrays would be of some "surely-big-enough" size, fixed at compile time, and there would be additional parameters describing the bounds in use for each invocation. Since no array-assignment statements were available, there would be additional DO-loops to copy each block of values. In all versions of Fortran, the ordering of array elements in storage is "column-major" so that the DATA statement appears to initialise the arrays with their transpose - see Matrix_transposition#Fortran for example. As a result, the default output order for an array, if written as just WRITE (6,*) A will be that of the transposed order, just as with the default order of the DATA statement's data. To show the desired order of A(row,column), the array must be written with explicit specification of the order of elements, as is done by subroutine SHOW: columns across the page, rows running down the page.
      MODULE ARRAYMUSH	!A rather small collection.
       CONTAINS		!For the specific problem only.
        SUBROUTINE KPRODUCT(A,B,AB)	!AB = Kronecker product of A and B, both two-dimensional arrays.
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(:,:)		!Two-dimensional arrays, lower bound one.
         INTEGER, ALLOCATABLE:: AB(:,:)	!To be created to fit.
         INTEGER R,RA,RB,C,CA,CB,I	!Assistants.
          RA = UBOUND(A,DIM = 1)	!Ascertain the upper bounds of the incoming arrays.
          CA = UBOUND(A,DIM = 2)	!Their lower bounds will be deemed one,
          RB = UBOUND(B,DIM = 1)	!And the upper bound as reported will correspond.
          CB = UBOUND(B,DIM = 2)	!UBOUND(A) would give an array of two values, RA and CA, more for higher dimensionality.
          WRITE (6,1) "A",RA,CA,"B",RB,CB,"A.k.B",RA*RB,CA*CB	!Announce.
    1     FORMAT (3(A," is ",I0,"x",I0,1X))	!Three sets of sizes.
          IF (ALLOCATED(AB)) DEALLOCATE(AB)	!Discard any lingering storage.
          ALLOCATE (AB(RA*RB,CA*CB))		!Obtain the exact desired size.
          R = 0		!Syncopation: start the row offset.
          DO I = 1,RA	!Step down the rows of A.
            C = 0		!For each row, start the column offset.
            DO J = 1,CA		!Step along the columns of A.
              AB(R + 1:R + RB,C + 1:C + CB) = A(I,J)*B	!Place a block of B values.
              C = C + CB		!Advance a block of columns.
            END DO		!On to the next column of A.
            R = R + RB		!Advance a block of rows.
          END DO	!On to the next row of A.
        END SUBROUTINE KPRODUCT	!No tests for bad parameters, or lack of storage...

        SUBROUTINE SHOW(F,A)	!Write array A in row,column order.
         INTEGER F	!Output file unit number.
         INTEGER A(:,:)	!The 2-D array, lower bound one.
         INTEGER R	!The row stepper.
          DO R = 1,UBOUND(A,DIM = 1)	!Each row gets its own line.
            WRITE (F,1) A(R,:)		!Write all the columns of that row.
    1       FORMAT (666I3)		!This suffices for the example.
          END DO			!On to the next row.
        END SUBROUTINE SHOW	!WRITE (F,*) A or similar would show A as if transposed.
      END MODULE ARRAYMUSH	!That was simple enough.

      PROGRAM POKE
      USE ARRAYMUSH
      INTEGER A(2,2),B(2,2)		!First test: square arrays.
      INTEGER, ALLOCATABLE:: AB(:,:)	!To be created for each result.
      INTEGER C(3,3),D(3,4)		!Second test: some rectilinearity.
      DATA A/1,3, 2,4/,B/0,6, 5,7/	!Furrytran uses "column-major" order for successive storage elements.
      DATA C/0,1,0, 1,1,1, 0,1,0/	!So, the first three values go down the rows of the first column.
      DATA D/1,1,1, 1,0,1, 1,0,1, 1,1,1/!And then follow the values for the next column, etc.

      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

Output:

 First test...
A is 2x2 B is 2x2 A.k.B is 4x4
  0  5  0 10
  6  7 12 14
  0 15  0 20
 18 21 24 28

 Second test...
A is 3x3 B is 3x4 A.k.B is 9x12
  0  0  0  0  1  1  1  1  0  0  0  0
  0  0  0  0  1  0  0  1  0  0  0  0
  0  0  0  0  1  1  1  1  0  0  0  0
  1  1  1  1  1  1  1  1  1  1  1  1
  1  0  0  1  1  0  0  1  1  0  0  1
  1  1  1  1  1  1  1  1  1  1  1  1
  0  0  0  0  1  1  1  1  0  0  0  0
  0  0  0  0  1  0  0  1  0  0  0  0
  0  0  0  0  1  1  1  1  0  0  0  0
An alternative approach is not to produce the array AB at all, just calculate its elements as needed. Using the array dimension variables as defined above,
AB(i,j) = A((i - 1)/RB + 1,(j - 1)/CB + 1)*B(MOD(i - 1,RB) + 1,MOD(j - 1,CB) + 1))
with the subtracting and adding of one necessary because array indexing starts with row one and column one. With F90, they could start at zero (or any desired value) but if so, you will have to be very careful with counting. For instance, DO I = 1,RA must become DO I = 0,RA - 1 and so forth.

FreeBASIC

' version 06-04-2017
' compile with: fbc -s console

Sub kronecker_product(a() As Long, b() As Long, frmt As String = "#")

    Dim As Long i, j, k, l
    Dim As Long la1 = LBound(a, 1) : Dim As Long ua1 = UBound(a, 1)
    Dim As Long la2 = LBound(a, 2) : Dim As Long ua2 = UBound(a, 2)
    Dim As Long lb1 = LBound(b, 1) : Dim As Long ub1 = UBound(b, 1)
    Dim As Long lb2 = LBound(b, 2) : Dim As Long ub2 = UBound(b, 2)

    For i = la1 To ua1
        For k = lb1 To ub1
            Print "[";
            For j = la2 To ua2
                For l = lb2 To ub2
                    Print Using frmt; a(i, j) * b(k, l);
                    If j = ua1 And l = ub2 Then
                        Print "]"
                    Else
                        Print " ";
                    End If
                Next
            Next
        Next
    Next

End Sub

' ------=< MAIN >=-----

Dim As Long a(1 To 2, 1 To 2) = {{1, 2}, _
                                 {3, 4}}
Dim As Long b(1 To 2, 1 To 2) = {{0, 5}, _
                                 {6, 7}}
kronecker_product(a(), b(), "##")

Print
Dim As Long x(1 To 3, 1 To 3) = {{0, 1, 0}, _
                                 {1, 1, 1}, _
                                 {0, 1, 0}}
Dim As Long y(1 To 3, 1 To 4) = {{1, 1, 1, 1}, _
                                 {1, 0, 0, 1}, _
                                 {1, 1, 1, 1}}
kronecker_product(x(), y())

' empty keyboard buffer
While InKey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End
Output:
[ 0  5  0 10]
[ 6  7 12 14]
[ 0 15  0 20]
[18 21 24 28]

[0 0 0 0 1 1 1 1 0 0 0 0]
[0 0 0 0 1 0 0 1 0 0 0 0]
[0 0 0 0 1 1 1 1 0 0 0 0]
[1 1 1 1 1 1 1 1 1 1 1 1]
[1 0 0 1 1 0 0 1 1 0 0 1]
[1 1 1 1 1 1 1 1 1 1 1 1]
[0 0 0 0 1 1 1 1 0 0 0 0]
[0 0 0 0 1 0 0 1 0 0 0 0]
[0 0 0 0 1 1 1 1 0 0 0 0]

Frink

The Frink library Matrix.frink contains an implementation of Kronecker product. However, the following example demonstrates calculating the Kronecker product and typesetting the equations using multidimensional arrays and no external libraries.

a = [[1,2],[3,4]]
b = [[0,5],[6,7]]
println[formatProd[a,b]]

c = [[0,1,0],[1,1,1],[0,1,0]]
d = [[1,1,1,1],[1,0,0,1],[1,1,1,1]]
println[formatProd[c,d]]

formatProd[a,b] := formatTable[[[formatMatrix[a], "\u2297", formatMatrix[b], "=", formatMatrix[KroneckerProduct[a,b]]]]]

KroneckerProduct[a, b] :=
{
   [m,n] = a.dimensions[]
   [p,q] = b.dimensions[]
   rows = m p
   cols = n q
   n = new array[[rows, cols], 0]
   for i=0 to rows-1
      for j=0 to cols-1
         n@i@j = a@(i div p)@(j div q) * b@(i mod p)@(j mod q)
      
   return n      
}
Output:
                  ┌              ┐
                  │ 0   5   0  10│
┌    ┐   ┌    ┐   │              │
│1  2│   │0  5│   │ 6   7  12  14│
│    │ ⊗ │    │ = │              │
│3  4│   │6  7│   │ 0  15   0  20│
└    ┘   └    ┘   │              │
                  │18  21  24  28│
                  └              ┘
                           ┌                                  ┐
                           │0  0  0  0  1  1  1  1  0  0  0  0│
                           │                                  │
                           │0  0  0  0  1  0  0  1  0  0  0  0│
                           │                                  │
                           │0  0  0  0  1  1  1  1  0  0  0  0│
┌       ┐   ┌          ┐   │                                  │
│0  1  0│   │1  1  1  1│   │1  1  1  1  1  1  1  1  1  1  1  1│
│       │   │          │   │                                  │
│1  1  1│ ⊗ │1  0  0  1│ = │1  0  0  1  1  0  0  1  1  0  0  1│
│       │   │          │   │                                  │
│0  1  0│   │1  1  1  1│   │1  1  1  1  1  1  1  1  1  1  1  1│
└       ┘   └          ┘   │                                  │
                           │0  0  0  0  1  1  1  1  0  0  0  0│
                           │                                  │
                           │0  0  0  0  1  0  0  1  0  0  0  0│
                           │                                  │
                           │0  0  0  0  1  1  1  1  0  0  0  0│
                           └                                  ┘

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website.

In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.

Solution

Kronecker product is an intrinsec operation in Fōrmulæ

Test case 1

Test case 2

A function to calculate the Kronecker product can also be written:

Go

Implementation

package main

import (
    "fmt"
    "strings"
)

type uintMatrix [][]uint

func (m uintMatrix) String() string {
    var max uint
    for _, r := range m {
        for _, e := range r {
            if e > max {
                max = e
            }
        }
    }
    w := len(fmt.Sprint(max))
    b := &strings.Builder{}
    for _, r := range m {
        fmt.Fprintf(b, "|%*d", w, r[0])
        for _, e := range r[1:] {
            fmt.Fprintf(b, " %*d", w, e)
        }
        fmt.Fprintln(b, "|")
    }
    return b.String()
}

func kronecker(m1, m2 uintMatrix) uintMatrix {
    p := make(uintMatrix, len(m1)*len(m2))
    for r1i, r1 := range m1 {
        for r2i, r2 := range m2 {
            rp := make([]uint, len(r1)*len(r2))
            for c1i, e1 := range r1 {
                for c2i, e2 := range r2 {
                    rp[c1i*len(r2)+c2i] = e1 * e2
                }
            }
            p[r1i*len(m2)+r2i] = rp
        }
    }
    return p
}

func sample(m1, m2 uintMatrix) {
    fmt.Println("m1:")
    fmt.Print(m1)
    fmt.Println("m2:")
    fmt.Print(m2)
    fmt.Println("m1 ⊗ m2:")
    fmt.Print(kronecker(m1, m2))
}

func main() {
    sample(uintMatrix{
        {1, 2},
        {3, 4},
    }, uintMatrix{
        {0, 5},
        {6, 7},
    })
    sample(uintMatrix{
        {0, 1, 0},
        {1, 1, 1},
        {0, 1, 0},
    }, uintMatrix{
        {1, 1, 1, 1},
        {1, 0, 0, 1},
        {1, 1, 1, 1},
    })
}
Output:
m1:
|1 2|
|3 4|
m2:
|0 5|
|6 7|
m1 ⊗ m2:
| 0  5  0 10|
| 6  7 12 14|
| 0 15  0 20|
|18 21 24 28|
m1:
|0 1 0|
|1 1 1|
|0 1 0|
m2:
|1 1 1 1|
|1 0 0 1|
|1 1 1 1|
m1 ⊗ m2:
|0 0 0 0 1 1 1 1 0 0 0 0|
|0 0 0 0 1 0 0 1 0 0 0 0|
|0 0 0 0 1 1 1 1 0 0 0 0|
|1 1 1 1 1 1 1 1 1 1 1 1|
|1 0 0 1 1 0 0 1 1 0 0 1|
|1 1 1 1 1 1 1 1 1 1 1 1|
|0 0 0 0 1 1 1 1 0 0 0 0|
|0 0 0 0 1 0 0 1 0 0 0 0|
|0 0 0 0 1 1 1 1 0 0 0 0|

Library go.matrix

package main

import (
    "fmt"

    "github.com/skelterjohn/go.matrix"
)

func main() {
    fmt.Println(matrix.Kronecker(
        matrix.MakeDenseMatrixStacked([][]float64{
            {1, 2},
            {3, 4},
        }),
        matrix.MakeDenseMatrixStacked([][]float64{
            {0, 5},
            {6, 7},
        })))
    fmt.Println()
    fmt.Println(matrix.Kronecker(
        matrix.MakeDenseMatrixStacked([][]float64{
            {0, 1, 0},
            {1, 1, 1},
            {0, 1, 0},
        }),
        matrix.MakeDenseMatrixStacked([][]float64{
            {1, 1, 1, 1},
            {1, 0, 0, 1},
            {1, 1, 1, 1},
        })))
}
Output:
{ 0,  5,  0, 10,
  6,  7, 12, 14,
  0, 15,  0, 20,
 18, 21, 24, 28}

{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0,
 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0,
 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0}

Library gonum/matrix

Gonum/matrix doesn't have the Kronecker product, but here's an implementation using available methods.

package main

import (
    "fmt"

    "github.com/gonum/matrix/mat64"
)

func kronecker(a, b mat64.Matrix) *mat64.Dense {
    ar, ac := a.Dims()
    br, bc := b.Dims()
    k := mat64.NewDense(ar*br, ac*bc, nil)
    for i := 0; i < ar; i++ {
        for j := 0; j < ac; j++ {
            s := k.Slice(i*br, (i+1)*br, j*bc, (j+1)*bc).(*mat64.Dense)
            s.Scale(a.At(i, j), b)
        }
    }
    return k
}

func main() {
    fmt.Println(mat64.Formatted(kronecker(
        mat64.NewDense(2, 2, []float64{
            1, 2,
            3, 4,
        }),
        mat64.NewDense(2, 2, []float64{
            0, 5,
            6, 7,
        }))))
    fmt.Println()
    fmt.Println(mat64.Formatted(kronecker(
        mat64.NewDense(3, 3, []float64{
            0, 1, 0,
            1, 1, 1,
            0, 1, 0,
        }),
        mat64.NewDense(3, 4, []float64{
            1, 1, 1, 1,
            1, 0, 0, 1,
            1, 1, 1, 1,
        }))))
}
Output:
⎡ 0   5   0  10⎤
⎢ 6   7  12  14⎥
⎢ 0  15   0  20⎥
⎣18  21  24  28⎦

⎡0  0  0  0  1  1  1  1  0  0  0  0⎤
⎢0  0  0  0  1  0  0  1  0  0  0  0⎥
⎢0  0  0  0  1  1  1  1  0  0  0  0⎥
⎢1  1  1  1  1  1  1  1  1  1  1  1⎥
⎢1  0  0  1  1  0  0  1  1  0  0  1⎥
⎢1  1  1  1  1  1  1  1  1  1  1  1⎥
⎢0  0  0  0  1  1  1  1  0  0  0  0⎥
⎢0  0  0  0  1  0  0  1  0  0  0  0⎥
⎣0  0  0  0  1  1  1  1  0  0  0  0⎦

Haskell

import Data.List (transpose)

-------------------- KRONECKER PRODUCT -------------------

kroneckerProduct :: Num a => [[a]] -> [[a]] -> [[a]]
kroneckerProduct xs ys =
  fmap (`f` ys) <$> xs
    >>= fmap concat . transpose
  where
    f = fmap . fmap . (*)


--------------------------- TEST -------------------------
main :: IO ()
main =
  mapM_
    print
    ( kroneckerProduct
        [[1, 2], [3, 4]]
        [[0, 5], [6, 7]]
    )
    >> putStrLn []
    >> mapM_
      print
      ( kroneckerProduct
          [[0, 1, 0], [1, 1, 1], [0, 1, 0]]
          [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]]
      )
Output:
[0,5,0,10]
[6,7,12,14]
[0,15,0,20]
[18,21,24,28]

[0,0,0,0,1,1,1,1,0,0,0,0]
[0,0,0,0,1,0,0,1,0,0,0,0]
[0,0,0,0,1,1,1,1,0,0,0,0]
[1,1,1,1,1,1,1,1,1,1,1,1]
[1,0,0,1,1,0,0,1,1,0,0,1]
[1,1,1,1,1,1,1,1,1,1,1,1]
[0,0,0,0,1,1,1,1,0,0,0,0]
[0,0,0,0,1,0,0,1,0,0,0,0]
[0,0,0,0,1,1,1,1,0,0,0,0]

J

We can build Kronecker product from tensor outer product by transposing some dimensions of the result and then merging some dimensions.

Explicit implementation:

KP=: dyad def ',/"2 ,/ 1 3 |: x */ y'

Tacit:

KP=: 1 3 ,/"2@(,/)@|: */

these definitions are functionally equivalent.

Task examples:

   M=: 1+i.2 2
   N=: (+4**)i.2 2
   P=: -.0 2 6 8 e.~i.3 3
   Q=: -.5 6 e.~i.3 4
   M KP N
 0  5  0 10
 6  7 12 14
 0 15  0 20
18 21 24 28
   P KP Q
0 0 0 0 1 1 1 1 0 0 0 0
0 0 0 0 1 0 0 1 0 0 0 0
0 0 0 0 1 1 1 1 0 0 0 0
1 1 1 1 1 1 1 1 1 1 1 1
1 0 0 1 1 0 0 1 1 0 0 1
1 1 1 1 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0
0 0 0 0 1 0 0 1 0 0 0 0
0 0 0 0 1 1 1 1 0 0 0 0

Java

package kronecker;

/**
 * Defines a function to calculate the Kronecker product of two
 * rectangular matrices and tests it with two examples.
 */
public class Product {
  /**
   * Find the Kronecker product of the arguments.
   * @param a The first matrix to multiply.
   * @param b The second matrix to multiply.
   * @return A new matrix: the Kronecker product of the arguments.
   */
  public static int[][] product(final int[][] a, final int[][] b) {
    // Create matrix c as the matrix to fill and return.
    // The length of a matrix is its number of rows.
    final int[][] c = new int[a.length*b.length][];
    // Fill in the (empty) rows of c.
    // The length of each row is the number of columns.
    for (int ix = 0; ix < c.length; ix++) {
      final int num_cols = a[0].length*b[0].length;
      c[ix] = new int[num_cols];
    }
    // Now fill in the values: the products of each pair.
    // Go through all the elements of a.
    for (int ia = 0; ia < a.length; ia++) {
      for (int ja = 0; ja < a[ia].length; ja++) {
        // For each element of a, multiply it by all the elements of b.
        for (int ib = 0; ib < b.length; ib++) {
          for (int jb = 0; jb < b[ib].length; jb++) {
             c[b.length*ia+ib][b[ib].length*ja+jb] = a[ia][ja] * b[ib][jb];
          }
        }
      }
    }

    // Return the completed product matrix c.
    return c;
  }

  /**
   * Print an integer matrix, lining up the columns by the width
   * of the longest printed element.
   * @param m The matrix to print.
   */
  public static void print_matrix(final int[][] m) {
    // Printing the matrix neatly is the most complex part.
    // For clean formatting, convert each number to a string
    // and find length of the longest of these strings.
    // Build a matrix of these strings to print later.
    final String[][] sts = new String[m.length][];
    int max_length = 0;  // Safe, since all lengths are positive here.
    for (int im = 0; im < m.length; im++) {
      sts[im] = new String[m[im].length];
      for (int jm = 0; jm < m[im].length; jm++) {
        final String st = String.valueOf(m[im][jm]);
        if (st.length() > max_length) {
          max_length = st.length();
        }
        sts[im][jm] = st;
      }
    }

    // Now max_length holds the length of the longest string.
    // Build a format string to right justify the strings in a field
    // of this length.
    final String format = String.format("%%%ds", max_length);
    for (int im = 0; im < m.length; im++) {
      System.out.print("|");
      // Stop one short to avoid a trailing space.
      for (int jm = 0; jm < m[im].length - 1; jm++) {
        System.out.format(format, m[im][jm]);
        System.out.print(" ");
      }
      System.out.format(format, m[im][m[im].length - 1]);
      System.out.println("|");
    }
  }

  /**
   * Run a test by printing the arguments, computing their
   * Kronecker product, and printing it.
   * @param a The first matrix to multiply.
   * @param b The second matrix to multiply.
   */
  private static void test(final int[][] a, final int[][] b) {
    // Print out matrices and their product.
    System.out.println("Testing Kronecker product");
    System.out.println("Size of matrix a: " + a.length + " by " + a[0].length);
    System.out.println("Matrix a:");
    print_matrix(a);
    System.out.println("Size of matrix b: " + b.length + " by " + b[0].length);
    System.out.println("Matrix b:");
    print_matrix(b);
    System.out.println("Calculating matrix c as Kronecker product");
    final int[][] c = product(a, b);
    System.out.println("Size of matrix c: " + c.length + " by " + c[0].length);
    System.out.println("Matrix c:");
    print_matrix(c);
  }

  /**
   * Create the matrices for the first test and run the test.
   */
  private static void test1() {
    // Test 1: Create a and b.
    final int[][] a = new int[2][];  // 2 by 2
    a[0] = new int[]{1, 2};
    a[1] = new int[]{3, 4};
    final int[][] b = new int[2][];  // 2 by 2
    b[0] = new int[]{0, 5};
    b[1] = new int[]{6, 7};
    // Run the test.
    test(a, b);
  }

  /**
   * Create the matrices for the first test and run the test.
   */
  private static void test2() {
    // Test 2: Create a and b.
    final int[][] a = new int[3][];  // 3 by 3
    a[0] = new int[]{0, 1, 0};
    a[1] = new int[]{1, 1, 1};
    a[2] = new int[]{0, 1, 0};
    final int[][] b = new int[3][];  // 3 by 4
    b[0] = new int[]{1, 1, 1, 1};
    b[1] = new int[]{1, 0, 0, 1};
    b[2] = new int[]{1, 1, 1, 1};
    // Run the test.
    test(a, b);
  }

  /**
   * Run the program to run the two tests.
   * @param args Command line arguments (not used).
   */
  public static void main(final String[] args) {
    // Test the product method.
    test1();
    test2();
  }

}
Output:
Testing Kronecker product
Size of matrix a: 2 by 2
Matrix a:
|1 2|
|3 4|
Size of matrix b: 2 by 2
Matrix b:
|0 5|
|6 7|
Calculating matrix c as Kronecker product
Size of matrix c: 4 by 4
Matrix c:
| 0  5  0 10|
| 6  7 12 14|
| 0 15  0 20|
|18 21 24 28|
Testing Kronecker product
Size of matrix a: 3 by 3
Matrix a:
|0 1 0|
|1 1 1|
|0 1 0|
Size of matrix b: 3 by 4
Matrix b:
|1 1 1 1|
|1 0 0 1|
|1 1 1 1|
Calculating matrix c as Kronecker product
Size of matrix c: 9 by 12
Matrix c:
|0 0 0 0 1 1 1 1 0 0 0 0|
|0 0 0 0 1 0 0 1 0 0 0 0|
|0 0 0 0 1 1 1 1 0 0 0 0|
|1 1 1 1 1 1 1 1 1 1 1 1|
|1 0 0 1 1 0 0 1 1 0 0 1|
|1 1 1 1 1 1 1 1 1 1 1 1|
|0 0 0 0 1 1 1 1 0 0 0 0|
|0 0 0 0 1 0 0 1 0 0 0 0|
|0 0 0 0 1 1 1 1 0 0 0 0|

JavaScript

Imperative

Version #1.

Works with: Chrome
// matkronprod.js
// Prime function:
// mkp arrow function: Return the Kronecker product of the a and b matrices.
// Note: both a and b must be matrices, i.e., 2D rectangular arrays.
mkp=(a,b)=>a.map(a=>b.map(b=>a.map(y=>b.map(x=>r.push(y*x)),t.push(r=[]))),t=[])&&t;
// Helper functions:
// Log title and matrix mat to console
function matl2cons(title,mat) {console.log(title); console.log(mat.join`\n`)}
// Print title to document
function pttl2doc(title) {document.write('<b>'+title+'</b><br />')}
// Print title and matrix mat to document
function matp2doc(title,mat) {
  document.write('<b>'+title+'</b>:<br />');
  for (var i = 0; i < mat.length; i++) {
    document.write('&nbsp;&nbsp;'+mat[i].join(' ')+'<br />');
  }
}
Required tests
<!-- KronProdTest.html -->
<html><head>
  <title>Kronecker product: Sample 1 (from Wikipedia) and Sample 2</title>
  <script src="matkronprod.js"></script>
  <script>
  var mr,ttl='Kronecker product of A and B matrices';
  [ {a:[[1,2],[3,4]],b:[[0,5],[6,7]] },
    {a:[[0,1,0],[1,1,1],[0,1,0]],b:[[1,1,1,1],[1,0,0,1],[1,1,1,1]] }
  ].forEach(m=>{
    console.log(ttl); pttl2doc(ttl);
    matl2cons('A',m.a); matp2doc('A',m.a);
    matl2cons('B',m.b); matp2doc('B',m.b);
    mr=mkp(m.a,m.b);
    matl2cons('A x B',mr); matp2doc('A x B',mr);
    })
  </script>
</head><body></body>
</html>
Output:
Console and page results
Kronecker product of A and B matrices
A
1,2
3,4
B
0,5
6,7
A x B
0,5,0,10
6,7,12,14
0,15,0,20
18,21,24,28
Kronecker product of A and B matrices
A
0,1,0
1,1,1
0,1,0
B
1,1,1,1
1,0,0,1
1,1,1,1
A x B
0,0,0,0,1,1,1,1,0,0,0,0
0,0,0,0,1,0,0,1,0,0,0,0
0,0,0,0,1,1,1,1,0,0,0,0
1,1,1,1,1,1,1,1,1,1,1,1
1,0,0,1,1,0,0,1,1,0,0,1
1,1,1,1,1,1,1,1,1,1,1,1
0,0,0,0,1,1,1,1,0,0,0,0
0,0,0,0,1,0,0,1,0,0,0,0
0,0,0,0,1,1,1,1,0,0,0,0

Version #2.

This version is more understandable for sure.

Translation of: PARI/GP
Works with: Chrome
// matkronprod2.js
// Prime function:
// mkp2(): Return the Kronecker product of the a and b matrices
// Note: both a and b must be matrices, i.e., 2D rectangular arrays.
function mkp2(a,b) {
  var m=a.length, n=a[0].length, p=b.length, q=b[0].length;
  var rtn=m*p, ctn=n*q; var r=new Array(rtn);
  for (var i=0; i<rtn; i++) {r[i]=new Array(ctn)
    for (var j=0;j<ctn;j++) {r[i][j]=0}
  }
  for (var i=0; i<m; i++) {
    for (var j=0; j<n; j++) {
      for (var k=0; k<p; k++) {
        for (var l=0; l<q; l++) {
          r[p*i+k][q*j+l]=a[i][j]*b[k][l];
        }}}}//all4forend
  return(r);
}
// Helper functions:
// Log title and matrix mat to console
function matl2cons(title,mat) {console.log(title); console.log(mat.join`\n`)}
// Print title to document
function pttl2doc(title) {document.write('<b>'+title+'</b><br>')}
// Print title and matrix mat to document
function matp2doc(title,mat) {
  document.write('<b>'+title+'</b>:<br>');
  for (var i=0; i < mat.length; i++) {
    document.write('&nbsp;&nbsp;'+mat[i].join(' ')+'<br>');
  }
}
Required tests
<!-- KronProdTest2.html -->
<html><head>
  <title>Kronecker product v.2: Sample 1 (from Wikipedia) and Sample 2</title>
  <script src="matkronprod2.js"></script>
  <script>
  var mr,ttl='Kronecker product of A and B matrices';
  [ {a:[[1,2],[3,4]],b:[[0,5],[6,7]] },
    {a:[[0,1,0],[1,1,1],[0,1,0]],b:[[1,1,1,1],[1,0,0,1],[1,1,1,1]] }
  ].forEach(m=>{
    console.log(ttl); pttl2doc(ttl);
    matl2cons('A',m.a); matp2doc('A',m.a);
    matl2cons('B',m.b); matp2doc('B',m.b);
    mr=mkp2(m.a,m.b);
    matl2cons('A x B',mr); matp2doc('A x B',mr);
    })
  </script>
</head><body></body>
</html>
Output:
Console and page results
Output is identical to Version #1 above.

Functional

ES6

Translation of: Haskell

(As JavaScript is now widely embedded in non-browser contexts, a non-HTML string value is returned here, rather than making calls to methods of the Document Object Model, which is not part of JavaScript and will not always be available to a JavaScript interpreter)

(() => {
    'use strict';

    // --------- KRONECKER PRODUCT OF TWO MATRICES ---------

    // kprod :: [[Num]] -> [[Num]] -> [[Num]]
    const kprod = xs =>
        ys => concatMap(
            compose(map(concat), transpose)
        )(
            map(map(
                flip(compose(map, map, mul))(ys)
            ))(xs)
        );

    // ----------------------- TEST ------------------------
    // main :: IO ()
    const main = () =>
        unlines(map(compose(unlines, map(show)))([
            kprod([
                [1, 2],
                [3, 4]
            ])([
                [0, 5],
                [6, 7]
            ]), [], // One empty output line
            kprod([
                [0, 1, 0],
                [1, 1, 1],
                [0, 1, 0]
            ])([
                [1, 1, 1, 1],
                [1, 0, 0, 1],
                [1, 1, 1, 1]
            ])
        ]));


    // ----------------- GENERIC FUNCTIONS -----------------

    // compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
    const compose = (...fs) =>
        x => fs.reduceRight((a, f) => f(a), x);


    // concat :: [[a]] -> [a]
    const concat = xs => [].concat.apply([], xs);


    // concatMap :: (a -> [b]) -> [a] -> [b]
    const concatMap = f =>
        xs => xs.flatMap(f);


    // flip :: (a -> b -> c) -> b -> a -> c
    const flip = f =>
        x => y => f(y)(x);


    // map :: (a -> b) -> [a] -> [b]
    const map = f =>
        xs => xs.map(f);


    // mul (*) :: Num a => a -> a -> a
    const mul = a =>
        b => a * b;


    // show :: a -> String
    const show = x =>
        JSON.stringify(x); //, null, 2);


    // transpose :: [[a]] -> [[a]]
    const transpose = xs =>
        xs[0].map((_, col) => xs.map(row => row[col]));


    // unlines :: [String] -> String
    const unlines = xs =>
        xs.join('\n');


    // MAIN ---
    console.log(main());
})();
Output:
[0,5,0,10]
[6,7,12,14]
[0,15,0,20]
[18,21,24,28]

[0,0,0,0,1,1,1,1,0,0,0,0]
[0,0,0,0,1,0,0,1,0,0,0,0]
[0,0,0,0,1,1,1,1,0,0,0,0]
[1,1,1,1,1,1,1,1,1,1,1,1]
[1,0,0,1,1,0,0,1,1,0,0,1]
[1,1,1,1,1,1,1,1,1,1,1,1]
[0,0,0,0,1,1,1,1,0,0,0,0]
[0,0,0,0,1,0,0,1,0,0,0,0]
[0,0,0,0,1,1,1,1,0,0,0,0]

jq

In this entry, matrices are JSON arrays of numeric arrays. For the sake of illustration, the ancillary functions, though potentially independently useful, are defined here as inner functions.

def kprod(a; b):

  # element-wise multiplication of a matrix by a number, "c"
  def multiply(c): map( map(. * c) );

  # "right" should be a vector with the same length as the input
  def laminate(right):
    [range(0; right|length) as $i
    | (.[$i] + [right[$i]]) ];

  # "matrix" and the input matrix should have the same number of rows
  def addblock(matrix):
    reduce (matrix|transpose)[] as $v (.; laminate($v));

  (a[0]|length) as $m
  | reduce range(0; a|length) as $i ([];
      . + reduce range(0; $m) as $j ([];
        addblock( b | multiply(a[$i][$j]) ) ));

Examples:

def left:  [[ 1, 2], [3, 4]];
def right: [[ 0, 5], [6, 7]];

kprod(left;right)
Output:
[[0,5,0,10],[6,7,12,14],[0,15,0,20],[18,21,24,28]]
def left:  [[0, 1, 0], [1, 1, 1], [0, 1, 0]];
def right: [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]];

kprod(left;right)
Output:
[[0,0,0,0,1,1,1,1,0,0,0,0],
 [0,0,0,0,1,0,0,1,0,0,0,0],
 [0,0,0,0,1,1,1,1,0,0,0,0],
 [1,1,1,1,1,1,1,1,1,1,1,1],
 [1,0,0,1,1,0,0,1,1,0,0,1],
 [1,1,1,1,1,1,1,1,1,1,1,1],
 [0,0,0,0,1,1,1,1,0,0,0,0],
 [0,0,0,0,1,0,0,1,0,0,0,0],
 [0,0,0,0,1,1,1,1,0,0,0,0]]

Julia

# v0.6

# Julia has a builtin kronecker product function
a = [1 2; 3 4]
b = [0 5; 6 7]
k = kron(a, b)
println("$a × $b =")
for row in 1:size(k)[1]
    println(k[row,:])
end
println()

a = [0 1 0; 1 1 1; 0 1 0]
b = [1 1 1 1; 1 0 0 1; 1 1 1 1]
k = kron(a, b)
println("$a × $b =")
for row in 1:size(k)[1]
    println(k[row,:])
end
Output:
[1 2; 3 4] × [0 5; 6 7] =
[0, 5, 0, 10]
[6, 7, 12, 14]
[0, 15, 0, 20]
[18, 21, 24, 28]

[0 1 0; 1 1 1; 0 1 0] × [1 1 1 1; 1 0 0 1; 1 1 1 1] =
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]

Kotlin

// version 1.1.2 (JVM)

typealias Matrix = Array<IntArray>

fun kroneckerProduct(a: Matrix, b: Matrix): Matrix {
    val m = a.size
    val n = a[0].size
    val p = b.size
    val q = b[0].size
    val rtn = m * p
    val ctn = n * q
    val r: Matrix = Array(rtn) { IntArray(ctn) } // all elements zero by default
    for (i in 0 until m)
        for (j in 0 until n)
            for (k in 0 until p)
                for (l in 0 until q)
                    r[p * i + k][q * j + l] = a[i][j] * b[k][l]
    return r
}

fun printMatrix(text: String, m: Matrix) {
    println(text)
    for (i in 0 until m.size) println(m[i].contentToString())
    println()
}

fun printAll(a: Matrix, b: Matrix, r: Matrix) {
    printMatrix("Matrix A:", a)
    printMatrix("Matrix B:", b)
    printMatrix("Kronecker product:", r)
}

fun main(args: Array<String>) {
    var a: Matrix
    var b: Matrix
    var r: Matrix
    a = arrayOf(
        intArrayOf(1, 2),
        intArrayOf(3, 4)
    )
    b = arrayOf(
        intArrayOf(0, 5),
        intArrayOf(6, 7)
    )
    r = kroneckerProduct(a, b)
    printAll(a, b, r)

    a = arrayOf(
        intArrayOf(0, 1, 0),
        intArrayOf(1, 1, 1),
        intArrayOf(0, 1, 0)
    )
    b = arrayOf(
        intArrayOf(1, 1, 1, 1),
        intArrayOf(1, 0, 0, 1),
        intArrayOf(1, 1, 1, 1)
    )
    r = kroneckerProduct(a, b)
    printAll(a, b, r)
}
Output:
Matrix A:
[1, 2]
[3, 4]

Matrix B:
[0, 5]
[6, 7]

Kronecker product:
[0, 5, 0, 10]
[6, 7, 12, 14]
[0, 15, 0, 20]
[18, 21, 24, 28]

Matrix A:
[0, 1, 0]
[1, 1, 1]
[0, 1, 0]

Matrix B:
[1, 1, 1, 1]
[1, 0, 0, 1]
[1, 1, 1, 1]

Kronecker product:
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]

Lua

function prod( a, b )
    print( "\nPRODUCT:" )
    for m = 1, #a do
        for p = 1, #b do
            for n = 1, #a[m] do
                for q = 1, #b[p] do
                    io.write( string.format( "%3d ", a[m][n] * b[p][q] ) )
                end
            end
            print()
        end
    end
end
--[[entry point]]--
a = { { 1, 2 }, { 3, 4 } }; b = { { 0, 5 }, { 6, 7 } }
prod( a, b )      
a = { { 0, 1, 0 }, { 1, 1, 1 }, { 0, 1, 0 } }
b = { { 1, 1, 1, 1 }, { 1, 0, 0, 1 }, { 1, 1, 1, 1 } }
prod( a, b )
Output:
PRODUCT:
  0   5   0  10
  6   7  12  14
  0  15   0  20
 18  21  24  28

PRODUCT:
  0   0   0   0   1   1   1   1   0   0   0   0
  0   0   0   0   1   0   0   1   0   0   0   0
  0   0   0   0   1   1   1   1   0   0   0   0
  1   1   1   1   1   1   1   1   1   1   1   1
  1   0   0   1   1   0   0   1   1   0   0   1
  1   1   1   1   1   1   1   1   1   1   1   1
  0   0   0   0   1   1   1   1   0   0   0   0
  0   0   0   0   1   0   0   1   0   0   0   0
  0   0   0   0   1   1   1   1   0   0   0   0

Mathematica/Wolfram Language

KroneckerProduct[{{1, 2}, {3, 4}}, {{0, 5}, {6, 7}}]//MatrixForm
KroneckerProduct[{{0, 1, 0}, {1, 1, 1}, {0, 1, 0}}, 
 {{1, 1, 1, 1}, {1, 0, 0, 1}, {1, 1, 1, 1}}]//MatrixForm
Output:
0	5	0	10
6	7	12	14
0	15	0	20
18	21	24	28

0	0	0	0	1	1	1	1	0	0	0	0
0	0	0	0	1	0	0	1	0	0	0	0
0	0	0	0	1	1	1	1	0	0	0	0
1	1	1	1	1	1	1	1	1	1	1	1
1	0	0	1	1	0	0	1	1	0	0	1
1	1	1	1	1	1	1	1	1	1	1	1
0	0	0	0	1	1	1	1	0	0	0	0
0	0	0	0	1	0	0	1	0	0	0	0
0	0	0	0	1	1	1	1	0	0	0	0

Maxima

There is a built-in function kronecker autoloaded from linearalgebra package.

Here comes a naive implementation.

/* Function to map first, second and so on, over a list of lists without recurring corresponding built-in functions */
auxkron(n,lst):=makelist(lst[k][n],k,1,length(lst));

/* Function to subdivide a list into lists of equal lengths */
lst_equally_subdivided(lst,n):=if mod(length(lst),n)=0 then makelist(makelist(lst[i],i,j,j+n-1),j,1,length(lst)-1,n);

/* Kronecker product implementation */
alternative_kronecker(MatA,MatB):=block(auxlength:length(first(args(MatA))),makelist(i*args(MatB),i,flatten(args(MatA))),
makelist(apply(matrix,%%[i]),i,1,length(%%)),
lst_equally_subdivided(%%,auxlength),
makelist(map(args,%%[i]),i,1,length(%%)),
makelist(auxkron(j,%%),j,1,auxlength),
makelist(apply(append,%%[i]),i,1,length(%%)),
apply(matrix,%%),
transpose(%%),
args(%%),
makelist(apply(append,%%[i]),i,1,length(%%)),
apply(matrix,%%));

Another implementation that does not make use of auxkron

altern_kronecker(MatA,MatB):=block(auxlength:length(first(args(MatA))),
makelist(i*args(MatB),i,flatten(args(MatA))),
makelist(apply(matrix,%%[i]),i,1,length(%%)),
lst_equally_subdivided(%%,auxlength),
makelist(apply(addcol,%%[i]),i,1,length(%%)),
map(args,%%),
apply(append,%%),
apply(matrix,%%));
Output:

A:matrix([0,1,0],[1,1,1],[0,1,0])$ B:matrix([1,1,1,1],[1,0,0,1],[1,1,1,1])$

C:matrix([1,2],[3,4])$ D:matrix([0,5],[6,7])$

alternative_kronecker(A,B); /* matrix( [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0] ) */

alternative_kronecker(C,D); /* matrix( [0, 5, 0, 10], [6, 7, 12, 14], [0, 15, 0, 20], [18, 21, 24, 28] ) */

/* altern_kronecker gives the same outputs */

Nim

Same as Kotlin but with a generic Matrix type.

import strutils

type Matrix[M, N: static Positive; T: SomeNumber] = array[M, array[N, T]]

func kroneckerProduct[M, N, P, Q: static int; T: SomeNumber](
  a: Matrix[M, N, T], b: Matrix[P, Q, T]): Matrix[M * P, N * Q, T] =
  for i in 0..<M:
    for j in 0..<N:
      for k in 0..<P:
        for l in 0..<Q:
          result[i * P + k][j * Q + l] = a[i][j] * b[k][l]

proc `$`(m: Matrix): string =
  for row in m:
    result.add '['
    let length = result.len
    for val in row:
      result.addSep(" ", length)
      result.add ($val).align(2)
    result.add "]\n"


when isMainModule:

  const
    A1: Matrix[2, 2, int] = [[1, 2], [3, 4]]
    B1: Matrix[2, 2, int] = [[0, 5], [6, 7]]

  echo "Matrix A:\n", A1
  echo "Matrix B:\n", B1
  echo "Kronecker product:\n", kroneckerProduct(A1, B1)

  const
    A2: Matrix[3, 3, int] = [[0, 1, 0], [1, 1, 1], [0, 1, 0]]
    B2: Matrix[3, 4, int] = [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]]

  echo "Matrix A:\n", A2
  echo "Matrix B:\n", B2
  echo "Kronecker product:\n", kroneckerProduct(A2, B2)
Output:
Matrix A:
[ 1  2]
[ 3  4]

Matrix B:
[ 0  5]
[ 6  7]

Kronecker product:
[ 0  5  0 10]
[ 6  7 12 14]
[ 0 15  0 20]
[18 21 24 28]

Matrix A:
[ 0  1  0]
[ 1  1  1]
[ 0  1  0]

Matrix B:
[ 1  1  1  1]
[ 1  0  0  1]
[ 1  1  1  1]

Kronecker product:
[ 0  0  0  0  1  1  1  1  0  0  0  0]
[ 0  0  0  0  1  0  0  1  0  0  0  0]
[ 0  0  0  0  1  1  1  1  0  0  0  0]
[ 1  1  1  1  1  1  1  1  1  1  1  1]
[ 1  0  0  1  1  0  0  1  1  0  0  1]
[ 1  1  1  1  1  1  1  1  1  1  1  1]
[ 0  0  0  0  1  1  1  1  0  0  0  0]
[ 0  0  0  0  1  0  0  1  0  0  0  0]
[ 0  0  0  0  1  1  1  1  0  0  0  0]

Octave

>> kron([1 2; 3 4], [0 5; 6 7])
ans =

    0    5    0   10
    6    7   12   14
    0   15    0   20
   18   21   24   28

>> kron([0 1 0; 1 1 1; 0 1 0], [1 1 1 1; 1 0 0 1; 1 1 1 1])
ans =

   0   0   0   0   1   1   1   1   0   0   0   0
   0   0   0   0   1   0   0   1   0   0   0   0
   0   0   0   0   1   1   1   1   0   0   0   0
   1   1   1   1   1   1   1   1   1   1   1   1
   1   0   0   1   1   0   0   1   1   0   0   1
   1   1   1   1   1   1   1   1   1   1   1   1
   0   0   0   0   1   1   1   1   0   0   0   0
   0   0   0   0   1   0   0   1   0   0   0   0
   0   0   0   0   1   1   1   1   0   0   0   0

ooRexx

Translation of: REXX
/*REXX program multiplies two matrices together,                      */
/* displays the matrices and the result.                              */
Signal On syntax
amat=2x2 1 2 3 4                 /* define A matrix size and elements */
bmat=2x2 0 5 6 7                 /* "      B    "     "   "     "     */
a=.matrix~new('A',2,2,1 2 3 4)         /* create matrix A             */
b=.matrix~new('B',2,2,0 5 6 7)         /* create matrix B             */
a~show
b~show
c=kronmat(a,b)
c~show
Say ''
Say copies('|',55)
Say ''
a=.matrix~new('A',3,3,0 1 0 1 1 1 0 1 0)         /* create matrix A   */
b=.matrix~new('B',3,4,1 1 1 1 1 0 0 1 1 1 1 1)   /* create matrix B   */
a~show
b~show
c=kronmat(a,b)
c~show
Exit

kronmat: Procedure               /* compute the Kronecker Product     */
  Use Arg a,b
  rp=0                           /* row of product                    */
  Do ra=1 To a~rows
    Do rb=1 To b~rows
      rp=rp+1                    /* row of product                    */
      cp=0                       /* column of product                 */
      Do ca=1 To a~cols
        x=a~element(ra,ca)
        Do cb=1 To b~cols
          y=b~element(rb,cb)
          cp=cp+1                /* column of product                 */
          xy=x*y
          c.rp.cp=xy             /* element of product                */
          End /* cb */
        End /* ca */
      End /* rb */
    End /* ra */
  mm=''
  Do i=1 To a~rows*b~rows
    Do j=1 To a~rows*b~cols
      mm=mm C.i.j
      End /*j*/
    End /*i*/
  c=.matrix~new('Kronecker product',a~rows*b~rows,a~rows*b~cols,mm)
  Return c
/*--------------------------------------------------------------------*/
Exit:
  Say arg(1)
  Exit
Syntax:
  Say 'Syntax raised in line' sigl
  Say sourceline(sigl)
  Say 'rc='rc '('errortext(rc)')'
  Say '***** There was a problem!'
  Exit

::class Matrix
/********************************************************************
* Matrix is implemented as an array of rows
* where each row is an arryay of elements.
********************************************************************/
::Attribute name
::Attribute rows
::Attribute cols

::Method init
  expose m name rows cols
  Use Arg name,rows,cols,elements
  If words(elements)<>(rows*cols) Then Do
    Say 'incorrect number of elements ('words(elements)')<>'||(rows*cols)
    m=.nil
    Return
    End
  m=.array~new
  Do r=1 To rows
    ro=.array~new
    Do c=1 To cols
      Parse Var elements e elements
      ro~append(e)
      End
    m~append(ro)
    End

::Method element   /* get an element's value */
  expose m
  Use Arg r,c
  ro=m[r]
  Return ro[c]

::Method set       /* set an element's value and return its previous */
  expose m
  Use Arg r,c,new
  ro=m[r]
  old=ro[c]
  ro[c]=new
  Return old

::Method show  public  /* display the matrix */
  expose m name rows cols
  z='+'
  b6=left('',6)
  Say ''
  Say b6 copies('-',7) 'matrix' name copies('-',7)
  w=0
  Do r=1 To rows
    ro=m[r]
    Do c=1 To cols
      x=ro[c]
      w=max(w,length(x))
      End
    End
  Say b6 b6 '+'copies('-',cols*(w+1)+1)'+' /* top border              */
  Do r=1 To rows
    ro=m[r]
    line='|' right(ro[1],w)         /* element of first colsumn       */                       /* start with long vertical bar   */
    Do c=2 To cols                  /* loop for other columns         */
      line=line right(ro[c],w)      /* append the elements            */
      End /* c */
    Say b6 b6 line '|'              /* append a long vertical bar.    */
    End /* r */
  Say b6 b6 '+'copies('-',cols*(w+1)+1)'+' /* bottom border           */
  Return
output:
       ------- matrix A -------
              +-----+
              | 1 2 |
              | 3 4 |
              +-----+

       ------- matrix B -------
              +-----+
              | 0 5 |
              | 6 7 |
              +-----+

       ------- matrix Kronecker product -------
              +-------------+
              |  0  5  0 10 |
              |  6  7 12 14 |
              |  0 15  0 20 |
              | 18 21 24 28 |
              +-------------+

|||||||||||||||||||||||||||||||||||||||||||||||||||||||


       ------- matrix A -------
              +-------+
              | 0 1 0 |
              | 1 1 1 |
              | 0 1 0 |
              +-------+

       ------- matrix B -------
              +---------+
              | 1 1 1 1 |
              | 1 0 0 1 |
              | 1 1 1 1 |
              +---------+

       ------- matrix Kronecker product -------
              +-------------------------+
              | 0 0 0 0 1 1 1 1 0 0 0 0 |
              | 0 0 0 0 1 0 0 1 0 0 0 0 |
              | 0 0 0 0 1 1 1 1 0 0 0 0 |
              | 1 1 1 1 1 1 1 1 1 1 1 1 |
              | 1 0 0 1 1 0 0 1 1 0 0 1 |
              | 1 1 1 1 1 1 1 1 1 1 1 1 |
              | 0 0 0 0 1 1 1 1 0 0 0 0 |
              | 0 0 0 0 1 0 0 1 0 0 0 0 |
              | 0 0 0 0 1 1 1 1 0 0 0 0 |
              +-------------------------+


PARI/GP

Version #1

Works with: PARI/GP version 2.9.1 and above
\\ Print title and matrix mat rows. 4/17/16 aev
matprows(title,mat)={print(title); for(i=1,#mat[,1], print(mat[i,]))}
\\ 
\\ Create and return the Kronecker product of the a and b matrices. 4/17/16 aev
matkronprod(a,b,pflg=0)={
my(m=#a[,1],n=#a[1,],p=#b[,1],q=#b[1,],r,rtn,ctn);
rtn=m*p; ctn=n*q;
if(pflg,print(" *** Kronecker product - a: ",m," x ",n," b: ",p," x ",q," result r: ",rtn," x ",ctn));
r=matrix(rtn,ctn);
for(i=1,m, for(j=1,n, for(k=1,p, for(l=1,q,
    r[p*(i-1)+k,q*(j-1)+l]=a[i,j]*b[k,l];
))));\\all4fend
if(pflg,print(r)); return(r);
}
{\\ Requireq tests:
my(a,b,r);
\\ Sample 1
a=[1,2;3,4];
b=[0,5;6,7];
r=matkronprod(a,b);
matprows("Sample 1 result:",r);
\\ Sample 2
a=[0,1,0;1,1,1;0,1,0];
b=[1,1,1,1;1,0,0,1;1,1,1,1];
r=matkronprod(a,b);
matprows("Sample 2 result:",r);
}
Output:
Sample 1 result:
[0, 5, 0, 10]
[6, 7, 12, 14]
[0, 15, 0, 20]
[18, 21, 24, 28]
Sample 2 result:
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]

Version #2

This version is from B. Allombert. 12/12/17

Works with: PARI/GP version 2.9.1 and above
\\ Print title and matrix mat rows. aev
matprows(title,mat)={print(title); for(i=1,#mat[,1], print(mat[i,]))}
\\ 
\\ Create and return the Kronecker product of the a and b matrices. 12/12/17 ba
kronprod(a,b)={return(matconcat(matrix(#a[,1],#a,i,j,a[i,j]*b)))}
{\\ Requireq tests:
my(a,b,r);
\\ Sample 1
a=[1,2;3,4];
b=[0,5;6,7];
r=kronprod(a,b);
matprows("Sample 1 result:",r);
\\ Sample 2
a=[0,1,0;1,1,1;0,1,0];
b=[1,1,1,1;1,0,0,1;1,1,1,1];
r=kronprod(a,b);
matprows("Sample 2 result:",r);
}
Output:
Sample 1 result:
[0, 5, 0, 10]
[6, 7, 12, 14]
[0, 15, 0, 20]
[18, 21, 24, 28]
Sample 2 result:
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]

Perl

#!/usr/bin/perl
use strict;
use warnings;
use PDL;

sub kron {
    my ($x, $y) = @_;

    return $x->dummy(0)
             ->dummy(0)
             ->mult($y, 0)
             ->clump(0, 2)
             ->clump(1, 2)
}

my @mats = (
	[pdl([[1, 2], [3, 4]]),
         pdl([[0, 5], [6, 7]])],
	[pdl([[0, 1, 0], [1, 1, 1], [0, 1, 0]]),
         pdl([[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]])],
);
for my $mat (@mats) {
	print "A = $mat->[0]\n";
	print "B = $mat->[1]\n";
	print "kron(A,B) = " . kron($mat->[0], $mat->[1]) . "\n";
}

Phix

function kronecker(sequence a, b)
    integer ar = length(a),
            ac = length(a[1]),
            br = length(b),
            bc = length(b[1])
    sequence res = repeat(repeat(0,ac*bc),ar*br)
    for ia=1 to ar do
        integer i0 = (ia-1)*br
        for ja=1 to ac do
            integer j0 = (ja-1)*bc
            for ib=1 to br do
                integer i = i0+ib
                for jb=1 to bc do
                    integer j = j0+jb
                    res[i,j] = a[ia,ja]*b[ib,jb]
                end for
            end for
        end for
    end for
    return res
end function
 
constant a = {{1,2},
              {3,4}},
         b = {{0,5},
              {6,7}},
         c = {{0,1,0},
              {1,1,1},
              {0,1,0}},
         d = {{1,1,1,1},
              {1,0,0,1},
              {1,1,1,1}}
 
pp(kronecker(a,b),{pp_Nest,1,pp_IntFmt,"%2d"})
pp(kronecker(c,d),{pp_Nest,1})
Output:
{{ 0, 5, 0,10},
 { 6, 7,12,14},
 { 0,15, 0,20},
 {18,21,24,28}}
{{0,0,0,0,1,1,1,1,0,0,0,0},
 {0,0,0,0,1,0,0,1,0,0,0,0},
 {0,0,0,0,1,1,1,1,0,0,0,0},
 {1,1,1,1,1,1,1,1,1,1,1,1},
 {1,0,0,1,1,0,0,1,1,0,0,1},
 {1,1,1,1,1,1,1,1,1,1,1,1},
 {0,0,0,0,1,1,1,1,0,0,0,0},
 {0,0,0,0,1,0,0,1,0,0,0,0},
 {0,0,0,0,1,1,1,1,0,0,0,0}}

Pike

Translation of: Python
array kronecker(array matrix1, array matrix2) {
	array final_list = ({});
	array sub_list = ({});

	int count = sizeof(matrix2);

	foreach(matrix1, array elem1) {
		int counter = 0;
		int check = 0;
		while (check < count) {
			foreach(elem1, int num1) {
				foreach(matrix2[counter], int num2) {
					sub_list = Array.push(sub_list, num1 * num2);
				}
			}
		counter += 1;
		final_list = Array.push(final_list, sub_list);
		sub_list = ({});
		check += 1;
		}
	}	

	return final_list;
}

int main() {
	//Sample 1
	array(array(int)) a1 = ({ ({1, 2}), ({3, 4}) });
	array(array(int)) b1 = ({ ({0, 5}), ({6, 7}) });
	
	//Sample 2
	array(array(int)) a2 = ({ ({0, 1, 0}), ({1, 1, 1}), ({0, 1, 0}) });
	array(array(int)) b2 = ({ ({1, 1, 1, 1}), ({1, 0, 0, 1}), ({1, 1, 1, 1}) });

	array result1 = kronecker(a1, b1);
	for (int i = 0; i < sizeof(result1); i++) {
		foreach(result1[i], int result) {
			write((string)result + " ");
		}
		write("\n");
	}

	write("\n");

	array result2 = kronecker(a2, b2);
	for (int i = 0; i < sizeof(result2); i++) {
		foreach(result2[i], int result) {
			write((string)result + " ");
		}
		write("\n");
	}

	return 0;
}
Output:
0 5 0 10 
6 7 12 14 
0 15 0 20 
18 21 24 28 

0 0 0 0 1 1 1 1 0 0 0 0 
0 0 0 0 1 0 0 1 0 0 0 0 
0 0 0 0 1 1 1 1 0 0 0 0 
1 1 1 1 1 1 1 1 1 1 1 1 
1 0 0 1 1 0 0 1 1 0 0 1 
1 1 1 1 1 1 1 1 1 1 1 1 
0 0 0 0 1 1 1 1 0 0 0 0 
0 0 0 0 1 0 0 1 0 0 0 0 
0 0 0 0 1 1 1 1 0 0 0 0

PureBasic

EnableExplicit
DataSection
  Matrix_A_B_Dimension_Bsp1:
  Data.i 2,2,?MatrixA_Werte_Bsp1,2,2,?MatrixB_Werte_Bsp1
    
  Matrix_A_B_Dimension_Bsp2:
  Data.i 3,3,?MatrixA_Werte_Bsp2,3,4,?MatrixB_Werte_Bsp2
  
  MatrixA_Werte_Bsp1:
  Data.i 1,2,3,4
  
  MatrixA_Werte_Bsp2:
  Data.i 0,1,0,1,1,1,0,1,0
  
  MatrixB_Werte_Bsp1:
  Data.i 0,5,6,7
  
  MatrixB_Werte_Bsp2:
  Data.i 1,1,1,1,1,0,0,1,1,1,1,1
EndDataSection

Define.i ma, na, mb, nb, adr1, adr2, i, j, k, l
Define mk$

Gosub Bsp1_Matrix_A_B : Gosub LoadMatrix : Gosub Bsp2_Matrix_A_B : Gosub LoadMatrix : End

LoadMatrix:
Read.i ma
Read.i na
Read.i adr1
Read.i mb
Read.i nb
Read.i adr2

Dim mxa.i(ma,na)
Dim mxb.i(mb,nb)
NewMap mxc.i()

For i=1 To ma
  For j=1 To na
    mxa(i,j)=PeekI(adr1)
    adr1+SizeOf(Integer)
  Next
Next

For i=1 To mb
  For j=1 To nb
    mxb(i,j)=PeekI(adr2)
    adr2+SizeOf(Integer)
  Next
Next

OpenConsole("Kronecker product")
PrintN("Matrix A:")
For i=1 To ma ; Zeile
  Print("|")
  For j=1 To na ; Spalte
    Print(RSet(Str(mxa(i,j)),2," ")+" ")
  Next
  PrintN("|")
Next
PrintN("")

PrintN("Matrix B:")
For i=1 To mb ; Zeile
  Print("|")
  For j=1 To nb ; Spalte
    Print(RSet(Str(mxb(i,j)),2," ")+" ")
  Next
  PrintN("|")
Next
PrintN("")

PrintN("Matrix C=AxB")
For i=1 To ma ; Zeile MA
  For j=1 To na ; Spalte MA
    For k=1 To mb ; Zeile MB
      For l=1 To nb ; Spalte MB        
        mxc(Str(i)+","+Str(j)+","+Str(k)+","+Str(l))=mxa(i,j)*mxb(k,l)
      Next
    Next
  Next
Next

For i=1 To ma ; Zeile MA
  For k=1 To mb; Zeile MB
    Print("|")
    For j=1 To na ; Spalte MA
      For l=1 To nb ; Spalte MB
        mk$=Str(i)+","+Str(j)+","+Str(k)+","+Str(l)
        If FindMapElement(mxc(),mk$)        
          Print(RSet(Str(mxc()),2," ")+" ")
        EndIf        
      Next
    Next
    PrintN("|")
  Next    
Next
PrintN("Press return") : Input()
Return

Bsp1_Matrix_A_B:
  Restore Matrix_A_B_Dimension_Bsp1
Return

Bsp2_Matrix_A_B:
  Restore Matrix_A_B_Dimension_Bsp2
Return
Output:
Matrix A:
| 1  2 |
| 3  4 |

Matrix B:
| 0  5 |
| 6  7 |

Matrix C=AxB
| 0  5  0 10 |
| 6  7 12 14 |
| 0 15  0 20 |
|18 21 24 28 |
Press return

Matrix A:
| 0  1  0 |
| 1  1  1 |
| 0  1  0 |

Matrix B:
| 1  1  1  1 |
| 1  0  0  1 |
| 1  1  1  1 |

Matrix C=AxB
| 0  0  0  0  1  1  1  1  0  0  0  0 |
| 0  0  0  0  1  0  0  1  0  0  0  0 |
| 0  0  0  0  1  1  1  1  0  0  0  0 |
| 1  1  1  1  1  1  1  1  1  1  1  1 |
| 1  0  0  1  1  0  0  1  1  0  0  1 |
| 1  1  1  1  1  1  1  1  1  1  1  1 |
| 0  0  0  0  1  1  1  1  0  0  0  0 |
| 0  0  0  0  1  0  0  1  0  0  0  0 |
| 0  0  0  0  1  1  1  1  0  0  0  0 |
Press return

Python

Version 1

In Python, the numpy library has the kron function. The following is an implementation for "bare" lists of lists.

#!/usr/bin/env python3

# Sample 1
a1 = [[1, 2], [3, 4]]
b1 = [[0, 5], [6, 7]]

# Sample 2
a2 = [[0, 1, 0], [1, 1, 1], [0, 1, 0]]
b2 = [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]]

def kronecker(matrix1, matrix2):
    final_list = []
    sub_list = []

    count = len(matrix2)

    for elem1 in matrix1:
        counter = 0
        check = 0
        while check < count:
            for num1 in elem1:
                for num2 in matrix2[counter]:
                    sub_list.append(num1 * num2)
            counter += 1
            final_list.append(sub_list)
            sub_list = []
            check +=1
            
    return final_list

# Result 1
result1 = kronecker(a1, b1)
for elem in result1:
    print(elem)

print("")

# Result 2
result2 = kronecker(a2, b2)
for elem in result2:
    print(elem)

Result:

[0, 5, 0, 10]
[6, 7, 12, 14]
[0, 15, 0, 20]
[18, 21, 24, 28]

[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]

Version 2

This version was initially based on and uses a similar looping structure to version 1, but it is much less readable for those not familiar with Python list comprehensions. Nevertheless I think it serves as a wonderful example of what list comprehensions can be good for. My original version of this code took an iterable as input and recursively computed the Kronecker product of any number of matrices, which is a very common use case in arenas where the Kronecker product is used. I have reduced this example to match the task description, but I encourage learners to attempt to reimplement it.

Code:

# Sample 1
r = [[1, 2], [3, 4]]
s = [[0, 5], [6, 7]]

# Sample 2
t = [[0, 1, 0], [1, 1, 1], [0, 1, 0]]
u = [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]]

def kronecker(matrix1, matrix2):
    return [[num1 * num2 for num1 in elem1 for num2 in matrix2[row]] for elem1 in matrix1 for row in range(len(matrix2))]

# Result 1:
for row in kronecker(r, s):
    print(row)
print()

# Result 2
for row in kronecker(t, u):
    print(row)

Version 3

We can still get the power of list comprehensions (without generating the unreadably long single lines of code referred to above) by de-sugaring them down to the underlying list monad pattern.

Version three rewrites the list comprehension above in terms of concatMap (the 'bind' or 'insert' operator for list monads), to which we pass a function that returns its value wrapped in a list. (Where values are filtered out by a condition, we return an empty list).

Note, for example, that the innermost expression here has to be lambda num1: [num1 * num2], rather than just lambda num1: num1 * num2.

The outermost part of the concatMap nest corresponds to the rightmost part of the list comprehension expression.

(Versions 2 and 3 produce the same output from the same test)

from itertools import (chain)


# kronecker :: [[a]] -> [[a]] -> [[a]]
def kronecker(m1, m2):
    return concatMap(
        lambda row2: concatMap(
            lambda elem2: [concatMap(
                lambda num2: concatMap(
                    lambda num1: [num1 * num2],
                    elem2
                ),
                m1[row2]
            )],
            m2
        ),
        range(len(m2))
    )


# concatMap :: (a -> [b]) -> [a] -> [b]
def concatMap(f, xs):
    return list(
        chain.from_iterable(
            map(f, xs)
        )
    )


if __name__ == '__main__':
    # Sample 1
    r = [[1, 2], [3, 4]]
    s = [[0, 5], [6, 7]]

    # Sample 2
    t = [[0, 1, 0], [1, 1, 1], [0, 1, 0]]
    u = [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]]

    # Result 1:
    for row in kronecker(r, s):
        print(row)
    print()

    # Result 2
    for row in kronecker(t, u):
        print(row)
Output:
[0, 5, 0, 10]
[6, 7, 12, 14]
[0, 15, 0, 20]
[18, 21, 24, 28]

[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]

R

R has built-in Kronecker product operator for a and b matrices: a %x% b.

## Sample using:
a <- matrix(c(1,1,1,1), ncol=2, nrow=2, byrow=TRUE);
b <- matrix(c(0,1,1,0), ncol=2, nrow=2, byrow=TRUE);
a %x% b
Output:
     [,1] [,2] [,3] [,4]
[1,]    0    1    0    1
[2,]    1    0    1    0
[3,]    0    1    0    1
[4,]    1    0    1    0

Note: This resultant matrix could be used as initial for Checkerboard fractal.

Racket

Uses typed racket, since the 'math/...' libraries are much more performant in that language.

#lang typed/racket/base

(require math/array
         math/matrix
         racket/match)

(define-type (M A) (Matrix A))

(define #:forall (A B C) (general-⊗ [m1 : (M A)] [m2 : (M B)] [× : (A B -> C)]) : (M C)
  (match-let* ((`(#(,rs1 ,cs1) . #(,rs2 ,cs2)) (cons (array-shape m1) (array-shape m2)))
               (rs (* rs1 rs2))
               (cs (* cs1 cs2)))
    (for*/matrix: rs cs ((r (in-range rs)) (c (in-range cs))) : C
      (let-values (((rq rr) (quotient/remainder r rs2))
                   ((cq cr) (quotient/remainder c cs2)))
        (× (array-ref m1 (vector rq cq)) (array-ref m2 (vector rr cr)))))))

;; Narrow to Number
(define (Kronecker-product [m1 : (M Number)] [m2 : (M Number)]) (general-⊗ m1 m2 *))

;; ---------------------------------------------------------------------------------------------------
(module+ test
  (Kronecker-product (matrix [[1 2]
                              [3 4]])
                     (matrix [[0 5]
                              [6 7]]))
  
  (Kronecker-product (matrix [[0 1 0]
                              [1 1 1]
                              [0 1 0]])
                     (matrix [[1 1 1 1]
                              [1 0 0 1]
                              [1 1 1 1]])))
Output:
(mutable-array #[#[0 5 0 10] #[6 7 12 14] #[0 15 0 20] #[18 21 24 28]])
(mutable-array
 #[#[0 0 0 0 1 1 1 1 0 0 0 0]
   #[0 0 0 0 1 0 0 1 0 0 0 0]
   #[0 0 0 0 1 1 1 1 0 0 0 0]
   #[1 1 1 1 1 1 1 1 1 1 1 1]
   #[1 0 0 1 1 0 0 1 1 0 0 1]
   #[1 1 1 1 1 1 1 1 1 1 1 1]
   #[0 0 0 0 1 1 1 1 0 0 0 0]
   #[0 0 0 0 1 0 0 1 0 0 0 0]
   #[0 0 0 0 1 1 1 1 0 0 0 0]])

Raku

(formerly Perl 6)

Works with: rakudo version 2017.01-34-g700a077
sub kronecker_product ( @a, @b ) {
    return (@a X @b).map: { .[0].list X* .[1].list };
}

.say for kronecker_product([ <1 2>, <3 4> ],
                           [ <0 5>, <6 7> ]);
say '';
.say for kronecker_product([ <0 1 0>,   <1 1 1>,   <0 1 0>  ],
                           [ <1 1 1 1>, <1 0 0 1>, <1 1 1 1>]);
Output:
(0 5 0 10)
(6 7 12 14)
(0 15 0 20)
(18 21 24 28)

(0 0 0 0 1 1 1 1 0 0 0 0)
(0 0 0 0 1 0 0 1 0 0 0 0)
(0 0 0 0 1 1 1 1 0 0 0 0)
(1 1 1 1 1 1 1 1 1 1 1 1)
(1 0 0 1 1 0 0 1 1 0 0 1)
(1 1 1 1 1 1 1 1 1 1 1 1)
(0 0 0 0 1 1 1 1 0 0 0 0)
(0 0 0 0 1 0 0 1 0 0 0 0)
(0 0 0 0 1 1 1 1 0 0 0 0)

REXX

A little extra coding was added to make the matrix glyphs and elements alignment look nicer.

/*REXX program calculates the Kronecker product of two matrices.      */
w=0                              /* W: max width of any matrix element*/
amat=2x2 1 2 3 4                 /* define A matrix size and elements */
bmat=2x2 0 5 6 7                 /* "      B    "     "   "     "     */
Call makeMat 'A',amat            /* construct A matrix from elements  */
Call makeMat 'B',bmat            /* "         B    "     "     "      */
Call KronMat 'Kronecker product' /* calculate the Kronecker  product  */
Call showMat what,arows*brows||'X'||arows*bcols
Say ''
Say copies('|',55)
Say ''
w=0                              /* W: max width of any matrix element*/
amat=3x3 0 1 0 1 1 1 0 1 0       /* define A matrix size and elements */
bmat=3x4 1 1 1 1 1 0 0 1 1 1 1 1 /* "      B    "     "   "     "     */
Call makeMat 'A',amat            /* construct A matrix from elements  */
Call makeMat 'B',bmat            /* "         B    "     "     "      */
Call KronMat 'Kronecker product' /* calculate the Kronecker  product  */
Call showMat what,arows*brows||'X'||arows*bcols
Exit                             /* stick a fork in it, we're all done*/
/*--------------------------------------------------------------------*/
makemat:
  Parse Arg what,size elements   /*elements: e.1.1 e.1.2 - e.rows cols*/
  Parse Var size rows 'X' cols
  x.what.shape=rows cols
  n=0
  Do r=1 To rows
    Do c=1 To cols
      n=n+1
      element=word(elements,n)
      w=max(w,length(element))
      x.what.r.c=element
      End
    End
  Call showMat what,size
  Return
/*--------------------------------------------------------------------*/
kronmat:                         /* compute the Kronecker Product     */
  Parse Arg what
  Parse Var x.a.shape arows acols
  Parse Var x.b.shape brows bcols
  rp=0                           /* row of product                    */
  Do ra=1 To arows
    Do rb=1 To brows
      rp=rp+1                    /* row of product                    */
      cp=0                       /* column of product                 */
      Do ca=1 To acols
        x=x.a.ra.ca
        Do cb=1 To bcols
          y=x.b.rb.cb
          cp=cp+1                /* column of product                 */
          xy=x*y
          x.what.rp.cp=xy        /* element of product                */
          w=max(w,length(xy))
          End /* cB */
        End /* cA */
      End /* rB */
    End /* rA */
  Return
/*--------------------------------------------------------------------*/
showmat:
  Parse Arg what,size .
  Parse Var size rows 'X' cols
  z='+'
  b6=left('',6)
  Say ''
  Say b6 copies('-',7) 'matrix' what copies('-',7)
  Say b6 b6 '+'copies('-',cols*(w+1)+1)'+'
  Do r=1 To rows
    line='|' right(x.what.r.1,w)    /* element of first column        */                       /* start with long vertical bar   */
    Do c=2 To cols                  /* loop for other columns         */
      line=line right(x.what.r.c,w) /* append the elements            */
      End /* c */
    Say b6 b6 line '|'              /* append a long vertical bar.    */
    End /* r */
  Say b6 b6 '+'copies('-',cols*(w+1)+1)'+'
  Return
output   when using the default inputs:
       ------- matrix A -------
              +-----+
              | 1 2 |
              | 3 4 |
              +-----+

       ------- matrix B -------
              +-----+
              | 0 5 |
              | 6 7 |
              +-----+

       ------- matrix Kronecker product -------
              +-------------+
              |  0  5  0 10 |
              |  6  7 12 14 |
              |  0 15  0 20 |
              | 18 21 24 28 |
              +-------------+

|||||||||||||||||||||||||||||||||||||||||||||||||||||||


       ------- matrix A -------
              +-------+
              | 0 1 0 |
              | 1 1 1 |
              | 0 1 0 |
              +-------+

       ------- matrix B -------
              +---------+
              | 1 1 1 1 |
              | 1 0 0 1 |
              | 1 1 1 1 |
              +---------+

       ------- matrix Kronecker product -------
              +-------------------------+
              | 0 0 0 0 1 1 1 1 0 0 0 0 |
              | 0 0 0 0 1 0 0 1 0 0 0 0 |
              | 0 0 0 0 1 1 1 1 0 0 0 0 |
              | 1 1 1 1 1 1 1 1 1 1 1 1 |
              | 1 0 0 1 1 0 0 1 1 0 0 1 |
              | 1 1 1 1 1 1 1 1 1 1 1 1 |
              | 0 0 0 0 1 1 1 1 0 0 0 0 |
              | 0 0 0 0 1 0 0 1 0 0 0 0 |
              | 0 0 0 0 1 1 1 1 0 0 0 0 |
              +-------------------------+ 

Ring

# Project : Kronecker product

a = [[1, 2], [3, 4]]
b = [[0, 5], [6, 7]]
la1 = 1
ua1 = 2
la2 = 1
ua2 = 2
lb1 = 1
ub1 = 2
lb2 = 1
ub2 = 2
kroneckerproduct(a,b)
see nl

la1 = 1
ua1 = 3
la2 = 1
ua2 = 3
lb1 = 1
ub1 = 3
lb2 = 1
ub2 = 3
x = [[0, 1, 0], [1, 1, 1], [0, 1, 0]]
y = [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]]
kroneckerproduct(x, y)

func kroneckerproduct(a,b)
 

for i = la1 to ua1
      for k = lb1 to ub1
            see "["
            for j = la2 to ua2
                 for l = lb2 to ub2
                       see a[i][j] * b[k][l] 
                       if j = ua1 and l = ub2
                          see "]" + nl
                       else
                          see " "
                       ok
                 next
            next
      next
next

Output:

[0 5 0 10]
[6 7 12 14]
[0 15 0 20]
[18 21 24 28]

[0 0 0 1 1 1 0 0 0]
[0 0 0 1 0 0 0 0 0]
[0 0 0 1 1 1 0 0 0]
[1 1 1 1 1 1 1 1 1]
[1 0 0 1 0 0 1 0 0]
[1 1 1 1 1 1 1 1 1]
[0 0 0 1 1 1 0 0 0]
[0 0 0 1 0 0 0 0 0]
[0 0 0 1 1 1 0 0 0]


RPL

Works with: Halcyon Calc version 4.2.7
≪ DUP SIZE LIST→ DROP 4 ROLL DUP SIZE LIST→ DROP → b p q a m n 
  ≪ {} m p * + n q * + 0 CON
     1 m p * FOR row
        1 n q * FOR col
           a {} row 1 - p / IP 1 + + col 1 - q / IP 1 + + GET
           b {} row 1 - p MOD 1 + + col 1 - q MOD 1 + + GET
           * {} row + col + SWAP PUT
     NEXT NEXT
≫ ≫ 'KROKR' STO

HP-49 version

≪ DUP SIZE LIST→ DROP 4 PICK SIZE LIST→ DROP → a b rb cb ra ca 
  ≪ a SIZE b SIZE * 0 CON
     0 ra 1 - FOR j
        0 ca 1 - FOR k
           { 1 1 } 
           { } j + k +
           DUP2 ADD a SWAP GET UNROT
           { } ra + ca + * ADD
           SWAP b * REPL
     NEXT NEXT
≫ ≫ 'KROKR' STO
[[1, 2], [3, 4]]  [[0, 5], [6, 7]] KROKR
[[0, 1, 0], [1, 1, 1], [0, 1, 0]]  [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 1, 1]] KROKR
Output:
2: [[ 0 5 0 10 ] 
    [ 6 7 12 14 ] 
    [ 0 15 0 20 ] 
    [ 18 21 24 28 ]]
1: [[ 0 0 0 0 1 1 1 1 0 0 0 0 ] 
    [ 0 0 0 0 1 0 0 1 0 0 0 0 ] 
    [ 0 0 0 0 1 1 1 1 0 0 0 0 ] 
    [ 1 1 1 1 1 1 1 1 1 1 1 1 ] 
    [ 1 0 0 1 1 0 0 1 1 0 0 1 ] 
    [ 1 1 1 1 1 1 1 1 1 1 1 1 ] 
    [ 0 0 0 0 1 1 1 1 0 0 0 0 ] 
    [ 0 0 0 0 1 0 0 1 0 0 0 0 ] 
    [ 0 0 0 0 1 1 1 1 0 0 0 0 ]]

Rust

fn main() {

    let mut a = vec![vec![1., 2.], vec![3., 4.]];
    let mut b = vec![vec![0., 5.], vec![6., 7.]];

    let mut a_ref = &mut a;
    let a_rref = &mut a_ref;

    let mut b_ref = &mut b;
    let b_rref = &mut b_ref;

    let ab = kronecker_product(a_rref, b_rref);

    println!("Kronecker product of\n");
    for i in a {
        println!("{:?}", i);
    }
    println!("\nand\n");
    for i in b {
        println!("{:?}", i);
    }
    println!("\nis\n");
    for i in ab {
        println!("{:?}", i);
    }

    println!("\n\n");

    let mut a = vec![vec![0., 1., 0.],
                    vec![1., 1., 1.],
                    vec![0., 1., 0.]];
    let mut b = vec![vec![1., 1., 1., 1.],
                    vec![1., 0., 0., 1.],
                    vec![1., 1., 1., 1.]];

    let mut a_ref = &mut a;
    let a_rref = &mut a_ref;

    let mut b_ref = &mut b;
    let b_rref = &mut b_ref;

    let ab = kronecker_product(a_rref, b_rref);

    println!("Kronecker product of\n");
    for i in a {
        println!("{:?}", i);
    }
    println!("\nand\n");
    for i in b {
        println!("{:?}", i);
    }
    println!("\nis\n");
    for i in ab {
        println!("{:?}", i);
    }

    println!("\n\n");

}

fn kronecker_product(a: &mut Vec<Vec<f64>>, b: &mut Vec<Vec<f64>>) -> Vec<Vec<f64>> {
    let m = a.len();
    let n = a[0].len();
    let p = b.len();
    let q = b[0].len();
    let rtn = m * p;
    let ctn = n * q;

    let mut r = zero_matrix(rtn, ctn);

    for i in 0..m {
        for j in 0..n {
            for k in 0..p {
                for l in 0..q {
                    r[p * i + k][q * j + l] = a[i][j] * b[k][l];
                }
            }
        }
    }
    r
}

fn zero_matrix(rows: usize, cols: usize) -> Vec<Vec<f64>> {
    let mut matrix = Vec::with_capacity(cols);
    for _ in 0..rows {
        let mut col: Vec<f64> = Vec::with_capacity(rows);
        for _ in 0..cols {
            col.push(0.0);
        }
        matrix.push(col);
    }
    matrix
}
Output:
Kronecker product of

[1.0, 2.0]
[3.0, 4.0]

and

[0.0, 5.0]
[6.0, 7.0]

is

[0.0, 5.0, 0.0, 10.0]
[6.0, 7.0, 12.0, 14.0]
[0.0, 15.0, 0.0, 20.0]
[18.0, 21.0, 24.0, 28.0]



Kronecker product of

[0.0, 1.0, 0.0]
[1.0, 1.0, 1.0]
[0.0, 1.0, 0.0]

and

[1.0, 1.0, 1.0, 1.0]
[1.0, 0.0, 0.0, 1.0]
[1.0, 1.0, 1.0, 1.0]

is

[0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
[1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0]
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
[0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]



Scala

 object KroneckerProduct
{
  /**Get the dimensions of the input matrix*/
  def getDimensions(matrix : Array[Array[Int]]) : (Int,Int) = {
    val dimensions = matrix.map(x => x.size)
    (dimensions.size, dimensions(0))
  }

  /**Compute the Kronecker product between 2 input matrixes and return the result as a matrix*/
  def kroneckerProduct(matrix1 : Array[Array[Int]], matrix2 : Array[Array[Int]]) : Array[Array[Int]] = {
    val (r1,c1) = getDimensions(matrix1)
    val (r2,c2) = getDimensions(matrix2)

    val res = Array.ofDim[Int](r1*r2, c1*c2)

    for(
      i <- 0 until r1;
      j <- 0 until c1;
      k <- 0 until r2;
      l <- 0 until c2
    ){
      res(r2 * i + k)(c2 * j + l) = matrix1(i)(j) * matrix2(k)(l)
    }

    res
  }

  def main(args: Array[String]): Unit = {
    val m1 = Array(Array(1, 2), Array(3, 4))
    val m2 = Array(Array(0, 5), Array(6, 7))
    println(kroneckerProduct(m1,m2).map(_.mkString("|")).mkString("\n"))

    println("----------")

    val m3 = Array(Array(0, 1, 0), Array(1, 1, 1), Array(0, 1, 0))
    val m4 = Array(Array(1, 1, 1, 1), Array(1, 0, 0, 1), Array(1, 1, 1, 1))
    println(kroneckerProduct(m3,m4).map(_.mkString("|")).mkString("\n"))
  }

}
Output:
0|5|0|10
6|7|12|14
0|15|0|20
18|21|24|28
----------
0|0|0|0|1|1|1|1|0|0|0|0
0|0|0|0|1|0|0|1|0|0|0|0
0|0|0|0|1|1|1|1|0|0|0|0
1|1|1|1|1|1|1|1|1|1|1|1
1|0|0|1|1|0|0|1|1|0|0|1
1|1|1|1|1|1|1|1|1|1|1|1
0|0|0|0|1|1|1|1|0|0|0|0
0|0|0|0|1|0|0|1|0|0|0|0
0|0|0|0|1|1|1|1|0|0|0|0

Sidef

Translation of: Raku
func kronecker_product(a, b) {
    a ~X b -> map { _[0] ~X* _[1] }
}

kronecker_product([[1, 2], [3, 4]],
                  [[0, 5], [6, 7]]).each { .say }

say ''
kronecker_product([[0,1,0],  [1,1,1],   [0,1,0]],
                  [[1,1,1,1],[1,0,0,1], [1,1,1,1]]).each { .say }
Output:
[0, 5, 0, 10]
[6, 7, 12, 14]
[0, 15, 0, 20]
[18, 21, 24, 28]

[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]

Simula

BEGIN

    PROCEDURE OUTMATRIX(A, W); INTEGER ARRAY A; INTEGER W;
    BEGIN
        INTEGER I, J;
        INTEGER LA1, UA1;
        INTEGER LA2, UA2;

        LA1 := LOWERBOUND(A, 1); UA1 := UPPERBOUND(A, 1);
        LA2 := LOWERBOUND(A, 2); UA2 := UPPERBOUND(A, 2);

        FOR I := LA1 STEP 1 UNTIL UA1 DO
        BEGIN
            OUTTEXT("[");
            FOR J := LA2 STEP 1 UNTIL UA2 DO
            BEGIN
                IF NOT (J = LA2) THEN OUTCHAR(' ');
                OUTINT(A(I, J), W)
            END;
            OUTTEXT("]");
            OUTIMAGE
        END
    END OUTMATRIX;

    PROCEDURE KRONECKERPRODUCT(A, B, C); INTEGER ARRAY A, B, C;
    BEGIN
        INTEGER I, J, K, L, CI, CJ;
        INTEGER LA1, UA1;
        INTEGER LA2, UA2;
        INTEGER LB1, UB1;
        INTEGER LB2, UB2;

        LA1 := LOWERBOUND(A, 1); UA1 := UPPERBOUND(A, 1);
        LA2 := LOWERBOUND(A, 2); UA2 := UPPERBOUND(A, 2);
        LB1 := LOWERBOUND(B, 1); UB1 := UPPERBOUND(B, 1);
        LB2 := LOWERBOUND(B, 2); UB2 := UPPERBOUND(B, 2);

        CI := 1;
        FOR I := LA1 STEP 1 UNTIL UA1 DO
            FOR K := LB1 STEP 1 UNTIL UB1 DO
            BEGIN
                CJ := 1;
                FOR J := LA2 STEP 1 UNTIL UA2 DO
                    FOR L := LB2 STEP 1 UNTIL UB2 DO
                    BEGIN
                        C(CI, CJ) := A(I, J) * B(K, L);
                        CJ := CJ + 1
                    END;
                CI := CI + 1
            END
    END KRONECKERPRODUCT;
     
    ! --- EXAMPLE 1 --- ;
    BEGIN
        INTEGER ARRAY A(1:2, 1:2);
        INTEGER ARRAY B(1:2, 1:2);
        INTEGER ARRAY C(1:4, 1:4);

         
        ! {{1, 2}, {3, 4}} ;

        A(1, 1) := 1;
        A(1, 2) := 2;

        A(2, 1) := 3;
        A(2, 2) := 4;

        ! {{0, 5}, {6, 7}} ;

        B(1, 1) := 0;
        B(1, 2) := 5;

        B(2, 1) := 6;
        B(2, 2) := 7;

        OUTMATRIX(A, 2); OUTTEXT("   *"); OUTIMAGE;
        OUTMATRIX(B, 2); OUTTEXT("   ="); OUTIMAGE;

        KRONECKERPRODUCT(A, B, C);

        OUTMATRIX(C, 2); OUTIMAGE

        ! OUTPUT:

        ! [ 0  5  0 10]
        ! [ 6  7 12 14]
        ! [ 0 15  0 20]
        ! [18 21 24 28] ;

    END EXAMPLE 1;

    ! --- EXAMPLE 2 --- ;
    BEGIN
        INTEGER ARRAY X(1:3, 1:3);
        INTEGER ARRAY Y(1:3, 1:4);
        INTEGER ARRAY C(1:9, 1:12);

        ! {{0, 1, 0}, {1, 1, 1}, {0, 1, 0}} ;

        X(1,1) := 0;
        X(1,2) := 1;
        X(1,3) := 0;

        X(2,1) := 1;
        X(2,2) := 1;
        X(2,3) := 1;

        X(3,1) := 0;
        X(3,2) := 1;
        X(3,3) := 0;

       ! {{1, 1, 1, 1}, {1, 0, 0, 1}, {1, 1, 1, 1}} ;

        Y(1,1) := 1;
        Y(1,2) := 1;
        Y(1,3) := 1;
        Y(1,4) := 1;

        Y(2,1) := 1;
        Y(2,2) := 0;
        Y(2,3) := 0;
        Y(2,4) := 1;

        Y(3,1) := 1;
        Y(3,2) := 1;
        Y(3,3) := 1;
        Y(3,4) := 1;

        OUTIMAGE;

        OUTMATRIX(X, 1); OUTTEXT("   *"); OUTIMAGE;
        OUTMATRIX(Y, 1); OUTTEXT("   ="); OUTIMAGE;

        KRONECKERPRODUCT(X, Y, C);

        OUTMATRIX(C, 1); OUTIMAGE;
     
        ! OUTPUT:

        ! [0 0 0 0 1 1 1 1 0 0 0 0]
        ! [0 0 0 0 1 0 0 1 0 0 0 0]
        ! [0 0 0 0 1 1 1 1 0 0 0 0]
        ! [1 1 1 1 1 1 1 1 1 1 1 1]
        ! [1 0 0 1 1 0 0 1 1 0 0 1]
        ! [1 1 1 1 1 1 1 1 1 1 1 1]
        ! [0 0 0 0 1 1 1 1 0 0 0 0]
        ! [0 0 0 0 1 0 0 1 0 0 0 0]
        ! [0 0 0 0 1 1 1 1 0 0 0 0] ;

    END EXAMPLE 2;
END
Output:
[ 1  2]
[ 3  4]
   *
[ 0  5]
[ 6  7]
   =
[ 0  5  0 10]
[ 6  7 12 14]
[ 0 15  0 20]
[18 21 24 28]


[0 1 0]
[1 1 1]
[0 1 0]
   *
[1 1 1 1]
[1 0 0 1]
[1 1 1 1]
   =
[0 0 0 0 1 1 1 1 0 0 0 0]
[0 0 0 0 1 0 0 1 0 0 0 0]
[0 0 0 0 1 1 1 1 0 0 0 0]
[1 1 1 1 1 1 1 1 1 1 1 1]
[1 0 0 1 1 0 0 1 1 0 0 1]
[1 1 1 1 1 1 1 1 1 1 1 1]
[0 0 0 0 1 1 1 1 0 0 0 0]
[0 0 0 0 1 0 0 1 0 0 0 0]
[0 0 0 0 1 1 1 1 0 0 0 0]

Stata

In Mata, the Kronecker product is the operator #.

. mata
------------------------------------------------- mata (type end to exit) ----------
: a=1,2\3,4

: b=0,5\6,7

: a#b
        1    2    3    4
    +---------------------+
  1 |   0    5    0   10  |
  2 |   6    7   12   14  |
  3 |   0   15    0   20  |
  4 |  18   21   24   28  |
    +---------------------+

: a=0,1,0\1,1,1\0,1,0

: b=1,1,1,1\1,0,0,1\1,1,1,1

: a#b
        1    2    3    4    5    6    7    8    9   10   11   12
    +-------------------------------------------------------------+
  1 |   0    0    0    0    1    1    1    1    0    0    0    0  |
  2 |   0    0    0    0    1    0    0    1    0    0    0    0  |
  3 |   0    0    0    0    1    1    1    1    0    0    0    0  |
  4 |   1    1    1    1    1    1    1    1    1    1    1    1  |
  5 |   1    0    0    1    1    0    0    1    1    0    0    1  |
  6 |   1    1    1    1    1    1    1    1    1    1    1    1  |
  7 |   0    0    0    0    1    1    1    1    0    0    0    0  |
  8 |   0    0    0    0    1    0    0    1    0    0    0    0  |
  9 |   0    0    0    0    1    1    1    1    0    0    0    0  |
    +-------------------------------------------------------------+
: end

SuperCollider

// the iterative version is derived from the javascript one here:
(
f = { |a, b|
	var m = a.size;
	var n = a[0].size;
	var p = b.size;
	var q = b[0].size;
	var rtn = m * p;
	var ctn = n * q;
	var res = { 0.dup(ctn) }.dup(rtn);
	m.do { |i|
		n.do { |j|
			p.do { |k|
				q.do { |l|
					res[p*i+k][q*j+l] = a[i][j] * b[k][l];
				}
			}
		}
	};
	res
};
)

// Like APL/J, SuperCollider has applicative operators, so here is a shorter version.
// the idea is to first replace every element of b with its product with all of a
// and then reshape the matrix appropriately
// note that +++ is lamination: [[1, 2, 3], [4, 5, 6]] +++ [100, 200] returns [ [ 1, 2, 3, 100 ], [ 4, 5, 6, 200 ] ].

(
f = { |a, b|
	a.collect { |x|
		x.collect { |y| b * y }.reduce('+++')
	}.reduce('++')
}
)

// or shorter:
(a *.2 b).collect(_.reduce('+++')).reduce('++')
// to apply either of the two functions:
(
x = f.(
	[
		[0, 1, 0],
		[1, 1, 1],
		[0, 1, 0]
	],
	[
		[1, 1, 1, 1],
		[1, 0, 0, 1],
		[1, 1, 1, 1]
	]
)
)

Results in:

[ 
	[ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0 ], 
	[ 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0 ], 
	[ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0 ], 
	[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 
	[ 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1 ], 
	[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 
	[ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0 ], 
	[ 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0 ], 
	[ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0 ] 
]

And:

(
x = f.(
	[
		[ 1, 2 ],
		[ 3, 4 ]
	],
	[
		[ 0, 5 ],
		[ 6, 7 ]
	]
)
)

returns:

[ 
	[ 0, 5, 0, 10 ], 
	[ 6, 7, 12, 14 ], 
	[ 0, 15, 0, 20 ], 
	[ 18, 21, 24, 28 ] 
]

Swift

func kronecker(m1: [[Int]], m2: [[Int]]) -> [[Int]] {
  let m = m1.count
  let n = m1[0].count
  let p = m2.count
  let q = m2[0].count
  let rtn = m * p
  let ctn = n * q

  var res = Array(repeating: Array(repeating: 0, count: ctn), count: rtn)

  for i in 0..<m {
    for j in 0..<n {
      for k in 0..<p {
        for l in 0..<q {
          res[p * i + k][q * j + l] = m1[i][j] * m2[k][l]
        }
      }
    }
  }

  return res
}

func printMatrix<T>(_ matrix: [[T]]) {
  guard !matrix.isEmpty else {
    print()

    return
  }

  let rows = matrix.count
  let cols = matrix[0].count

  for i in 0..<rows {
    for j in 0..<cols {
      print(matrix[i][j], terminator: " ")
    }

    print()
  }
}


func printProducts(a: [[Int]], b: [[Int]]) {
  print("Matrix A:")
  printMatrix(a)
  print("Matrix B:")
  printMatrix(b)
  print("kronecker a b:")
  printMatrix(kronecker(m1: a, m2: b))
  print()
}

let a = [
  [1, 2],
  [3, 4]
]

let b = [
  [0, 5],
  [6, 7]
]

printProducts(a: a, b: b)

let a2 = [
  [0, 1, 0],
  [1, 1, 1],
  [0, 1, 0]
]

let b2 = [
  [1, 1, 1, 1],
  [1, 0, 0, 1],
  [1, 1, 1, 1]
]

printProducts(a: a2, b: b2)
Output:
Matrix A:
1 2 
3 4 
Matrix B:
0 5 
6 7 
kronecker a b:
0 5 0 10 
6 7 12 14 
0 15 0 20 
18 21 24 28 

Matrix A:
0 1 0 
1 1 1 
0 1 0 
Matrix B:
1 1 1 1 
1 0 0 1 
1 1 1 1 
kronecker a b:
0 0 0 0 1 1 1 1 0 0 0 0 
0 0 0 0 1 0 0 1 0 0 0 0 
0 0 0 0 1 1 1 1 0 0 0 0 
1 1 1 1 1 1 1 1 1 1 1 1 
1 0 0 1 1 0 0 1 1 0 0 1 
1 1 1 1 1 1 1 1 1 1 1 1 
0 0 0 0 1 1 1 1 0 0 0 0 
0 0 0 0 1 0 0 1 0 0 0 0 
0 0 0 0 1 1 1 1 0 0 0 0 

Tcl

# some helpers for matrices in nice string form:
proc parse_matrix {s} {
    split [string trim $s] \n
}

proc print_matrix {m} {
    foreach row $m {
        puts [join [lmap x $row {format %3s $x}]]
    }
}

# obvious imperative version using [foreach]
proc kroenecker {A B} {
    foreach arow $A {
        foreach brow $B {
            set row {}
            foreach a $arow {
                foreach b $brow {
                    lappend row [expr {$a * $b}]
                }
            }
            lappend result $row
        }
    }
    return $result
}

proc lolcat {args} {    ;# see https://wiki.tcl.tk/41507
    concat {*}[uplevel 1 lmap $args]
}                                           

# more compact but obtuse, using [lmap] and [lolcat]
proc kroenecker {A B} {
    lolcat arow $A { 
        lmap brow $B {
            lolcat a $arow {
                lmap b $brow {
                    expr {$a * $b}
                }
            }
        }
    }
}

# demo:
set inputs {
    {1 2
     3 4}
    {0 5
     6 7}

    {0 1 0
     1 1 1
     0 1 0}
    {1 1 1 1
     1 0 0 1
     1 1 1 1}
}

foreach {a b} $inputs {
    set a [parse_matrix $a]
    set b [parse_matrix $b]
    print_matrix [kroenecker $a $b]
    puts ""
}
Output:
  0   5   0  10
  6   7  12  14
  0  15   0  20
 18  21  24  28
  
  0   0   0   0   1   1   1   1   0   0   0   0
  0   0   0   0   1   0   0   1   0   0   0   0
  0   0   0   0   1   1   1   1   0   0   0   0
  1   1   1   1   1   1   1   1   1   1   1   1
  1   0   0   1   1   0   0   1   1   0   0   1
  1   1   1   1   1   1   1   1   1   1   1   1
  0   0   0   0   1   1   1   1   0   0   0   0
  0   0   0   0   1   0   0   1   0   0   0   0
  0   0   0   0   1   1   1   1   0   0   0   0

VBScript

' Kronecker product - 05/04/2017 ' array boundary iteration corrections 06/13/2023
dim a(),b(),r()
 
sub kroneckerproduct '(a,b)
    m=ubound(a,1): n=ubound(a,2)
    p=ubound(b,1): q=ubound(b,2)
    rtn=m*p
    ctn=n*q
    redim r(rtn,ctn) 
    for i=1 to m
        for j=1 to n
            for k=1 to p
                for l=1 to q
                    r(p*(i-1)+k,q*(j-1)+l)=a(i,j)*b(k,l)  
    next: next: next: next
end sub 'kroneckerproduct
 
Private Sub printmatrix(text, m, w)
    wscript.stdout.writeline text
    Dim myArr()
    Select Case m
        Case "a": myArr = a()
        Case "b": myArr = b()
        Case "r": myArr = r()
    End Select
    For i = LBound(myArr, 1) To UBound(myArr, 1)
        text = vbNullString
        For j = LBound(myArr, 2) To UBound(myArr, 2)
            Select Case m
                Case "a": k = a(i, j)
                Case "b": k = b(i, j)
                Case "r": k = r(i, j)
            End Select
            text = text & " " & k
        Next
        wscript.stdout.writeline text
    Next
End Sub 'printmatrix

sub printall(w)
    printmatrix "matrix a:", "a", w 
    printmatrix "matrix b:", "b", w 
    printmatrix "kronecker product:", "r", w  
end sub 'printall
 
sub main()
    xa = Array(1, 2, _
               3, 4)
    ReDim a(LBound(xa, 1) To LBound(xa, 1) + 1, LBound(xa, 1) To LBound(xa, 1) + 1)
    k = LBound(a, 1)
    For i = LBound(a, 1) To UBound(a, 1): For j = LBound(a, 1) To UBound(a, 1)
        a(i, j) = xa(k): k = k + 1
    Next: Next
    xb = Array(0, 5, _
               6, 7)
    ReDim b(LBound(xb, 1) To LBound(xb, 1) + 1, LBound(xb, 1) To LBound(xb, 1) + 1)
    k = LBound(b, 1)
    For i = LBound(b, 1) To UBound(b, 1): For j = LBound(b, 2) To UBound(b, 2)
        b(i, j) = xb(k): k = k + 1
    Next: Next
    kroneckerproduct
    printall 3

    xa = Array(0, 1, 0, _
               1, 1, 1, _
               0, 1, 0)
    ReDim a(LBound(xa, 1) To LBound(xa, 1) + 2, LBound(xa, 1) To LBound(xa, 1) + 2)
    k = LBound(a, 1)
    For i = LBound(a, 1) To UBound(a, 1): For j = LBound(a, 1) To UBound(a, 1)
        a(i, j) = xa(k): k = k + 1
    Next: Next
    xb = Array(1, 1, 1, 1, _
               1, 0, 0, 1, _
               1, 1, 1, 1)
    ReDim b(LBound(xb, 1) To LBound(xb, 1) + 2, LBound(xb, 1) To LBound(xb, 1) + 3)
    k = LBound(b, 1)
    For i = LBound(b, 1) To UBound(b, 1): For j = LBound(b, 2) To UBound(b, 2)
        b(i, j) = xb(k): k = k + 1
    Next: Next

    kroneckerproduct
    printall 2
end sub 'main

main
Output:
matrix a:
  1  2
  3  4
matrix b:
  0  5
  6  7
kronecker product:
  0  5  0 10
  6  7 12 14
  0 15  0 20
 18 21 24 28

matrix a:
 0 1 0
 1 1 1
 0 1 0
matrix b:
 1 1 1 1
 1 0 0 1
 1 1 1 1
kronecker product:
 0 0 0 0 1 1 1 1 0 0 0 0
 0 0 0 0 1 0 0 1 0 0 0 0
 0 0 0 0 1 1 1 1 0 0 0 0
 1 1 1 1 1 1 1 1 1 1 1 1
 1 0 0 1 1 0 0 1 1 0 0 1
 1 1 1 1 1 1 1 1 1 1 1 1
 0 0 0 0 1 1 1 1 0 0 0 0
 0 0 0 0 1 0 0 1 0 0 0 0
 0 0 0 0 1 1 1 1 0 0 0 0

Wren

Library: Wren-fmt
Library: Wren-matrix

The above module already includes a method to calculate the Kronecker product.

import "./fmt" for Fmt
import "./matrix" for Matrix

var a1 = [
    [1, 2],
    [3, 4]
]

var a2 =  [
    [0, 5],
    [6, 7]
]

var a3 = [
    [0, 1, 0],
    [1, 1, 1],
    [0, 1, 0]
]

var a4 = [
    [1, 1, 1, 1],
    [1, 0, 0, 1],
    [1, 1, 1, 1]
]

var m1 = Matrix.new(a1)
var m2 = Matrix.new(a2)
Fmt.mprint(m1.kronecker(m2), 2, 0)
System.print()
var m3 = Matrix.new(a3)
var m4 = Matrix.new(a4)
Fmt.mprint(m3.kronecker(m4), 2, 0)
Output:
| 0  5  0 10|
| 6  7 12 14|
| 0 15  0 20|
|18 21 24 28|

| 0  0  0  0  1  1  1  1  0  0  0  0|
| 0  0  0  0  1  0  0  1  0  0  0  0|
| 0  0  0  0  1  1  1  1  0  0  0  0|
| 1  1  1  1  1  1  1  1  1  1  1  1|
| 1  0  0  1  1  0  0  1  1  0  0  1|
| 1  1  1  1  1  1  1  1  1  1  1  1|
| 0  0  0  0  1  1  1  1  0  0  0  0|
| 0  0  0  0  1  0  0  1  0  0  0  0|
| 0  0  0  0  1  1  1  1  0  0  0  0|

zkl

var [const] GSL=Import.lib("zklGSL");    // libGSL (GNU Scientific Library)
fcn kronecker(A,B){
   m,n, p,q := A.rows,A.cols, B.rows,B.cols;
   r:=GSL.Matrix(m*p, n*q);
   foreach i,j,k,l in (m,n,p,q){ r[p*i + k, q*j + l]=A[i,j]*B[k,l] }
   r
}
A:=GSL.Matrix(2,2).set(1,2, 3,4);
B:=GSL.Matrix(2,2).set(0,5, 6,7);
kronecker(A,B).format(3,0).println();	// format(width,precision)

A:=GSL.Matrix(3,3).set(0,1,0, 
		       1,1,1, 
		       0,1,0);
B:=GSL.Matrix(3,4).set(1,1,1,1, 
		       1,0,0,1, 
		       1,1,1,1);
kronecker(A,B).format(2,0).println();
Output:
  0,  5,  0, 10
  6,  7, 12, 14
  0, 15,  0, 20
 18, 21, 24, 28
 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0
 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0
 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0
 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0
 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0