Matrix multiplication: Difference between revisions

{{trans|Nim}}

assert(m1[0].len == m2.len)

V r = [[0.0] * m2[0].len] * m1.len

print(to_str(b))

print(to_str(matrix_mul(a, b)))

{{out}}

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

MATRIXRC CSECT Matrix multiplication

USING MATRIXRC,R13

W DS CL16

YREGS

{{out}}

<pre> 9 12 15

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

DEFINE PTR="CARD"

PutE() PrintE("equals") PutE()

PrintMatrix(res)

{{out}}

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

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;

begin

Put (A * B);

{{out}}

<pre>

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

return Temp;

end "*";

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

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

exception index error:

putf(stand error, $x"Exception: index error."l$)

{{out}}

<pre>

=={{header|Amazing Hopper}}==

#include <hopper.h>

main:

{first matrix,second matrix},mat mul, println

exit(0)

Alternatively, the follow code in macro-natural-Hopper:

#include <natural.h>

#include <hopper.h>

now take 'first matrix', and take 'second matrix', and multiply it; then, print with a new line.

exit(0)

{{out}}

<pre>

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)

0.00 1.00 0.00 0.00

0.00 0.00 1.00 0.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.

=={{header|AppleScript}}==

{{trans|JavaScript}}

-- matrixMultiply :: Num a => [[a]] -> [[a]] -> [[a]]

return lst

end tell

{{Out}}

=={{header|Arturo}}==

loop m 'row -> print map row 'val [pad to :string .format:".2f" val 6]

print "--------------------------------"

printMatrix B

printMatrix multiply A B

{{out}}

=={{header|AutoHotkey}}==

ahk [http://www.autohotkey.com/forum/topic44657-150.html discussion]

, 1 2 ; entries separated by space or tab

, 2 3

}

}

===Using Objects===

if (A[1].Count() <> B.Count())

return ["Dimension Error"]

}

return R

, [3,4]

, [5,6]

Res .= (A_Index=1?"":"`t") col (Mod(A_Index,M[1].MaxIndex())?"":"`n")

return Trim(Res,"`n")

{{out}}

<pre>9 12 15

=={{header|AWK}}==

# Separate matrices a and b by a blank line

