Kronecker product: Difference between revisions

{{trans|Python}}

 

V b1 = [[0, 5], [6, 7]]

 

V result2 = kronecker(a2, b2)

L(elem) result2

 

{{out}}

 

=={{header|360 Assembly}}==

KRONECK CSECT

USING KRONECK,R13 base register

R DS (NR*NR)F r(nr,nr)

YREGS

{{out}}

<pre>

The user must type in the monitor the following command after compilation and before running the program!<pre>SET EndProg=*</pre>

{{libheader|Action! Tool Kit}}

 

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

Test1()

Test2()

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Kronecker_product.png Screenshot from Atari 8-bit computer]

{{works with|Ada|Ada|83}}

 

with Ada.Integer_Text_IO;

 

Ada.Text_IO.New_Line;

end loop;

{{out}}

<pre> 0 5 0 10

 

=={{header|ALGOL 68}}==

# multiplies in-place the elements of the matrix a by the scaler b #

OP *:= = ( REF[,]INT a, INT b )REF[,]INT:

)

END

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

 

{{out}}

└─────┴───────┴───────────────────────┘</pre>

=={{header|AppleScript}}==

 

-- kprod :: [[Num]] -> [[Num]] -> [[Num]]

on unlines(xs)

intercalate(linefeed, xs)

{{Out}}

<pre>{0, 5, 0, 10}

=={{header|Arturo}}==

{{trans|Kotlin}}

print: [

result: ""

 

print "Kronecker Product:"

 

{{out}}

 

=={{header|AutoHotkey}}==

prod := [], r:= 1, c := 1

for i, aa in a

}

return prod

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

P := KroneckerProduct(a, b)

MsgBox % result

return

{{out}}

<pre>0 5 0 10

 

=={{header|AWK}}==

# syntax: GAWK -f KRONECKER_PRODUCT.AWK

BEGIN {

return(n)

}

{{out}}

<pre>

=={{header|BQN}}==

 

 

or

 

 

Example:

 

r ← >⟨0‿5, 6‿7⟩

 

 

<pre>

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>

printf("\n\n\nKronecker product of the two matrices written to %s.",output);

}

 

Input file :

 

=={{header|C sharp}}==

using System.Collections;

using System.Collections.Generic;

}

 

{{out}}

<pre>

 

=={{header|C++}}==

#include <iomanip>

#include <iostream>

test2();

return 0;

 

{{out}}

=={{header|D}}==

{{Trans|Go}}

import std.stdio, std.outbuffer;

 

sample(C,D);

}

 

Output:

=={{header|Factor}}==

{{works with|Factor|0.99 2020-01-23}}

 

{ { 1 2 } { 3 4 } }

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

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

{{out}}

<pre>

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 <code>A(3:7,9:12)</code> 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.

 

CONTAINS !For the specific problem only.

SUBROUTINE KPRODUCT(A,B,AB) !AB = Kronecker product of A and B, both two-dimensional arrays.

CALL SHOW (6,AB)

 

 

Output:

</pre>

 

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>[ 0 5 0 10]

=={{header|Frink}}==

The Frink library [https://frinklang.org/fsp/colorize.fsp?f=Matrix.frink 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.

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

println[formatProd[a,b]]

return n

{{out}}

<pre>

=={{header|Go}}==

===Implementation===

 

import (

{1, 1, 1, 1},

})

{{out}}

<pre>

 

===Library go.matrix===

 

import (

{1, 1, 1, 1},

})))

{{out}}

<pre>

===Library gonum/matrix===

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

 

import (

1, 1, 1, 1,

}))))

{{out}}

<pre>

 

=={{header|Haskell}}==

 

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

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

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

{{Out}}

<pre>[0,5,0,10]

Explicit implementation:

 

 

Tacit:

 

 

these definitions are functionally equivalent.

Task examples:

 

N=: (+4**)i.2 2

P=: -.0 2 6 8 e.~i.3 3

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

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

 

=={{header|Java}}==

 

package kronecker;

 

 

}

 

{{Output}}

====Version #1.====

{{Works with|Chrome}}

// matkronprod.js

// Prime function:

}

}

 

;Required tests:

<!-- KronProdTest.html -->

<html><head>

</head><body></body>

</html>

{{Output}} '''Console and page results'''

<pre>

{{trans|PARI/GP}}

{{Works with|Chrome}}

// matkronprod2.js

// Prime function:

}

}

;Required tests:

<!-- KronProdTest2.html -->

<html><head>

</head><body></body>

</html>

 

{{Output}} '''Console and page results'''

