Matrix multiplication: Difference between revisions
Added Easylang
(add BQN) |
(Added Easylang) |
||
(37 intermediate revisions by 20 users not shown) | |||
Line 6:
They can be of any dimensions, so long as the number of columns of the first matrix is equal to the number of rows of the second matrix.
<br><br>
=={{header|11l}}==
{{trans|Nim}}
<syntaxhighlight lang="11l">F matrix_mul(m1, m2)
assert(m1[0].len == m2.len)
V r = [[0.0] * m2[0].len] * m1.len
L(j) 0 .< m1.len
L(i) 0 .< m2[0].len
V s = 0.0
L(k) 0 .< m2.len
s += m1[j][k] * m2[k][i]
r[j][i] = s
R r
F to_str(m)
V result = ‘([’
L(r) m
I result.len > 2
result ‘’= "]\n ["
L(val) r
result ‘’= ‘#5.2’.format(val)
R result‘])’
V a = [[1.0, 1.0, 1.0, 1.0],
[2.0, 4.0, 8.0, 16.0],
[3.0, 9.0, 27.0, 81.0],
[4.0, 16.0, 64.0, 256.0]]
V b = [[ 4.0, -3.0 , 4/3.0, -1/4.0],
[-13/3.0, 19/4.0, -7/3.0, 11/24.0],
[ 3/2.0, -2.0 , 7/6.0, -1/4.0],
[ -1/6.0, 1/4.0, -1/6.0, 1/24.0]]
print(to_str(a))
print(to_str(b))
print(to_str(matrix_mul(a, b)))
print(to_str(matrix_mul(b, a)))</syntaxhighlight>
{{out}}
<pre>
([ 1.00 1.00 1.00 1.00]
[ 2.00 4.00 8.00 16.00]
[ 3.00 9.00 27.00 81.00]
[ 4.00 16.00 64.00 256.00])
([ 4.00 -3.00 1.33 -0.25]
[ -4.33 4.75 -2.33 0.46]
[ 1.50 -2.00 1.17 -0.25]
[ -0.17 0.25 -0.17 0.04])
([ 1.00 0.00 -0.00 -0.00]
[ 0.00 1.00 -0.00 -0.00]
[ 0.00 0.00 1.00 0.00]
[ 0.00 0.00 0.00 1.00])
([ 1.00 0.00 0.00 0.00]
[ 0.00 1.00 -0.00 0.00]
[ 0.00 0.00 1.00 0.00]
[ 0.00 0.00 -0.00 1.00])
</pre>
=={{header|360 Assembly}}==
<
MATRIXRC CSECT Matrix multiplication
USING MATRIXRC,R13
Line 113 ⟶ 171:
W DS CL16
YREGS
END MATRIXRC</
{{out}}
<pre> 9 12 15
Line 119 ⟶ 177:
29 40 51
39 54 69</pre>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">INCLUDE "D2:PRINTF.ACT" ;from the Action! Tool Kit
DEFINE PTR="CARD"
TYPE Matrix=[
BYTE width,height
PTR data] ;INT ARRAY
PROC PrintMatrix(Matrix POINTER m)
BYTE i,j
INT ARRAY d
CHAR ARRAY s(10)
d=m.data
FOR j=0 TO m.height-1
DO
FOR i=0 TO m.width-1
DO
StrI(d(j*m.width+i),s)
PrintF("%2S ",s)
OD
PutE()
OD
RETURN
PROC Create(MATRIX POINTER m BYTE w,h INT ARRAY a)
m.width=w
m.height=h
m.data=a
RETURN
PROC MatrixMul(Matrix POINTER m1,m2,res)
BYTE i,j,k
INT ARRAY d1,d2,dres,sum
IF m1.width#m2.height THEN
Print("Invalid size of matrices for multiplication!")
Break()
FI
d1=m1.data
d2=m2.data
dres=res.data
res.width=m2.width
res.height=m1.height
FOR j=0 TO res.height-1
DO
FOR i=0 TO res.width-1
DO
sum=0
FOR k=0 TO m1.width-1
DO
sum==+d1(k+j*m1.width)*d2(i+k*m2.width)
OD
dres(j*res.width+i)=sum
OD
OD
RETURN
PROC Main()
MATRIX m1,m2,res
INT ARRAY
d1=[2 1 4 0 1 1],
d2=[6 3 65535 0 1 1 0 4 65534 5 0 2],
dres(8)
Put(125) PutE() ;clear the screen
Create(m1,3,2,d1)
Create(m2,4,3,d2)
Create(res,0,0,dres)
MatrixMul(m1,m2,res)
PrintMatrix(m1)
PutE() PrintE("multiplied by") PutE()
PrintMatrix(m2)
PutE() PrintE("equals") PutE()
PrintMatrix(res)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Matrix_multiplication.png Screenshot from Atari 8-bit computer]
<pre>
2 1 4
0 1 1
multiplied by
6 3 -1 0
1 1 0 4
-2 5 0 2
equals
5 27 -2 12
-1 6 0 6
</pre>
=={{header|Ada}}==
Ada has matrix multiplication predefined for any floating-point or complex type.
The implementation is provided by the standard library packages Ada.Numerics.Generic_Real_Arrays and Ada.Numerics.Generic_Complex_Arrays correspondingly. The following example illustrates use of real matrix multiplication for the type Float:
<
with Ada.Numerics.Real_Arrays; use Ada.Numerics.Real_Arrays;
Line 153 ⟶ 311:
begin
Put (A * B);
end Matrix_Product;</
{{out}}
<pre>
Line 162 ⟶ 320:
</pre>
The following code illustrates how matrix multiplication could be implemented from scratch:
<
type Matrix is array (Natural range <>, Natural range <>) of Float;
function "*" (Left, Right : Matrix) return Matrix;
Line 187 ⟶ 345:
return Temp;
end "*";
end Matrix_Ops;</
=={{header|ALGOL 68}}==
Line 195 ⟶ 353:
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}
An example of user defined Vector and Matrix Multiplication Operators:
<
INT default upb:=3;
MODE VECTOR = [default upb]FIELD;
Line 254 ⟶ 412:
exception index error:
putf(stand error, $x"Exception: index error."l$)
)</
{{out}}
<pre>
Line 363 ⟶ 521:
exception index error:
putf(stand error, $x"Exception: index error."l$)
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
main:
first matrix=0, second matrix=0,a=-1
{5,2},rand array(a),mulby(10),ceil, cpy(first matrix), puts,{"\n"},puts
{2,3},rand array(a),mulby(10),ceil, cpy(second matrix), puts,{"\n"},puts
{first matrix,second matrix},mat mul, println
exit(0)
</syntaxhighlight>
Alternatively, the follow code in macro-natural-Hopper:
<syntaxhighlight lang="amazing hopper">
#include <natural.h>
#include <hopper.h>
main:
get a matrix of '5,2' integer random numbers, remember it in 'first matrix' and put it with a newline
get a matrix of '2,3' integer random numbers, remember it in 'second matrix' and put it with a newline
now take 'first matrix', and take 'second matrix', and multiply it; then, print with a new line.
exit(0)
</syntaxhighlight>
{{out}}
<pre>
2 2
1 5
3 4
6 6
4 8
7 1 6
6 2 4
26 6 20
37 11 26
45 11 34
78 18 60
76 20 56
</pre>
=={{header|APL}}==
Matrix multiply in APL is just <tt>+.×</tt>. For example:
<
A ← ↑A*¨⊂A←⍳4 ⍝ Same A as in other examples (1 1 1 1⍪ 2 4 8 16⍪ 3 9 27 81,[0.5] 4 16 64 256)
Line 376 ⟶ 572:
0.00 1.00 0.00 0.00
0.00 0.00 1.00 0.00
0.00 0.00 0.00 1.00</
By contrast, A×B is for element-by-element multiplication of arrays of the same shape, and if they are simple elements, this is ordinary multiplication.
Line 392 ⟶ 588:
=={{header|AppleScript}}==
{{trans|JavaScript}}
<
-- matrixMultiply :: Num a => [[a]] -> [[a]] -> [[a]]
Line 550 ⟶ 746:
return lst
end tell
end zipWith</
{{Out}}
<
=={{header|Arturo}}==
<
loop m 'row -> print map row 'val [pad to :string .format:".2f" val 6]
print "--------------------------------"
Line 588 ⟶ 784:
printMatrix B
printMatrix multiply A B
printMatrix multiply B A</
{{out}}
Line 615 ⟶ 811:
=={{header|AutoHotkey}}==
ahk [http://www.autohotkey.com/forum/topic44657-150.html discussion]
<
, 1 2 ; entries separated by space or tab
, 2 3
Line 666 ⟶ 862:
}
}
}</
===Using Objects===
<
if (A[1].Count() <> B.Count())
return ["Dimension Error"]
Line 682 ⟶ 878:
}
return R
}</
Examples:<
, [3,4]
, [5,6]
Line 701 ⟶ 897:
Res .= (A_Index=1?"":"`t") col (Mod(A_Index,M[1].MaxIndex())?"":"`n")
return Trim(Res,"`n")
}</
{{out}}
<pre>9 12 15
Line 709 ⟶ 905:
=={{header|AWK}}==
<
# Separate matrices a and b by a blank line
BEGIN {
Line 762 ⟶ 958:
function max(m, n) {
return m > n ? m : n
}</
<p><b>Input:</b></p>
<pre>
Line 781 ⟶ 977:
{{works with|QuickBasic|4.5}}
{{trans|Java}}
<
IF (LEN(a,2) = LEN(b)) 'if valid dims
n = LEN(a,2)
Line 804 ⟶ 1,000:
ELSE
PRINT "invalid dimensions"
END IF</
==={{header|Applesoft BASIC}}===
A nine-liner that fits on one screen. The code and variable names are similar to [[#BASIC|BASIC]] with DATA from [[Full_BASIC|Full BASIC]].
<syntaxhighlight lang="gwbasic"> 1 FOR K = 0 TO 1:M = O:N = P: READ O,P: IF K THEN DIM B(O,P): IF N < > O THEN PRINT "INVALID DIMENSIONS": STOP
2 IF NOT K THEN DIM A(O,P)
3 FOR I = 1 TO O: FOR J = 1 TO P: IF K THEN READ B(I,J)
4 IF NOT K THEN READ A(I,J)
5 NEXT J,I,K: DIM AB(M,P): FOR I = 1 TO M: FOR J = 1 TO P: FOR K = 1 TO N:AB(I,J) = AB(I,J) + (A(I,K) * B(K,J)): NEXT K,J,I: FOR I = 1 TO M: FOR J = 1 TO P: PRINT MID$ (S$,1 + (J = 1),1)AB(I,J);:S$ = " " + CHR$ (13): NEXT J,I
10000 DATA4,2
10010 DATA1,2,3,4,5,6,7,8
20000 DATA2,3
20010 DATA1,2,3,4,5,6</syntaxhighlight>
===Full BASIC===
{{works with|Full BASIC}}
{{trans|BBC_BASIC}}
<
MAT READ matrix1
Line 822 ⟶ 1,030:
MAT product=matrix1*matrix2
MAT PRINT product</
{{out}}
<pre> 9 12 15
Line 833 ⟶ 1,041:
(assumes default lower bound of 0):
<
matrix1() = 1, 2, \
Line 851 ⟶ 1,059:
PRINT
NEXT
</syntaxhighlight>
{{out}}
<pre> 9 12 15
Line 861 ⟶ 1,069:
<code>Mul</code> is a matrix multiplication idiom from [https://mlochbaum.github.io/bqncrate/ BQNcrate.]
<
(>⟨
Line 871 ⟶ 1,079:
⟨5, 6, 7, 8⟩
⟨9, 10, 11, 12⟩
⟩</
╵ 20 23 26 29
56 68 80 92
92 113 134 155
┘</
[https://mlochbaum.github.io/BQN/try.html#code=TXVsIOKGkCAry53iiJjDl+KOiTHigL/iiJ4KCig+4p+oCiAg4p+oMSwgMiwgM+KfqQogIOKfqDQsIDUsIDbin6kKICDin6g3LCA4LCA54p+pCuKfqSkgTXVsID7in6gKICDin6gxLCAgMiwgIDMsIDTin6kKICDin6g1LCAgNiwgIDcsIDjin6kKICDin6g5LCAxMCwgMTEsIDEy4p+pCuKfqQo= Try It!]
=={{header|Burlesque}}==
<
blsq ) {{1 2}{3 4}{5 6}{7 8}}{{1 2 3}{4 5 6}}mmsp
9 12 15
Line 886 ⟶ 1,094:
29 40 51
39 54 69
</syntaxhighlight>
=={{header|C}}==
<syntaxhighlight lang="c">#include <stdio.h>
#define MAT_ELEM(rows,cols,r,c) (r*cols+c)
//Improve performance by assuming output matrices do not overlap with
//input matrices. If this is C++, use the __restrict extension instead
#ifdef __cplusplus
typedef double * const __restrict MAT_OUT_t;
#else
typedef double * const restrict MAT_OUT_t;
#endif
typedef const double * const MAT_IN_t;
static inline void mat_mult(
const int m,
const int n,
const int p,
MAT_IN_t a,
MAT_IN_t b,
MAT_OUT_t c)
{
for (int row=0; row<m; row++) {
for (int col=0; col<p; col++) {
c[MAT_ELEM(m,p,row,col)] = 0;
for (int i=0; i<n; i++) {
c[MAT_ELEM(m,p,row,col)] += a[MAT_ELEM(m,n,row,i)]*b[MAT_ELEM(n,p,i,col)];
}
}
}
}
static inline void mat_show(
const int m,
const int p,
MAT_IN_t a)
{
for (int row=0; row<m;row++) {
for (int col=0; col<p;col++) {
printf("\t%7.3f", a[MAT_ELEM(m,p,row,col)]);
}
putchar('\n');
}
}
int main(void)
{
double a[4*4] = {1, 1, 1, 1,
2, 4, 8, 16,
3, 9, 27, 81,
4, 16, 64, 256};
double b[4*3] = { 4.0, -3.0, 4.0/3,
-13.0/3, 19.0/4, -7.0/3,
-1.0/6, 1.0/4, -1.0/6};
double c[4*3] = {0};
mat_mult(4,4,3,a,b,c);
mat_show(4,3,c);
return 0;
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
Line 965 ⟶ 1,166:
This code should work with any version of the .NET Framework and C# language
==={{header|Class}}===
<syntaxhighlight lang="csharp">public class Matrix
{
int n;
Line 1,008 ⟶ 1,211:
return result;
}
}</
==={{header|Extension Method}}===
Implementation of matrix multiplication and matrix display for 2D arrays using an extension method
<syntaxhighlight lang="csharp">
public static class LinearAlgebra
{
public static double[,] Product(this double[,] a, double[,] b)
{
int na = a.GetLength(0), ma = a.GetLength(1);
int nb = b.GetLength(0), mb = b.GetLength(1);
if (ma != nb)
{
throw new ArgumentException("Incompatible Matrix Sizes.", nameof(b));
}
double[,] c = new double[na, mb];
for (int i = 0; i < na; i++)
{
for (int j = 0; j < mb; j++)
{
double sum = 0;
for (int k = 0; k < ma; k++)
{
sum += a[i, k] * b[k, j];
}
c[i, j] = sum;
}
}
return c;
}
public static string Show(this double[,] a, string formatting = "g4", int columnWidth = 12)
{
int na = a.GetLength(0), ma = a.GetLength(1);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < na; i++)
{
sb.Append("|");
for (int j = 0; j < ma; j++)
{
sb.Append(" ");
if (columnWidth > 0)
{
sb.Append(a[i, j].ToString(formatting).PadLeft(columnWidth));
}
else if (columnWidth < 0)
{
sb.Append(a[i, j].ToString(formatting).PadRight(columnWidth));
}
else
{
throw new ArgumentOutOfRangeException(nameof(columnWidth), "Must be non-negative");
}
}
sb.AppendLine(" |");
}
return sb.ToString();
}
}
class Program
{
static void Main(string[] args)
{
double[,] A = new double[,] { { 1, 2, 3 }, { 4, 5, 6 } };
double[,] B = new double[,] { { 8, 7, 6 }, { 5, 4, 3 }, { 2, 1, 0 } };
double[,] C = A.Product(B);
Console.WriteLine("A=");
Console.WriteLine(A.Show("f4", 8));
Console.WriteLine("B=");
Console.WriteLine(B.Show("f4", 8));
Console.WriteLine("C=A*B");
Console.WriteLine(C.Show("f4", 8));
}
}
</syntaxhighlight>
{{out}}
<pre>
A=
| 1.0000 2.0000 3.0000 |
| 4.0000 5.0000 6.0000 |
B=
| 8.0000 7.0000 6.0000 |
| 5.0000 4.0000 3.0000 |
| 2.0000 1.0000 0.0000 |
C=A*B
| 24.0000 18.0000 12.0000 |
| 69.0000 54.0000 39.0000 |
</pre>
=={{header|C++}}==
Line 1,015 ⟶ 1,311:
{{libheader|Blitz++}}
<
#include <blitz/tinymat.h>
Line 1,035 ⟶ 1,331:
std::cout << C << std::endl;
}</
{{out}}
(3,3):
Line 1,044 ⟶ 1,340:
===Generic solution===
main.cpp
<
#include <iostream>
#include "matrix.h"
Line 1,081 ⟶ 1,377:
} /* main() */
</syntaxhighlight>
matrix.h
<
#ifndef _MATRIX_H
#define _MATRIX_H
Line 1,262 ⟶ 1,558:
#endif /* _MATRIX_H */
</syntaxhighlight>
{{out}}
Line 1,271 ⟶ 1,567:
=={{header|Ceylon}}==
<
void printMatrix(Matrix m) {
Line 1,335 ⟶ 1,631:
print("something went wrong!");
}
}</
{{out}}
<pre>[1, 2, 3]
Line 1,352 ⟶ 1,648:
Overload the '*' operator for arrays
<
if (a.eltType != b.eltType) then
Line 1,372 ⟶ 1,668:
return c;
}</
example usage (I could not figure out the syntax for multi-dimensional array literals)
<
m1(1,1) = 1; m1(1,2) = 2;
m1(2,1) = 3; m1(2,2) = 4;
Line 1,399 ⟶ 1,695:
writeln(m5);
writeln(m4 * m5);</
=={{header|Clojure}}==
<
(defn transpose
[s]
Line 1,420 ⟶ 1,716:
(def ma [[1 1 1 1] [2 4 8 16] [3 9 27 81] [4 16 64 256]])
(def mb [[4 -3 4/3 -1/4] [-13/3 19/4 -7/3 11/24] [3/2 -2 7/6 -1/4] [-1/6 1/4 -1/6 1/24]])</
{{out}}
Line 1,429 ⟶ 1,725:
=={{header|Common Lisp}}==
<
(flet ((col (mat i) (mapcar #'(lambda (row) (elt row i)) mat))
(row (mat i) (elt mat i)))
Line 1,437 ⟶ 1,733:
;; example use:
(matrix-multiply '((1 2) (3 4)) '((-3 -8 3) (-2 1 4)))</
<
(mapcar
(lambda (row)
(apply #'mapcar
(lambda (&rest column)
(apply #'+ (mapcar #'* row column))) matrix2)) matrix1))</
The following version uses 2D arrays as inputs.
<
(let* ((m (car (array-dimensions A)))
(n (cadr (array-dimensions A)))
Line 1,459 ⟶ 1,755:
sum (* (aref A i j)
(aref B j k))))))
C))</
Example use:
<
#2A((-7 -6 11) (-17 -20 25))
</syntaxhighlight>
Another version:
<
(loop
with m = (array-dimension a 0)
Line 1,481 ⟶ 1,777:
sum (* (aref a i j)
(aref b j k)))))
finally (return c)))</
=={{header|D}}==
===Basic Version===
<
std.array, std.algorithm;
Line 1,518 ⟶ 1,814:
writefln("B = \n" ~ form ~ "\n", b);
writefln("A * B = \n" ~ form, matrixMul(a, b));
}</
{{out}}
<pre>A =
Line 1,535 ⟶ 1,831:
===Short Version===
<
T[][] matMul(T)(in T[][] A, in T[][] B) pure nothrow /*@safe*/ {
Line 1,550 ⟶ 1,846:
writefln("B = \n" ~ form ~ "\n", b);
writefln("A * B = \n" ~ form, matMul(a, b));
}</
The output is the same.
===Pure Short Version===
<
T[][] matMul(T)(immutable T[][] A, immutable T[][] B) pure nothrow {
Line 1,570 ⟶ 1,866:
writefln("B = \n" ~ form ~ "\n", b);
writefln("A * B = \n" ~ form, matMul(a, b));
}</
The output is the same.
Line 1,576 ⟶ 1,872:
All array sizes are verified at compile-time (and no matrix is copied).
Same output.
<
alias TMMul_helper(M1, M2) = Unqual!(ForeachType!(ForeachType!M1))
Line 1,608 ⟶ 1,904:
matrixMul(a, b, result);
writefln("A * B = \n" ~ form, result);
}</
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
<syntaxhighlight lang="delphi">
program Matrix_multiplication;
Line 1,704 ⟶ 2,000:
readln;
end.</
{{out}}
<pre>a:
Line 1,720 ⟶ 2,016:
[75,00, 75,00, 75,00]
[117,00, 117,00, 117,00]]</pre>
=={{header|EasyLang}}==
<syntaxhighlight>
proc matmul . m1[][] m2[][] r[][] .
r[][] = [ ]
for i to len m1[][]
r[][] &= [ ]
for j = 1 to len m2[1][]
r[i][] &= 0
for k to len m2[][]
r[i][j] += m1[i][k] * m2[k][j]
.
.
.
.
mat1[][] = [ [ 1 2 3 ] [ 4 5 6 ] ]
mat2[][] = [ [ 1 2 ] [ 3 4 ] [ 5 6 ] ]
matmul mat1[][] mat2[][] erg[][]
print erg[][]
</syntaxhighlight>
{{out}}
<pre>
[
[ 22 28 ]
[ 49 64 ]
]
</pre>
=={{header|EGL}}==
<syntaxhighlight lang="egl">
program Matrix_multiplication type BasicProgram {}
Line 1,756 ⟶ 2,080:
end
end
</syntaxhighlight>
=={{header|Ela}}==
<
mmult a b = [ [ sum $ zipWith (*) ar bc \\ bc <- (transpose b) ] \\ ar <- a ]
Line 1,766 ⟶ 2,090:
[[1, 2],
[3, 4]] `mmult` [[-3, -8, 3],
[-2, 1, 4]]</
=={{header|Elixir}}==
<
def mult(m1, m2) do
Enum.map m1, fn (x) -> Enum.map t(m2), fn (y) -> Enum.zip(x, y)
Line 1,783 ⟶ 2,107:
</syntaxhighlight>
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">
(defvar M1 '((2 1 4)
(0 1 1)))
(defvar M2 '(( 6 3 -1 0)
( 1 1 0 4)
(-2 5 0 2)))
(seq-map (lambda (a1)
(seq-map (lambda (a2) (apply #'+ (seq-mapn #'* a1 a2)))
(apply #'seq-mapn #'list M2)))
M1)
</syntaxhighlight>
{{out}}
<pre>
((5 27 -2 12) (-1 6 0 6))
</pre>
=={{header|ELLA}}==
Line 1,789 ⟶ 2,133:
Code for matrix multiplication hardware design verification:
<
[INT k = 1..n](vector1[k], vector2[k]).
Line 1,833 ⟶ 2,177:
).
COM test: just displaysignal MOC</
=={{header|Erlang}}==
<
%% Multiplies two matrices. Usage example:
Line 1,895 ⟶ 2,239:
multiply_row_by_col(Row, []) ->
[].
</syntaxhighlight>
{{out}}
Line 1,903 ⟶ 2,247:
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM MAT_PROD
Line 1,941 ⟶ 2,285:
END PROGRAM
</syntaxhighlight>
{{out}}<pre>
9 12 15
Line 1,950 ⟶ 2,294:
=={{header|Euphoria}}==
<
sequence c
if length(a[1]) != length(b) then
Line 1,965 ⟶ 2,309:
return c
end if
end function</
=={{header|Excel}}==
Line 2,052 ⟶ 2,396:
|}
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
let MatrixMultiply (matrix1 : _[,] , matrix2 : _[,]) =
let result_row = (matrix1.GetLength 0)
Line 2,066 ⟶ 2,410:
ret
</syntaxhighlight>
=={{header|Factor}}==
Line 2,079 ⟶ 2,423:
Using a list of lists representation. The multiplication is done using three nested loops.
<
class Main
{
Line 2,111 ⟶ 2,455:
}
}
</syntaxhighlight>
{{out}}
<pre>
[[1, 2, 3], [4, 5, 6]] times [[1, 2], [3, 4], [5, 6]] = [[22, 28], [49, 64]]
</pre>
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">
Array a[3,2]
Array b[2,3]
[a]:=[(2,3,5,7,11,13)]
[b]:=[(1,1,2,3,5,8)]
[a]*[b]
</syntaxhighlight>
{{out}}
<pre>
[[ 9, 25, 66, `
14, 39, 103, `
18, 49, 129 ]]
</pre>
Line 2,121 ⟶ 2,480:
{{libheader|Forth Scientific Library}}
{{works with|gforth|0.7.9_20170308}}
<
S" fsl/dynmem.seq" REQUIRED
: F+! ( addr -- ) ( F: r -- ) DUP F@ F+ F! ;
Line 2,134 ⟶ 2,493:
A{{ 3 3 B{{ 3 3 & C{{ mat*
3 3 C{{ }}fprint</
=={{header|Fortran}}==
In ISO Fortran 90 or later, use the MATMUL intrinsic function to perform Matrix Multiply; use RESHAPE and SIZE intrinsic functions to form the matrices themselves:
<
real, dimension(m,k) :: b = reshape( [ (i, i=1, m*k) ], [ m, k ] )
real, dimension(size(a,1), size(b,2)) :: c ! C is an array whose first dimension (row) size
Line 2,162 ⟶ 2,521:
do i = 1, n
print *, c(i,:)
end do</
For Intel 14.x or later (with compiler switch -assume realloc_lhs)
<
program mm
real , allocatable :: a(:,:),b(:,:)
Line 2,172 ⟶ 2,531:
print'(<n>f15.7)',transpose(matmul(a,b))
end program
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
dim as double m( any , any )
declare constructor ( )
Line 2,218 ⟶ 2,577:
print c.m(2, 0), c.m(2, 1), c.m(2, 2), c.m(2, 3)
print c.m(3, 0), c.m(3, 1), c.m(3, 2), c.m(3, 3)
</syntaxhighlight>
=={{header|Frink}}==
<
{
c = makeArray[[length[a], length[b@0]], 0]
Line 2,236 ⟶ 2,595:
return c
}</
=={{header|Futhark}}==
Line 2,243 ⟶ 2,602:
Note that the transposition need not be manifested, but is merely a change of indexing.
<syntaxhighlight lang="futhark">
fun main(x: [n][m]int, y: [m][p]int): [n][p]int =
map (fn xr => map (fn yc => reduce (+) 0 (zipWith (*) xr yc))
(transpose y))
x
</syntaxhighlight>
=={{header|GAP}}==
<
A := [[1, 2], [3, 4], [5, 6], [7, 8]];
B := [[1, 2, 3], [4, 5, 6]];
Line 2,269 ⟶ 2,628:
# [ 19, 26, 33 ],
# [ 29, 40, 51 ],
# [ 39, 54, 69 ] ]</
=={{header|Generic}}==
<
generic coordinaat
{
Line 2,943 ⟶ 3,302:
}
</syntaxhighlight>
=={{header|Go}}==
===Library gonum/mat===
<
import (
Line 2,969 ⟶ 3,328:
m.Mul(a, b)
fmt.Println(mat.Formatted(&m))
}</
{{out}}
<pre>
Line 2,977 ⟶ 3,336:
===Library go.matrix===
<
import (
Line 3,004 ⟶ 3,363:
}
fmt.Printf("Product of A and B:\n%v\n", p)
}</
{{out}}
<pre>
Line 3,021 ⟶ 3,380:
===2D representation===
<
import "fmt"
Line 3,080 ⟶ 3,439:
fmt.Printf("Matrix B:\n%s\n\n", B)
fmt.Printf("Product of A and B:\n%s\n\n", P)
}</
{{out}}
<pre>
Line 3,098 ⟶ 3,457:
</pre>
===Flat representation===
<
import "fmt"
Line 3,153 ⟶ 3,512:
}
p.print("Product of A and B:")
}</
Output is similar to 2D version.
Line 3,159 ⟶ 3,518:
=== Without Indexed Loops ===
Uses transposition to avoid indirect element access via ranges of indexes. "assertConformable()" asserts that a & b are both rectangular lists of lists, and that row-length (number of columns) of a is equal to the column-length (number of rows) of b.
<
assert a instanceof List
assert b instanceof List
Line 3,175 ⟶ 3,534:
}
}
}</
=== Without Transposition ===
Uses ranges of indexes, the way that matrix multiplication is typically defined. Not as elegant, but it avoids expensive transpositions. Reuses "assertConformable()" from above.
<
assertConformable(a, b)
Line 3,187 ⟶ 3,546:
}
}
}</
Test:
<
[ 3, 4 ],
[ 5, 6 ],
Line 3,200 ⟶ 3,559:
matmulWOIL(m4by2, m2by3).each { println it }
println()
matmulWOT(m4by2, m2by3).each { println it }</
{{out}}
Line 3,217 ⟶ 3,576:
A somewhat inefficient version with lists (''transpose'' is expensive):
<
mmult :: Num a => [[a]] -> [[a]] -> [[a]]
Line 3,225 ⟶ 3,584:
test = [[1, 2],
[3, 4]] `mmult` [[-3, -8, 3],
[-2, 1, 4]]</
===With Array===
A more efficient version, based on arrays:
<
mmult :: (Ix i, Num a) => Array (i,i) a -> Array (i,i) a -> Array (i,i) a
Line 3,241 ⟶ 3,600:
jr = range (y1,y1')
kr = range (x1,x1')
l = [((i,j), sum [x!(i,k) * y!(k,j) | k <- kr]) | i <- ir, j <- jr]</
===With List and without transpose===
<
multiply us vs = map (mult [] vs) us
where
mult xs [] _ = xs
mult xs _ [] = xs
mult [] (zs : zss) (y : ys) = mult (map (y *) zs) zss ys
mult xs (zs : zss) (y : ys) =
mult
(zipWith (\u v -> u + v * y) xs zs)
zss
ys
main :: IO ()
main =
mapM_ print $
multiply
[[1, 2], [3, 4]]
[[-3, -8, 3], [-2, 1, 4]]</syntaxhighlight>
{{out}}
<pre>[-7,-6,11]
Line 3,258 ⟶ 3,625:
===With List and without transpose - shorter===
<
mult uss vss =
let go xs
|
in go . zipWith (flip (map . (*)))
main :: IO ()
main =
mapM_ print $
mult [[1, 2], [3, 4]] [[-3, -8, 3], [-2, 1, 4]]</syntaxhighlight>
{{out}}
<pre>[-7,-6,11]
Line 3,275 ⟶ 3,641:
===With Numeric.LinearAlgebra===
<
a, b :: Matrix I
Line 3,283 ⟶ 3,649:
main :: IO ()
main = print $ a <> b</
{{out}}
<pre>
Line 3,291 ⟶ 3,657:
=={{header|HicEst}}==
<
a = $ ! initialize to 1, 2, ..., m*n
Line 3,305 ⟶ 3,671:
ENDDO
DLG(DefWidth=4, Text=a, Text=b,Y=0, Text=res,Y=0)</
<
1 2 1 2 3 9 12 15
3 4 4 5 6 19 26 33
5 6 29 40 51
7 8 39 54 69 </
=={{header|Icon}} and {{header|Unicon}}==
Line 3,316 ⟶ 3,682:
Using the provided matrix library:
<
link matrix
Line 3,330 ⟶ 3,696:
write_matrix ("", m3)
end
</syntaxhighlight>
And a hand-crafted multiply procedure:
<
procedure multiply_matrix (m1, m2)
result := [] # to hold the final matrix
Line 3,350 ⟶ 3,716:
return result
end
</syntaxhighlight>
{{out}}
Line 3,368 ⟶ 3,734:
=={{header|IDL}}==
<
=={{header|Idris}}==
<
Matrix : Nat -> Nat -> Type -> Type
Line 3,384 ⟶ 3,750:
multiply' : Num t => Matrix m1 n t -> Matrix m2 n t -> Matrix m1 m2 t
multiply' (a::as) b = map (dot a) b :: multiply' as b
multiply' [] _ = []</
=={{header|J}}==
Matrix multiply in J is <code>+/ .*</code>. For example:
<
A =: ^/~>:i. 4 NB. Same A as in other examples (1 1 1 1, 2 4 8 16, 3 9 27 81,:4 16 64 256)
Line 3,397 ⟶ 3,763:
0.00 1.00 0.00 0.00
0.00 0.00 1.00 0.00
0.00 0.00 0.00 1.00</
The notation is for a generalized inner product so that
<
x *./ .= y NB. which rows of x are the same as vector y?
x + / .= y NB. number of places where a value in row x equals the corresponding value in y</
[[Floyd-Warshall_algorithm#J|etc.]]
Line 3,411 ⟶ 3,777:
=={{header|Java}}==
<
if(a.length == 0) return new double[0][0];
if(a[0].length != b.length) return null; //invalid dims
Line 3,429 ⟶ 3,795:
}
return ans;
}</
=={{header|JavaScript}}==
Line 3,437 ⟶ 3,803:
Extends [[Matrix Transpose#JavaScript]]
<
Matrix.prototype.mult = function(other) {
if (this.width != other.height) {
Line 3,459 ⟶ 3,825:
var a = new Matrix([[1,2],[3,4]])
var b = new Matrix([[-3,-8,3],[-2,1,4]]);
print(a.mult(b));</
{{out}}
<pre>-7,-6,11
Line 3,465 ⟶ 3,831:
====Functional====
<
'use strict';
Line 3,531 ⟶ 3,897:
}
})();</
{{Out}}
<
[33, 42, 38, -14], [17, 74, 72, 44]]</
===ES6===
<
// -------------- MATRIX MULTIPLICATION --------------
// matrixMultiply :: Num a => [[a]] -> [[a]] -> [[a]]
Line 3,544 ⟶ 3,912:
b => {
const cols = transpose(b);
return a.map(
compose(
dotProduct
)
};
//
const main = () =>
JSON.stringify(matrixMultiply(
Line 3,564 ⟶ 3,930:
[-3, 5, 0],
[3, 7, -2]
]
)([
[-1, 1, 4, 8],
[6, 9, 10, 2],
Line 3,570 ⟶ 3,937:
]));
// --------------------- GENERIC ---------------------
// compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
const compose = (...fs) =>
// A function defined by the right-to-left
// composition of all the functions in fs.
fs.reduce(
(f, g) => x => f(g(x)),
Line 3,579 ⟶ 3,949:
);
//
const
//
//
compose(sum, zipWith(mul)(xs));
// mul :: Num a => a -> a -> a
const mul = a =>
b => a * b;
// sum :: (Num a) => [a] -> a
Line 3,608 ⟶ 3,966:
xs.reduce((a, x) => a + x, 0);
// transpose :: [[a]] -> [[a]]
Line 3,619 ⟶ 3,971:
// The columns of the input transposed
// into new rows.
//
(_,
v => v[i]
)
) : [];
// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
Line 3,631 ⟶ 3,985:
// custom function, rather than with the
// default tuple constructor.
xs => ys =>
).slice(
0, Math.min(xs.length,
// MAIN ---
return main();
}))();</
{{Out}}
<pre>[[51,-8,26,-18],[-8,-38,-6,34],[33,42,38,-14],[17,74,72,44]]</pre>
Line 3,649 ⟶ 4,001:
The function multiply(A;B) assumes its arguments are numeric matrices of the proper dimensions. Note that preallocating the resultant matrix would actually slow things down.
<
a as $a | b as $b
| reduce range(0;$a|length) as $i (0; . + ($a[$i] * $b[$i]) );
Line 3,666 ⟶ 4,018:
| reduce range(0; $A|length) as $i
([]; reduce range(0; $p) as $j
(.; .[$i][$j] = dot_product( $A[$i]; $BT[$j] ) )) ;</
'''Example'''
((2|sqrt)/2) as $r | [ [$r, $r], [(-($r)), $r]] as $R
Line 3,678 ⟶ 4,030:
Uses module listed in [[Matrix Transpose#Jsish]]
<
require('Matrix');
Line 3,695 ⟶ 4,047:
a.mult(b) ==> { height:2, mtx:[ [ -7, -6, 11 ], [ -17, -20, 25 ] ], width:3 }
=!EXPECTEND!=
*/</
{{out}}
Line 3,703 ⟶ 4,055:
=={{header|Julia}}==
The multiplication is denoted by *
<
2x2 Array{Int64,2}:
22 28
Line 3,711 ⟶ 4,063:
1-element Array{Int64,1}:
14
</syntaxhighlight>
=={{header|K}}==
<
(19 22
43 50)</
=={{header|Klong}}==
<
[[1 2] [3 4]] mul [[5 6] [7 8]]
[[19 22]
[43 50]]</
=={{header|Kotlin}}==
<
typealias Vector = DoubleArray
Line 3,764 ⟶ 4,116:
)
printMatrix(m1 * m2)
}</
{{out}}
Line 3,776 ⟶ 4,128:
=={{header|Lambdatalk}}==
<
{require lib_matrix}
Line 3,799 ⟶ 4,151:
[ 66, 81,-12],
[-24,-18,150]]
</syntaxhighlight>
=={{header|Lang5}}==
<
[[1 2] [3 4] [5 6]] 'm dress * .</
{{out}}
<pre>[
Line 3,814 ⟶ 4,166:
Use the LFE <code>transpose/1</code> function from [[Matrix transposition]].
<
(defun matrix* (matrix-1 matrix-2)
(list-comp
Line 3,822 ⟶ 4,174:
(lists:foldl #'+/2 0
(lists:zipwith #'*/2 a b)))))
</syntaxhighlight>
Usage example in the LFE REPL:
<
> (set ma '((1 2)
(3 4)
Line 3,836 ⟶ 4,188:
> (matrix* ma mb)
((5 11 17 23) (11 25 39 53) (17 39 61 83) (23 53 83 113))
</syntaxhighlight>
=={{header|Liberty BASIC}}==
There is no native matrix capability. A set of functions is available at http://www.diga.me.uk/RCMatrixFuncs.bas implementing matrices of arbitrary dimension in a string format.
<syntaxhighlight lang="lb">
MatrixA$ ="4, 4, 1, 1, 1, 1, 2, 4, 8, 16, 3, 9, 27, 81, 4, 16, 64, 256"
MatrixB$ ="4, 4, 4, -3, 4/3, -1/4 , -13/3, 19/4, -7/3, 11/24, 3/2, -2, 7/6, -1/4, -1/6, 1/4, -1/6, 1/24"
Line 3,851 ⟶ 4,203:
MatrixP$ =MatrixMultiply$( MatrixA$, MatrixB$)
call DisplayMatrix MatrixP$
</syntaxhighlight>
{{out}}
Line 3,873 ⟶ 4,225:
=={{header|Logo}}==
<
;PROCEDURE LISTVMD
;A = LIST
Line 3,977 ⟶ 4,329:
THIS_IS: 5 ROWS X 5 COLS
{{830 1880 2930 3980 5030} {890 2040 3190 4340 5490} {950 2200 3450 4700 5950}
{1010 2360 3710 5060 6410} {1070 2520 3970 5420 6870}}</
=={{header|Lua}}==
<
if #m1[1] ~= #m2 then -- inner matrix-dimensions must agree
return nil
Line 4,010 ⟶ 4,362:
end
io.write("\n")
end </
===SciLua===
Using the sci.alg library from scilua.org
<
mat1 = alg.tomat{{1, 2, 3}, {4, 5, 6}}
mat2 = alg.tomat{{1, 2}, {3, 4}, {5, 6}}
mat3 = mat1[] ** mat2[]
print(mat3)</
{{out}}
<pre>+22.00000,+28.00000
Line 4,024 ⟶ 4,376:
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module CheckMatMult {
\\ Matrix Multiplication
Line 4,092 ⟶ 4,444:
}
CheckMatMult2
</syntaxhighlight>
{{out}}
Line 4,103 ⟶ 4,455:
=={{header|Maple}}==
<
B := <<1,2,3>|<4,5,6>|<7,8,9>|<10,11,12>>;
A . B;</
{{out}}
<pre> [1 2 3]
Line 4,124 ⟶ 4,476:
=={{header|MathCortex}}==
<
>> A = [2,3; -2,1]
2 3
Line 4,136 ⟶ 4,488:
14 10
2 -2
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Line 4,144 ⟶ 4,496:
This computes a dot product:
<
With the following output:
<
This also computes a dot product, using the infix . notation:
<
This does element-wise multiplication of matrices:
<
With the following output:
<
Alternative infix notations '*' and ' ' (space, indicating multiplication):
<
<
In all cases matrices can be fully symbolic or numeric or mixed symbolic and numeric.
Line 4,171 ⟶ 4,523:
as complex numbers:
<
With the following output:
<
=={{header|MATLAB}}==
Matlab contains two methods of multiplying matrices: by using the "mtimes(matrix,matrix)" function, or the "*" operator.
<
A =
Line 4,206 ⟶ 4,558:
19 22
43 50</
=={{header|Maxima}}==
<
[3, 4],
[5, 6],
Line 4,221 ⟶ 4,573:
[19, 26, 33],
[29, 40, 51],
[39, 54, 69]) */</
=={{header|Nial}}==
<
=1 1 1 1
=2 4 8 16
Line 4,235 ⟶ 4,587:
=1.3e-15 1. -4.4e-16 -3.3e-16
=0. 0. 1. 4.4e-16
=0. 0. 0. 1.</
=={{header|Nim}}==
{{libheader|strfmt}}
<
type Matrix[M, N: static[int]] = array[M, array[N, float]]
Line 4,269 ⟶ 4,621:
echo b
echo a * b
echo b * a</
{{out}}
Line 4,292 ⟶ 4,644:
This version works on arrays of arrays of ints:
<
let x0 = Array.length x
and y0 = Array.length y in
Line 4,304 ⟶ 4,656:
done
done;
z</
# matrix_multiply [|[|1;2|];[|3;4|]|] [|[|-3;-8;3|];[|-2;1;4|]|];;
Line 4,311 ⟶ 4,663:
{{trans|Scheme}}
This version works on lists of lists of ints:
<
let rec mapn f lists =
assert (lists <> []);
Line 4,327 ⟶ 4,679:
(List.map2 ( * ) row column))
m2)
m1</
# matrix_multiply [[1;2];[3;4]] [[-3;-8;3];[-2;1;4]];;
Line 4,333 ⟶ 4,685:
=={{header|Octave}}==
<
% prepare the matrix
% 1 1 1 1
Line 4,345 ⟶ 4,697:
endfor
b = inverse(a);
a * b</
=={{header|Ol}}==
This short version works on lists of lists length less than 253 rows and less than 253 columns.
<
(define (matrix-multiply matrix1 matrix2)
(map
Line 4,358 ⟶ 4,710:
matrix2))
matrix1))
</syntaxhighlight>
> (matrix-multiply '((1 2) (3 4)) '((-3 -8 3) (-2 1 4)))
Line 4,364 ⟶ 4,716:
This long version works on lists of lists with any matrix dimensions.
<
(define (matrix-multiply A B)
(define m (length A))
Line 4,392 ⟶ 4,744:
r))))
rows)))))
</syntaxhighlight>
Testing large matrices:
<
(define M 372)
(define N 17)
Line 4,418 ⟶ 4,770:
(for-each print (matrix-multiply A B))
</syntaxhighlight>
{{Out}}
<pre>
Line 4,439 ⟶ 4,791:
(18194582 18269540 18344498 18419456 18494414 18569372 18644330 18719288 18794246 18869204 18944162 19019120 19094078 19169036 19243994 19318952 19393910)
</pre>
=={{header|ooRexx}}==
<syntaxhighlight lang="ooRexx">/*REXX program multiplies two matrices together, */
/* displays the matrices and the result. */
Signal On syntax
x.=0
a=.matrix~new('A',4,2,1 2 3 4 5 6 7 8) /* create matrix A */
b=.matrix~new('B',2,3,1 2 3 4 5 6) /* create matrix B */
If a~cols<>b~rows Then
Call exit 'Matrices are incompatible for matrix multiplication',
'a~cols='a~cols'<>b~rows='||b~rows
-- say a~name'[2,2] changed from' a~set(2,2,4711) 'to 4711' ; Pull .
c=multMat(a,b) /* multiply A x B */
a~show
b~show
c~show
Exit
multMat: Procedure
Use Arg a,b
c.=0
Do i=1 To a~rows
Do j=1 To b~cols
Do k=1 To a~cols
c.i.j=c.i.j+a~element(i,k)*b~element(k,j)
End /*k*/
End /*j*/
End /*i*/
mm=''
Do i=1 To a~rows
Do j=1 To b~cols
mm=mm C.i.j
End /*j*/
End /*i*/
c=.matrix~new('C',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 /* 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</syntaxhighlight>
{{Out}}
<pre>
------- matrix A -------
+-----+
| 1 2 |
| 3 4 |
| 5 6 |
| 7 8 |
+-----+
------- matrix B -------
+-------+
| 1 2 3 |
| 4 5 6 |
+-------+
------- matrix C -------
+----------+
| 9 12 15 |
| 19 26 33 |
| 29 40 51 |
| 39 54 69 |
+----------+ </pre>
=={{header|OxygenBasic}}==
Generic MatMul:
<syntaxhighlight lang="text">
'generic with striding pointers
'def typ float
typedef float typ
'
function MatMul(typ *r,*a,*b, int n=4) 'NxN MATRIX : N=1..
============================================================
int ystep=sizeof typ
int xstep=n*sizeof typ
int i,j,k
sys px
for i=1 to n
px=@a
for j=1 to n
r=0
for k=1 to n
r+=(a*b)
@a+=xstep
@b+=ystep
next
@r+=ystep
px+=ystep
@a=px
@b-=xstep
next
@a-=xstep
@b+=xstep
next
end function
</syntaxhighlight>
When using matrices in Video graphics, speed is important. Here is a matrix multiplier written in OxygenBasics's x86 Assembly code.
<
'Example of matrix layout mapped to an array of 4x4 cells
'
Line 4,556 ⟶ 5,078:
Print ShowMatrix C,n
</
=={{header|PARI/GP}}==
<syntaxhighlight lang
=={{header|Perl}}==
Line 4,566 ⟶ 5,088:
This function takes two references to arrays of arrays and returns the product as a reference to a new anonymous array of arrays.
<
{
our @a; local *a = shift;
Line 4,600 ⟶ 5,122:
$c = mmult(\@a,\@b);
display($c)</
{{out}}
<pre> -7 -6 11
Line 4,606 ⟶ 5,128:
=={{header|Phix}}==
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">integer</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">ha</span><span style="color: #0000FF;">,</span><span style="color: #000000;">wa</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hb</span><span style="color: #0000FF;">,</span><span style="color: #000000;">wb</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">({</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">],</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]},</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">wa</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">hb</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">crash</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"invalid aguments"</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span>
<span style="color: #000000;">c</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">][</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">][</span><span style="color: #000000;">k</span><span style="color: #0000FF;">]*</span><span style="color: #000000;">b</span><span style="color: #0000FF;">[</span><span style="color: #000000;">k</span><span style="color: #0000FF;">][</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
Line 4,666 ⟶ 5,188:
<span style="color: #000000;">K</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #000000;">row</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">371</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">),</span><span style="color: #000000;">16</span><span style="color: #0000FF;">})</span>
<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">matrix_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">J</span><span style="color: #0000FF;">,</span><span style="color: #000000;">K</span><span style="color: #0000FF;">),{</span><span style="color: #008000;">""</span><span style="color: #0000FF;">},</span><span style="color: #000000;">2</span><span style="color: #0000FF;">}),</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">))</span>
<!--</
{{out}}
<pre>
Line 4,690 ⟶ 5,212:
{18194582,18269540, `...`, 19318952,19393910}}
</pre>
Note that you get some "-0" in the second result under p2js due to differences in rounding behaviour between JavaScript and desktop/Phix.
=={{header|PicoLisp}}==
<
(mapcar
'((Row)
Line 4,701 ⟶ 5,224:
(matMul
'((1 2 3) (4 5 6))
'((6 -1) (3 2) (0 -3)) )</
{{out}}
<pre>-> ((12 -6) (39 -12))</pre>
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
/* Matrix multiplication of A by B, yielding C */
MMULT: procedure (a, b, c);
Line 4,730 ⟶ 5,253:
end;
end MMULT;
</syntaxhighlight>
=={{header|Pop11}}==
<
lvars ba = boundslist(a), bb = boundslist(b);
lvars i, i0 = ba(1), i1 = ba(2);
Line 4,756 ⟶ 5,279:
endfor;
endfor;
enddefine;</
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
function multarrays($a, $b) {
$n,$m,$p = ($a.Count - 1), ($b.Count - 1), ($b[0].Count - 1)
Line 4,793 ⟶ 5,316:
"`$a * `$c ="
show (multarrays $a $c)
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 4,820 ⟶ 5,343:
{{trans|Scheme}}
{{works with|SWI Prolog|5.9.9}}
<
:- use_module(library(clpfd)).
Line 4,830 ⟶ 5,353:
% as lists of lists. M3 is the product of M1 and M2
mmult(M1, M2, M3) :- transpose(M2,MT), maplist(mm_helper(MT), M1, M3).
mm_helper(M2, I1, M3) :- maplist(dot(I1), M2, M3).</
=={{header|PureBasic}}==
Matrices represented as integer arrays with rows in the first dimension and columns in the second.
<
Protected ar = ArraySize(a()) ;#rows for matrix a
Protected ac = ArraySize(a(), 2) ;#cols for matrix a
Line 4,856 ⟶ 5,379:
ProcedureReturn #False ;multiplication not performed, dimensions invalid
EndIf
EndProcedure</
Additional code to demonstrate use.
<
Data.i 2,3 ;matrix a (#rows, #cols)
Data.i 1,2,3, 4,5,6 ;elements by row
Line 4,911 ⟶ 5,434:
Input()
CloseConsole()
EndIf</
{{out}}
<pre>matrix a: (2, 3)
Line 4,927 ⟶ 5,450:
=={{header|Python}}==
<
(2, 4, 8, 16),
(3, 9, 27, 81),
Line 4,964 ⟶ 5,487:
print '%8.2f '%val,
print ']'
print ')'</
Another one, {{trans|Scheme}}
<
def matrixMul(m1, m2):
Line 4,976 ⟶ 5,499:
sum(map(mul, row, column)),
*m2),
m1)</
Using list comprehensions, multiplying matrices represented as lists of lists. (Input is not validated):
<
return [[sum(x * B[i][col] for i,x in enumerate(row)) for col in range(len(B[0]))] for row in A]</
Another one, use numpy the most popular array package for python
<
import numpy as np
np.dot(a,b)
#or if a is an array
a.dot(b)</
=={{header|R}}==
<syntaxhighlight lang
=={{header|Racket}}==
{{trans|Scheme}}
<
#lang racket
(define (m-mult m1 m2)
Line 5,003 ⟶ 5,526:
(m-mult '((1 2) (3 4)) '((5 6) (7 8)))
;; -> '((19 22) (43 50))
</syntaxhighlight>
Alternative:
<
#lang racket
(require math)
(matrix* (matrix [[1 2] [3 4]]) (matrix [[5 6] [7 8]]))
;; -> (array #[#[19 22] #[43 50]])
</syntaxhighlight>
=={{header|Raku}}==
Line 5,033 ⟶ 5,556:
used on an array to generate all the indexes of the array. We have a way of indicating a range by the infix <tt>..</tt> operator, and you can put a <tt>^</tt> on either end to exclude that endpoint. We found ourselves writing <tt>0 ..^ @a</tt> so often that we made <tt>^@a</tt> a shorthand for that. It's pronounced "upto". The array is evaluated in a numeric context, so it returns the number of elements it contains, which is exactly what you want for the exclusive limit of the range.
<syntaxhighlight lang="raku"
my @p;
for ^@a X ^@b[0] -> ($r, $c) {
Line 5,051 ⟶ 5,574:
[ -1/6, 1/4, -1/6, 1/24];
.say for mmult(@a,@b);</
{{out}}
Line 5,065 ⟶ 5,588:
Some people will find this more readable and elegant, and others will, well, not.
<syntaxhighlight lang="raku"
[
for ^a -> \r {
Line 5,075 ⟶ 5,598:
}
]
}</
Here we use Z with an "op" of <tt>*</tt>, which is a zip with multiply. This, along with the <tt>[+]</tt> reduction operator, replaces the inner loop. We chose to split the outer X loop back into two loops to make it convenient to collect each subarray value in <tt>[...]</tt>. It just collects all the returned values from the inner loop and makes an array of them. The outer loop simply returns the outer array.
Line 5,081 ⟶ 5,604:
For conciseness, the above could be written as:
<syntaxhighlight lang="raku"
@A.map: -> @a { do [+] @a Z× @B[*;$_] for ^@B[0] }
}</
Which overloads the built-in <code>×</code> operator for <code>Positional</code> operands. You’ll notice we are using <code>×</code> inside of the definition; since the arguments there are <code>Scalar</code>, it multiplies two numbers. Also, <code>do</code> is an alternative to parenthesising the loop for getting its result.
{{works with|Rakudo|2022.07-3}}
Here is a more functional version, expressing the product of two matrices as the cross dot product of the first matrix with the transpose of the second :
<syntaxhighlight lang="raku" line>sub infix:<·> { [+] @^a Z* @^b }
sub infix:<×>(@A, @B) { (@A X· [Z] @B).rotor(@B) }
</syntaxhighlight>
=={{header|Rascal}}==
<
if (max(matrix1.x) == max(matrix2.y)){
p = {<x1,y1,x2,y2, v1*v2> | <x1,y1,v1> <- matrix1, <x2,y2,v2> <- matrix2};
Line 5,108 ⟶ 5,639:
<1.0,0.0,-51.0>, <1.0,1.0,167.0>, <1.0,2.0,24.0>,
<2.0,0.0,4.0>, <2.0,1.0,-68.0>, <2.0,2.0,-41.0>
};</
=={{header|REXX}}==
<
Signal On syntax
x.=0
amat=4X2 1 2 3
bmat=2X3 1 2 3 4 5 6 /* " B "
Call makeMat 'A',amat
Call makeMat 'B',bmat /* "
If cols.A<>rows.B Then
Call exit 'Matrices are incompatible for matrix multiplication',
'cols.A='cols.A'<>rows.B='rows.B
Call multMat
Call showMat 'A',amat /* display matrix A
Call showMat 'B',bmat /*
Call showMat 'C',mm /*
Exit
/*--------------------------------------------------------------------*/
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
Parse Value rows cols With rows.what cols.what
n=0
Do r=1 To rows
Do c=1 To cols
n=n+1
element=word(elements,n)
x.what.r.c=element
End
End
Return
/*--------------------------------------------------------------------*/
multMat:
/* x.C.*.* = x.A.*.* x x.B.*.* */
Do i=1 To rows.A
Do j=1 To cols.B
Do k=1 To cols.A
x.C.i.j=x.C.i.j+x.A.i.k*x.B.k.j
End /*k*/
End /*j*/
End /*i*/
mm=rows.A||'X'||cols.B
Do i=1 To rows.A
Do j=1 To cols.B
mm=mm x.C.i.j
End /*j*/
End /*i*/
Call makeMat 'C',mm
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)
w=0
Do r=1 To rows
Do c=1 To cols
w=max(w,length(x.what.r.c))
End
End
Say b6 b6 '+'copies('-',cols*(w+1)+1)'+' /* top border */
Do r=1 To rows
line='|' right(x.what.r.1,w) /* element of first colsumn */ /* 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)'+' /* bottom border */
Return
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</syntaxhighlight>
{{out|output|text= when using the internal default input:}}
<pre>
------- matrix A -------
| 7 8 |
+-----+
------- matrix B -------
| 4 5 6 |
+-------+
------- matrix C -------
| 39 54 69 |
+----------+
</pre>
=={{header|Ring}}==
<
load "stdlib.ring"
n = 3
Line 5,184 ⟶ 5,769:
see nl
next
</syntaxhighlight>
Output:
<pre>
Line 5,190 ⟶ 5,775:
456
789
</pre>
=={{header|RPL}}==
The <code>*</code> operator can multiply numbers of any kind together, matrices - and even lists in latest RPL versions.
[[1 2 3][4 5 6]] [[3 1][4 1][5 9]] *
{{out}}
<pre>
1: [[ 26 30 ]
[ 62 63 ]]
</pre>
=={{header|Ruby}}==
Using 'matrix' from the standard library:
<
Matrix[[1, 2],
[3, 4]] * Matrix[[-3, -8, 3],
[-2, 1, 4]]</
{{out}}
Matrix[[-7, -6, 11], [-17, -20, 25]]
Version for lists: {{trans|Haskell}}
<
a.map do |ar|
b.transpose.map { |bc| ar.zip(bc).map{ |x| x.inject(&:*) }.sum }
end
end</
=={{header|Rust}}==
<
struct Matrix {
dat: [[f32; 3]; 3]
Line 5,270 ⟶ 5,864:
}
</syntaxhighlight>
=={{header|S-lang}}==
<
variable A = [1,2,3,4,5,6];
reshape(A, [2,3]); % reshape 1d array to 2 rows, 3 columns
Line 5,288 ⟶ 5,882:
reshape(B, [2,3]);
printf("\nA * B is %S (with reshaped B to match A)\n", A*B);
print(A*B);</
{{out}}
Line 5,313 ⟶ 5,907:
Assuming an array of arrays representation:
<
import n._
for (row <- a)
yield for(col <- b.transpose)
yield row zip col map Function.tupled(_*_) reduceLeft (_+_)
}</
For any subclass of <code>Seq</code> (which does not include Java-specific arrays):
<
(implicit n: Numeric[A]): CC[DD[A]] = {
import n._
Line 5,328 ⟶ 5,922:
yield for(col <- b.transpose)
yield row zip col map Function.tupled(_*_) reduceLeft (_+_)
}</
Examples:
Line 5,358 ⟶ 5,952:
{{trans|Common Lisp}}
This version works on lists of lists:
<
(map
(lambda (row)
Line 5,365 ⟶ 5,959:
(apply + (map * row column)))
matrix2))
matrix1))</
> (matrix-multiply '((1 2) (3 4)) '((-3 -8 3) (-2 1 4)))
Line 5,371 ⟶ 5,965:
=={{header|Seed7}}==
<
const func matrix: (in matrix: left) * (in matrix: right) is func
Line 5,396 ⟶ 5,990:
end for;
end if;
end func;</
Original source: [http://seed7.sourceforge.net/algorith/math.htm#mmult]
Line 5,407 ⟶ 6,001:
The SequenceL definition mirrors that definition more or less exactly:
<
let k := 1...size(B);
in sum( A[i,k] * B[k,j] );
Line 5,418 ⟶ 6,012:
[-2, 1, 4]];
test := matmul(a, b);</
It can be written a little more simply using the all keyword:
<
=={{header|Sidef}}==
<
var m = [[]]
for r in ^a {
Line 5,451 ⟶ 6,045:
for line in matrix_multi(a, b) {
say line.map{|i|'%3d' % i }.join(', ')
}</
{{out}}
<pre> 9, 12, 15
Line 5,462 ⟶ 6,056:
{{works with|OpenAxiom}}
{{works with|Axiom}}
<
+1 2+
Line 5,487 ⟶ 6,081:
| |
+39 54 69+
Type: Matrix(Integer)</
Domain:[http://fricas.github.io/api/Matrix.html?highlight=matrix Matrix(R)]
=={{header|SQL}}==
<
CREATE TABLE b (x integer, y integer, e real);
Line 5,511 ⟶ 6,105:
INTO TABLE c
FROM a AS lhs, b AS rhs
WHERE lhs.x = 0 AND rhs.y = 0;</
=={{header|Standard ML}}==
<
fun dot(x,y) = Vector.foldli (fn (i,xi,agg) => agg+xi*Vector.sub(y,i)) 0 x
fun x*y =
Line 5,537 ⟶ 6,131:
in
toList (m1*m2)
end;</
'''Output:'''
<
=={{header|Stata}}==
=== Stata matrices ===
<
. mat b=1,1,0,0\1,0,0,1\0,0,1,1
. mat c=a*b
Line 5,551 ⟶ 6,145:
c1 c2 c3 c4
r1 3 1 3 5
r2 9 4 6 11</
=== Mata ===
<
: b=1,1,0,0\1,0,0,1\0,0,1,1
: a*b
Line 5,560 ⟶ 6,154:
1 | 3 1 3 5 |
2 | 9 4 6 11 |
+---------------------+</
=={{header|Swift}}==
<
public func matrixMult<T: Numeric>(_ m1: [[T]], _ m2: [[T]]) -> [[T]] {
let n = m1[0].count
Line 5,622 ⟶ 6,216:
let m3 = matrixMult(m1, m2)
printMatrix(m3)</
{{out}}
Line 5,630 ⟶ 6,224:
=={{header|Tailspin}}==
<
operator (A matmul B)
$A -> \[i](
Line 5,665 ⟶ 6,259:
' -> !OUT::write
($a matmul $b) -> printMatrix&{w:2} -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
Line 5,684 ⟶ 6,278:
=={{header|Tcl}}==
{{works with|Tcl|8.5}}
<
namespace path ::tcl::mathop
proc matrix_multiply {a b} {
Line 5,703 ⟶ 6,297:
}
return $temp
}</
Using the <code>print_matrix</code> procedure defined in [[Matrix Transpose#Tcl]]
<pre>% print_matrix [matrix_multiply {{1 2} {3 4}} {{-3 -8 3} {-2 1 4}}]
Line 5,711 ⟶ 6,305:
=={{header|TI-83 BASIC}}==
Store your matrices in <tt>[A]</tt> and <tt>[B]</tt>.
<syntaxhighlight lang
An error will show if the matrices have invalid dimensions for multiplication.
<br><br>'''Other way:''' enter directly your matrices:
<
{{out}}
[[9 12 15]
Line 5,725 ⟶ 6,319:
{{trans|Mathematica}}
<
[1,2,3; 4,5,6] → m2
m1 * m2</
Or without the variables:
<
The result (without prettyprinting) is:
<
=={{header|Transd}}==
<syntaxhighlight lang="scheme">#lang transd
MainModule: {
_start: (λ (with n 5
A (for i in Range(n) project (for k in Range(n) project k))
B (for i in Range(n) project (for k in Range(n) project (- n k)))
C (for i in Range(n) project (for k in Range(n) project 0))
(for i in Range( n ) do
(for j in Range( n ) do
(for k in Range( n ) do
(+= (get (get C i) j) (* (get (get A i) k) (get (get B k) j)))
)))
(lout C))
)
}</syntaxhighlight>{{out}}
<pre>
[[50, 40, 30, 20, 10],
[50, 40, 30, 20, 10],
[50, 40, 30, 20, 10],
[50, 40, 30, 20, 10],
[50, 40, 30, 20, 10]]
</pre>
=={{header|UNIX Shell}}==
<
#!/bin/bash
Line 5,922 ⟶ 6,542:
echo
echo
</syntaxhighlight>
=={{header|Ursala}}==
Line 5,930 ⟶ 6,550:
the built in rational number type.
<
a =
Line 5,952 ⟶ 6,572:
#cast %qLL
test = mmult(a,b)</
{{out}}
<pre><
Line 5,962 ⟶ 6,582:
=={{header|VBA}}==
Using Excel. The resulting matrix should be smaller than 5461 elements.
<
matrix_multiplication = WorksheetFunction.MMult(a, b)
End Function</
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Dim matrix1(2,2)
matrix1(0,0) = 3 : matrix1(0,1) = 7 : matrix1(0,2) = 4
Line 5,987 ⟶ 6,607:
Next
End Sub
</syntaxhighlight>
{{Out}}
Line 5,997 ⟶ 6,617:
=={{header|Visual FoxPro}}==
<
LOCAL ARRAY a[4,2], b[2,3], c[4,3]
CLOSE DATABASES ALL
Line 6,040 ⟶ 6,660:
ENDIF
ENDPROC
</syntaxhighlight>
=={{header|Wren}}==
{{libheader|Wren-matrix}}
{{libheader|Wren-fmt}}
<
import "./fmt" for Fmt
var a = Matrix.new([
Line 6,065 ⟶ 6,685:
Fmt.mprint(b, 2, 0)
System.print("\nMatrix A x B:\n")
Fmt.mprint(a * b, 3, 0)</
{{out}}
Line 6,090 ⟶ 6,710:
=={{header|XPL0}}==
<
real M, \4x4 matrix [M] * [V] -> [V]
V; \column vector
Line 6,116 ⟶ 6,736:
N(3,C):= W(3,C);
];
];</
=={{header|XSLT 1.0}}==
With input document ...
<
<mult>
<A>
Line 6,133 ⟶ 6,753:
<r><c>4</c><c>5</c><c>6</c></r>
</B>
</mult></
... and this referenced stylesheet ...
<
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
>
Line 6,213 ⟶ 6,833:
</xsl:template>
</xsl:stylesheet></
{{out}} (in a browser):
Line 6,228 ⟶ 6,848:
A slightly smaller version of above stylesheet making use of (Non-"XSLT 1.0") EXSLT functions can be founde here: [[https://www.ibm.com/developerworks/mydeveloperworks/blogs/HermannSW/entry/matrix_multiplication30]]
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">dim a(4, 2)
a(0, 0) = 1 : a(0, 1) = 2
a(1, 0) = 3 : a(1, 1) = 4
a(2, 0) = 5 : a(2, 1) = 6
a(3, 0) = 7 : a(3, 1) = 8
dim b(2, 3)
b(0, 0) = 1 : b(0, 1) = 2 : b(0, 2) = 3
b(1, 0) = 4 : b(1, 1) = 5 : b(1, 2) = 6
dim prod(arraysize(a(),1), arraysize(b(),2))
if (arraysize(a(),2) = arraysize(b(),1)) then
for i = 0 to arraysize(a(),1)
for j = 0 to arraysize(b(),2)
for k = 0 to arraysize(a(),2)
prod(i, j) = prod(i, j) + (a(i, k) * b(k, j))
next k
next j
next i
for i = 0 to arraysize(prod(),1)-1
for j = 0 to arraysize(prod(),2)-1
print prod(i, j),
next j
print
next i
else
print "invalid dimensions"
end if
end</syntaxhighlight>
=={{header|zkl}}==
Using the GNU Scientific Library:
<
A:=GSL.Matrix(4,2).set(1,2, 3,4, 5,6, 7,8);
B:=GSL.Matrix(2,3).set(1,2,3, 4,5,6);
(A*B).format().println(); // creates a new matrix</
{{out}}
<pre>
Line 6,244 ⟶ 6,897:
Or, using lists:
{{trans|BASIC}}
<
n,m,p:=a[0].len(),a.len(),b[0].len();
ans:=(0).pump(m,List().write, (0).pump(p,List,0).copy); // matrix of zeros
foreach i,j,k in (m,p,n){ ans[i][j]+=a[i][k]*b[k][j]; }
ans
}</
<
b:=L( L(1,2,3,), L(4,5,6) );
printM(matMult(a,b));
fcn printM(m){ m.pump(Console.println,rowFmt) }
fcn rowFmt(row){ ("%4d "*row.len()).fmt(row.xplode()) }</
{{out}}
<pre>
Line 6,265 ⟶ 6,918:
=={{header|zonnon}}==
<
module MatrixOps;
type
Line 6,295 ⟶ 6,948:
Multiplication;
end MatrixOps.
</syntaxhighlight>
=={{header|ZPL}}==
<syntaxhighlight lang="zpl">
program matmultSUMMA;
Line 6,440 ⟶ 7,093:
return retval;
end;
</syntaxhighlight>
|