BEGIN {

function max(m, n) {

return m > n ? m : n

<p><b>Input:</b></p>

<pre>

{{works with|QuickBasic|4.5}}

{{trans|Java}}

IF (LEN(a,2) = LEN(b)) 'if valid dims

n = LEN(a,2)

ELSE

PRINT "invalid dimensions"

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

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)

10010 DATA1,2,3,4,5,6,7,8

20000 DATA2,3

===Full BASIC===

{{works with|Full BASIC}}

{{trans|BBC_BASIC}}

MAT READ matrix1

MAT product=matrix1*matrix2

{{out}}

<pre> 9 12 15

(assumes default lower bound of 0):

matrix1() = 1, 2, \

PRINT

NEXT

{{out}}

<pre> 9 12 15

<code>Mul</code> is a matrix multiplication idiom from [https://mlochbaum.github.io/bqncrate/ BQNcrate.]

(>⟨

⟨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

29 40 51

39 54 69

=={{header|C}}==

#define MAT_ELEM(rows,cols,r,c) (r*cols+c)

}

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

This code should work with any version of the .NET Framework and C# language

{

int n;

return result;

}

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

{{libheader|Blitz++}}

#include <blitz/tinymat.h>

std::cout << C << std::endl;

{{out}}

(3,3):

===Generic solution===

main.cpp

#include <iostream>

#include "matrix.h"

} /* main() */

matrix.h

#ifndef _MATRIX_H

#define _MATRIX_H

#endif /* _MATRIX_H */

{{out}}

=={{header|Ceylon}}==

void printMatrix(Matrix m) {

print("something went wrong!");

}

{{out}}

<pre>[1, 2, 3]

Overload the '*' operator for arrays

if (a.eltType != b.eltType) then

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;

writeln(m5);

=={{header|Clojure}}==

(defn transpose

[s]

(def ma [[1 1 1 1] [2 4 8 16] [3 9 27 81] [4 16 64 256]])

{{out}}

=={{header|Common Lisp}}==

(flet ((col (mat i) (mapcar #'(lambda (row) (elt row i)) mat))

(row (mat i) (elt mat i)))

;; example use:

(mapcar

(lambda (row)

(apply #'mapcar

(lambda (&rest column)

The following version uses 2D arrays as inputs.

(let* ((m (car (array-dimensions A)))

(n (cadr (array-dimensions A)))

sum (* (aref A i j)

(aref B j k))))))

Example use:

#2A((-7 -6 11) (-17 -20 25))

Another version:

(loop

with m = (array-dimension a 0)

sum (* (aref a i j)

(aref b j k)))))

=={{header|D}}==

===Basic Version===

std.array, std.algorithm;

writefln("B = \n" ~ form ~ "\n", b);

writefln("A * B = \n" ~ form, matrixMul(a, b));

{{out}}

<pre>A =

===Short Version===

T[][] matMul(T)(in T[][] A, in T[][] B) pure nothrow /*@safe*/ {

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 {

writefln("B = \n" ~ form ~ "\n", b);

writefln("A * B = \n" ~ form, matMul(a, b));

The output is the same.

All array sizes are verified at compile-time (and no matrix is copied).

Same output.

alias TMMul_helper(M1, M2) = Unqual!(ForeachType!(ForeachType!M1))

matrixMul(a, b, result);

writefln("A * B = \n" ~ form, result);

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

program Matrix_multiplication;

readln;

{{out}}

<pre>a:

[117,00, 117,00, 117,00]]</pre>

=={{header|EGL}}==

program Matrix_multiplication type BasicProgram {}

end

end

=={{header|Ela}}==

mmult a b = [ [ sum $ zipWith (*) ar bc \\ bc <- (transpose b) ] \\ ar <- a ]

[[1, 2],

[3, 4]] `mmult` [[-3, -8, 3],

=={{header|Elixir}}==

def mult(m1, m2) do

Enum.map m1, fn (x) -> Enum.map t(m2), fn (y) -> Enum.zip(x, y)

=={{header|ELLA}}==

Code for matrix multiplication hardware design verification:

[INT k = 1..n](vector1[k], vector2[k]).

).

=={{header|Erlang}}==

%% Multiplies two matrices. Usage example:

multiply_row_by_col(Row, []) ->

[].

{{out}}

=={{header|ERRE}}==

PROGRAM MAT_PROD

END PROGRAM

{{out}}<pre>

9 12 15

=={{header|Euphoria}}==

sequence c

if length(a[1]) != length(b) then

return c

end if

=={{header|Excel}}==

=={{header|F_Sharp|F#}}==

let MatrixMultiply (matrix1 : _[,] , matrix2 : _[,]) =

let result_row = (matrix1.GetLength 0)

ret

=={{header|Factor}}==

Using a list of lists representation. The multiplication is done using three nested loops.

class Main

{

}

}

{{out}}

=={{header|Fermat}}==

Array a[3,2]

Array b[2,3]

[b]:=[(1,1,2,3,5,8)]

[a]*[b]

{{out}}

<pre>

{{libheader|Forth Scientific Library}}

{{works with|gforth|0.7.9_20170308}}

S" fsl/dynmem.seq" REQUIRED

: F+! ( addr -- ) ( F: r -- ) DUP F@ F+ F! ;

A{{ 3 3 B{{ 3 3 & C{{ mat*

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

do i = 1, n

print *, c(i,:)

For Intel 14.x or later (with compiler switch -assume realloc_lhs)

program mm

real , allocatable :: a(:,:),b(:,:)

print'(<n>f15.7)',transpose(matmul(a,b))

end program

=={{header|FreeBASIC}}==

dim as double m( any , any )

declare constructor ( )

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)

=={{header|Frink}}==

{

c = makeArray[[length[a], length[b@0]], 0]

return c

=={{header|Futhark}}==

Note that the transposition need not be manifested, but is merely a change of indexing.

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

=={{header|GAP}}==

A := [[1, 2], [3, 4], [5, 6], [7, 8]];

B := [[1, 2, 3], [4, 5, 6]];

# [ 19, 26, 33 ],

# [ 29, 40, 51 ],

=={{header|Generic}}==

generic coordinaat

{

}

=={{header|Go}}==

===Library gonum/mat===

import (

m.Mul(a, b)

fmt.Println(mat.Formatted(&m))

{{out}}

<pre>

===Library go.matrix===

import (

}

fmt.Printf("Product of A and B:\n%v\n", p)

{{out}}

<pre>

===2D representation===

import "fmt"

fmt.Printf("Matrix B:\n%s\n\n", B)

fmt.Printf("Product of A and B:\n%s\n\n", P)

{{out}}

<pre>

</pre>

===Flat representation===

import "fmt"

}

p.print("Product of A and B:")

Output is similar to 2D version.

=== 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

}

}

=== 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)

}

}

Test:

[ 3, 4 ],

[ 5, 6 ],

matmulWOIL(m4by2, m2by3).each { println it }

println()

{{out}}

A somewhat inefficient version with lists (''transpose'' is expensive):

mmult :: Num a => [[a]] -> [[a]] -> [[a]]

test = [[1, 2],

[3, 4]] `mmult` [[-3, -8, 3],

===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

jr = range (y1,y1')

kr = range (x1,x1')

===With List and without transpose===

multiply us vs = map (mult [] vs) us

where

multiply

[[1, 2], [3, 4]]

{{out}}

<pre>[-7,-6,11]

===With List and without transpose - shorter===

mult uss vss =

let go xs

main =

mapM_ print $

{{out}}

<pre>[-7,-6,11]

===With Numeric.LinearAlgebra===

a, b :: Matrix I

main :: IO ()

{{out}}

<pre>

=={{header|HicEst}}==

a = $ ! initialize to 1, 2, ..., m*n

ENDDO

1 2 1 2 3 9 12 15

3 4 4 5 6 19 26 33

5 6 29 40 51

=={{header|Icon}} and {{header|Unicon}}==

Using the provided matrix library:

link matrix

write_matrix ("", m3)

end

And a hand-crafted multiply procedure:

procedure multiply_matrix (m1, m2)

result := [] # to hold the final matrix

return result

end

{{out}}

=={{header|IDL}}==

=={{header|Idris}}==

Matrix : Nat -> Nat -> Type -> Type

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

=={{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)

0.00 1.00 0.00 0.00

0.00 0.00 1.00 0.00

The notation is for a generalized inner product so that

x *./ .= y NB. which rows of x are the same as vector y?

[[Floyd-Warshall_algorithm#J|etc.]]

=={{header|Java}}==

if(a.length == 0) return new double[0][0];

if(a[0].length != b.length) return null; //invalid dims

}

return ans;

=={{header|JavaScript}}==

Extends [[Matrix Transpose#JavaScript]]

Matrix.prototype.mult = function(other) {

if (this.width != other.height) {

var a = new Matrix([[1,2],[3,4]])

var b = new Matrix([[-3,-8,3],[-2,1,4]]);

{{out}}

<pre>-7,-6,11

====Functional====

'use strict';

}

{{Out}}

===ES6===

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>[[51,-8,26,-18],[-8,-38,-6,34],[33,42,38,-14],[17,74,72,44]]</pre>

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

| reduce range(0; $A|length) as $i

([]; reduce range(0; $p) as $j

'''Example'''

((2|sqrt)/2) as $r | [ [$r, $r], [(-($r)), $r]] as $R

Uses module listed in [[Matrix Transpose#Jsish]]

require('Matrix');

a.mult(b) ==> { height:2, mtx:[ [ -7, -6, 11 ], [ -17, -20, 25 ] ], width:3 }

=!EXPECTEND!=

{{out}}

=={{header|Julia}}==

The multiplication is denoted by *

2x2 Array{Int64,2}:

22 28

1-element Array{Int64,1}:

14

=={{header|K}}==

(19 22

=={{header|Klong}}==

[[1 2] [3 4]] mul [[5 6] [7 8]]

[[19 22]

=={{header|Kotlin}}==

typealias Vector = DoubleArray

)

printMatrix(m1 * m2)

{{out}}

=={{header|Lambdatalk}}==

{require lib_matrix}

[ 66, 81,-12],

[-24,-18,150]]

=={{header|Lang5}}==

{{out}}

<pre>[

Use the LFE <code>transpose/1</code> function from [[Matrix transposition]].

(defun matrix* (matrix-1 matrix-2)

(list-comp

(lists:foldl #'+/2 0

(lists:zipwith #'*/2 a b)))))

Usage example in the LFE REPL:

> (set ma '((1 2)

(3 4)

> (matrix* ma mb)

((5 11 17 23) (11 25 39 53) (17 39 61 83) (23 53 83 113))

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

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"

MatrixP$ =MatrixMultiply$( MatrixA$, MatrixB$)

call DisplayMatrix MatrixP$

{{out}}

=={{header|Logo}}==

;PROCEDURE LISTVMD

;A = LIST

THIS_IS: 5 ROWS X 5 COLS

{{830 1880 2930 3980 5030} {890 2040 3190 4340 5490} {950 2200 3450 4700 5950}

=={{header|Lua}}==

if #m1[1] ~= #m2 then -- inner matrix-dimensions must agree

return nil

end

io.write("\n")

===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[]

{{out}}

<pre>+22.00000,+28.00000

=={{header|M2000 Interpreter}}==

Module CheckMatMult {

\\ Matrix Multiplication

}

CheckMatMult2

{{out}}

=={{header|Maple}}==

B := <<1,2,3>|<4,5,6>|<7,8,9>|<10,11,12>>;

{{out}}

<pre> [1 2 3]

=={{header|MathCortex}}==

>> A = [2,3; -2,1]

2 3

14 10

2 -2

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

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.

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 =

19 22

=={{header|Maxima}}==

[3, 4],

[5, 6],

[19, 26, 33],

[29, 40, 51],

=={{header|Nial}}==

=1 1 1 1

=2 4 8 16

=1.3e-15 1. -4.4e-16 -3.3e-16

=0. 0. 1. 4.4e-16

=={{header|Nim}}==

{{libheader|strfmt}}

type Matrix[M, N: static[int]] = array[M, array[N, float]]

echo b

echo a * b

{{out}}