{{Trans|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';

 

// MAIN ---

console.log(main());

{{Out}}

<pre>[0,5,0,10]

=={{header|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.

 

# element-wise multiplication of a matrix by a number, "c"

| reduce range(0; a|length) as $i ([];

. + reduce range(0; $m) as $j ([];

 

Examples:

def left: [[ 1, 2], [3, 4]];

def right: [[ 0, 5], [6, 7]];

 

{{out}}

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

 

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]];

 

{{out}}

<pre>[[0,0,0,0,1,1,1,1,0,0,0,0],

 

=={{header|Julia}}==

 

# Julia has a builtin kronecker product function

for row in 1:size(k)[1]

println(k[row,:])

 

{{out}}

=={{header|Kotlin}}==

{{trans|JavaScript (Imperative #2)}}

 

typealias Matrix = Array<IntArray>

r = kroneckerProduct(a, b)

printAll(a, b, r)

 

{{out}}

 

=={{header|Lua}}==

function prod( a, b )

print( "\nPRODUCT:" )

b = { { 1, 1, 1, 1 }, { 1, 0, 0, 1 }, { 1, 1, 1, 1 } }

prod( a, b )

{{out}}

<pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

KroneckerProduct[{{0, 1, 0}, {1, 1, 1}, {0, 1, 0}},

{{out}}

<pre>0 5 0 10

Same as Kotlin but with a generic Matrix type.

 

 

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

echo "Matrix A:\n", A2

echo "Matrix B:\n", B2

 

{{out}}

 

=={{header|Octave}}==

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

 

=={{header|PARI/GP}}==

=== Version #1 ===

{{Works with|PARI/GP|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,]))}

matprows("Sample 2 result:",r);

}

{{Output}}

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

{{Works with|PARI/GP|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,]))}

matprows("Sample 2 result:",r);

}

{{Output}}

 

=={{header|Perl}}==

use strict;

use warnings;

print "B = $mat->[1]\n";

print "kron(A,B) = " . kron($mat->[0], $mat->[1]) . "\n";

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">kronecker</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">ar</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">),</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">kronecker</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">),{</span><span style="color: #004600;">pp_Nest</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #004600;">pp_IntFmt</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%2d"</span><span style="color: #0000FF;">})</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">kronecker</span><span style="color: #0000FF;">(</span><span style="color: #000000;">c</span><span style="color: #0000FF;">,</span><span style="color: #000000;">d</span><span style="color: #0000FF;">),{</span><span style="color: #004600;">pp_Nest</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

{{trans|Python}}

 

array final_list = ({});

array sub_list = ({});

 

return 0;

{{out}}

<pre>0 5 0 10

 

=={{header|PureBasic}}==

DataSection

Matrix_A_B_Dimension_Bsp1:

Bsp2_Matrix_A_B:

Restore Matrix_A_B_Dimension_Bsp2

{{out}}

<pre>Matrix A:

In Python, the numpy library has the [https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.kron.html kron] function. The following is an implementation for "bare" lists of lists.

 

 

# Sample 1

result2 = kronecker(a2, b2)

for elem in result2:

 

Result:

 

Code:

r = [[1, 2], [3, 4]]

s = [[0, 5], [6, 7]]

# Result 2

for row in kronecker(t, u):

 

===Version 3===

 

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

 

 

# Result 2

for row in kronecker(t, u):

{{Out}}

<pre>[0, 5, 0, 10]

=={{header|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}}

<pre>

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

 

 

(require math/array

(matrix [[1 1 1 1]

[1 0 0 1]

 

{{out}}

(formerly Perl 6)

{{works with|rakudo|2017.01-34-g700a077}}

return (@a X @b).map: { .[0].list X* .[1].list };

}

.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>]);

{{out}}

<pre>(0 5 0 10)

=={{header|REXX}}==

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

w= 0 /*W: max width of any matrix element. */

aMat= 2x2 1 2 3 4 /*define A matrix size and elements.*/

say $ $ _ '│' /*append a long vertical bar. */

end /*r*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

# Project : Kronecker product

 

next

next

Output:

<pre>

 

=={{header|Rust}}==

 

let mut a = vec![vec![1., 2.], vec![3., 4.]];

matrix

}

{{out}}

<pre>

 

=={{header|Scala}}==

{

/**Get the dimensions of the input matrix*/

}

 

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Raku}}

a ~X b -> map { _[0] ~X* _[1] }

}

say ''

kronecker_product([[0,1,0], [1,1,1], [0,1,0]],

{{out}}

<pre>

 

=={{header|Simula}}==

 

PROCEDURE OUTMATRIX(A, W); INTEGER ARRAY A; INTEGER W;

 

END EXAMPLE 2;

{{out}}

<pre>

In Mata, the Kronecker product is the operator '''#'''.

 

------------------------------------------------- mata (type end to exit) ----------

: a=1,2\3,4

9 | 0 0 0 0 1 1 1 1 0 0 0 0 |

+-------------------------------------------------------------+

 

=={{header|SuperCollider}}==

(

f = { |a, b|

(a *.2 b).collect(_.reduce('+++')).reduce('++')

 

 

(

x = f.(

)

)

 

Results in:

And:

 

x = f.(

[

)

)

 

returns:

=={{header|Swift}}==

 

let m = m1.count

let n = m1[0].count

]

 

 

{{out}}

 

=={{header|Tcl}}==

proc parse_matrix {s} {

split [string trim $s] \n

print_matrix [kroenecker $a $b]

puts ""

 

{{out}}

 

=={{header|VBScript}}==

dim a(),b(),r()

end sub 'main

 

{{out}}

<pre>

{{libheader|Wren-matrix}}

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

import "/matrix" for Matrix

 

var m3 = Matrix.new(a3)

var m4 = Matrix.new(a4)

 

{{out}}

 

=={{header|zkl}}==

fcn kronecker(A,B){

m,n, p,q := A.rows,A.cols, B.rows,B.cols;

foreach i,j,k,l in (m,n,p,q){ r[p*i + k, q*j + l]=A[i,j]*B[k,l] }

r

B:=GSL.Matrix(2,2).set(0,5, 6,7);

kronecker(A,B).format(3,0).println(); // format(width,precision)

1,0,0,1,

1,1,1,1);

{{out}}

<pre>