Matrix multiplication: Difference between revisions

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|360 Assembly}}==

MATRIXRC CSECT Matrix multiplication

USING MATRIXRC,R13

W DS CL16

YREGS

{{out}}

<pre> 9 12 15

29 40 51

39 54 69</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;

 

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>

exception index error:

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

 

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

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

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

, 1 2 ; entries separated by space or tab

, 2 3

}

}

===Using Objects===

Loop, % RRows {

RRow:=A_Index

loop, % RCols {

R[RRow,RCol] := v

}

}

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"

 

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

29 40 51

39 54 69</pre>

 

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

 

 

{

}

 

{

}

 

{

 

 

}

 

 

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

[75,00, 75,00, 75,00]

[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

 

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

<pre>

[[1, 2, 3], [4, 5, 6]] times [[1, 2], [3, 4], [5, 6]] = [[22, 28], [49, 64]]

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

mult xs [] _ = xs

mult xs _ [] = xs

 

main :: IO ()

{{out}}

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

 

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

mult uss vss =

 

main :: IO ()

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

 

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

b => {

const cols = transpose(b);

compose(

dotProduct

)

};

 

 

const main = () =>

JSON.stringify(matrixMultiply(

[-3, 5, 0],

[3, 7, -2]

[-1, 1, 4, 8],

[6, 9, 10, 2],

]));

 

 

// compose (<<<) :: (b -> c) -> (a -> b) -> a -> c

const compose = (...fs) =>

fs.reduce(

(f, g) => x => f(g(x)),

);

 

 

 

 

// mul :: Num a => a -> a -> a

const mul = a =>

b => a * b;

 

// sum :: (Num a) => [a] -> a

xs.reduce((a, x) => a + x, 0);

 

 

// transpose :: [[a]] -> [[a]]

// The columns of the input transposed

// into new rows.

)

) : [];

 

// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

// custom function, rather than with the

// default tuple constructor.

 

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

 

 

The Wolfram Language supports both dot products and element-wise multiplication of matrices.

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

 

This version works on arrays of arrays of ints:

let x0 = Array.length x

and y0 = Array.length y in

done

done;

 

# matrix_multiply [|[|1;2|];[|3;4|]|] [|[|-3;-8;3|];[|-2;1;4|]|];;

{{trans|Scheme}}

This version works on lists of lists of ints:

let rec mapn f lists =

assert (lists <> []);

(List.map2 ( * ) row column))

m2)

 

# matrix_multiply [[1;2];[3;4]] [[-3;-8;3];[-2;1;4]];;

 

=={{header|Octave}}==

% prepare the matrix

% 1 1 1 1

endfor

b = inverse(a);

 

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

matrix2))

matrix1))

 

> (matrix-multiply '((1 2) (3 4)) '((-3 -8 3) (-2 1 4)))

 

This long version works on lists of lists with any matrix dimensions.

(define (matrix-multiply A B)

(define m (length A))

r))))

rows)))))

 

Testing large matrices:

(define M 372)

(define N 17)

 

(for-each print (matrix-multiply A B))

{{Out}}

<pre>

(18194582 18269540 18344498 18419456 18494414 18569372 18644330 18719288 18794246 18869204 18944162 19019120 19094078 19169036 19243994 19318952 19393910)

</pre>

 

=={{header|OxygenBasic}}==

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

'

 

Print ShowMatrix C,n

 

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

 

=={{header|Perl}}==

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;

 

$c = mmult(\@a,\@b);

{{out}}

<pre> -7 -6 11

 

=={{header|Phix}}==

{{out}}

<pre>

{18194582,18269540, `...`, 19318952,19393910}}

</pre>

 

=={{header|PicoLisp}}==

(mapcar

'((Row)

(matMul

'((1 2 3) (4 5 6))

{{out}}

<pre>-> ((12 -6) (39 -12))</pre>

 

=={{header|PL/I}}==

/* Matrix multiplication of A by B, yielding C */

MMULT: procedure (a, b, c);

end;

end MMULT;

 

=={{header|Pop11}}==

 

lvars ba = boundslist(a), bb = boundslist(b);

lvars i, i0 = ba(1), i1 = ba(2);

endfor;

endfor;

 

=={{header|PowerShell}}==

function multarrays($a, $b) {

$n,$m,$p = ($a.Count - 1), ($b.Count - 1), ($b[0].Count - 1)

"`$a * `$c ="

show (multarrays $a $c)

<b>Output:</b>

<pre>

{{trans|Scheme}}

{{works with|SWI Prolog|5.9.9}}

:- use_module(library(clpfd)).

 

% 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).

 

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

ProcedureReturn #False ;multiplication not performed, dimensions invalid

EndIf

Additional code to demonstrate use.

Data.i 2,3 ;matrix a (#rows, #cols)

Data.i 1,2,3, 4,5,6 ;elements by row

Input()

CloseConsole()

{{out}}

<pre>matrix a: (2, 3)

 

=={{header|Python}}==

(2, 4, 8, 16),

(3, 9, 27, 81),

print '%8.2f '%val,

print ']'

 

Another one, {{trans|Scheme}}

 

def matrixMul(m1, m2):

sum(map(mul, row, column)),

*m2),

 

Using list comprehensions, multiplying matrices represented as lists of lists. (Input is not validated):

 

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

 

=={{header|R}}==

 

=={{header|Racket}}==

{{trans|Scheme}}

 

#lang racket

(define (m-mult m1 m2)

(m-mult '((1 2) (3 4)) '((5 6) (7 8)))

;; -> '((19 22) (43 50))

 

Alternative:

#lang racket

(require math)

(matrix* (matrix [[1 2] [3 4]]) (matrix [[5 6] [7 8]]))

;; -> (array #[#[19 22] #[43 50]])

 

=={{header|Raku}}==

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.

 

my @p;

for ^@a X ^@b[0] -> ($r, $c) {

[ -1/6, 1/4, -1/6, 1/24];

 

 

{{out}}

Some people will find this more readable and elegant, and others will, well, not.

 

[

for ^a -> \r {

}

]

 

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.

For conciseness, the above could be written as:

 

@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.

 

=={{header|Rascal}}==

if (max(matrix1.x) == max(matrix2.y)){

p = {<x1,y1,x2,y2, v1*v2> | <x1,y1,v1> <- matrix1, <x2,y2,v2> <- matrix2};

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

 

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

<pre>

 

 

</pre>

 

=={{header|Ring}}==

load "stdlib.ring"

n = 3

see nl

next

Output:

<pre>

456

789

</pre>

 

=={{header|Ruby}}==

Using 'matrix' from the standard library:

 

Matrix[[1, 2],

[3, 4]] * Matrix[[-3, -8, 3],

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

 

=={{header|Rust}}==

struct Matrix {

dat: [[f32; 3]; 3]

}

 

 

=={{header|S-lang}}==

variable A = [1,2,3,4,5,6];

reshape(A, [2,3]); % reshape 1d array to 2 rows, 3 columns

reshape(B, [2,3]);

printf("\nA * B is %S (with reshaped B to match A)\n", A*B);

 

{{out}}

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._

yield for(col <- b.transpose)

yield row zip col map Function.tupled(_*_) reduceLeft (_+_)

 

Examples:

{{trans|Common Lisp}}

This version works on lists of lists:

(map

(lambda (row)

(apply + (map * row column)))

matrix2))

 

> (matrix-multiply '((1 2) (3 4)) '((-3 -8 3) (-2 1 4)))

 

=={{header|Seed7}}==

 

const func matrix: (in matrix: left) * (in matrix: right) is func

end for;

end if;

 

Original source: [http://seed7.sourceforge.net/algorith/math.htm#mmult]

The SequenceL definition mirrors that definition more or less exactly:

 

let k := 1...size(B);

in sum( A[i,k] * B[k,j] );

[-2, 1, 4]];

 

It can be written a little more simply using the all keyword:

 

 

=={{header|Sidef}}==

var m = [[]]

for r in ^a {

for line in matrix_multi(a, b) {

say line.map{|i|'%3d' % i }.join(', ')

{{out}}

<pre> 9, 12, 15

{{works with|OpenAxiom}}

{{works with|Axiom}}

 

+1 2+

| |

+39 54 69+

 

Domain:[http://fricas.github.io/api/Matrix.html?highlight=matrix Matrix(R)]

 

=={{header|SQL}}==

CREATE TABLE b (x integer, y integer, e real);

 

INTO TABLE c

FROM a AS lhs, b AS rhs

 

=={{header|Standard ML}}==

fun dot(x,y) = Vector.foldli (fn (i,xi,agg) => agg+xi*Vector.sub(y,i)) 0 x

fun x*y =

in

toList (m1*m2)

'''Output:'''

 

=={{header|Stata}}==

=== Stata matrices ===

. mat b=1,1,0,0\1,0,0,1\0,0,1,1

. mat c=a*b

c1 c2 c3 c4

r1 3 1 3 5

=== Mata ===

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

: a*b

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

let m3 = matrixMult(m1, m2)

 

 

{{out}}

 

=={{header|Tailspin}}==

operator (A matmul B)

$A -> \[i](

' -> !OUT::write

($a matmul $b) -> printMatrix&{w:2} -> !OUT::write

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

namespace path ::tcl::mathop

proc matrix_multiply {a b} {

}

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

=={{header|TI-83 BASIC}}==

Store your matrices in <tt>[A]</tt> and <tt>[B]</tt>.

An error will show if the matrices have invalid dimensions for multiplication.

<br><br>'''Other way:''' enter directly your matrices:

{{out}}

[[9 12 15]

{{trans|Mathematica}}

 

[1,2,3; 4,5,6] → m2

 

Or without the variables:

 

 

The result (without prettyprinting) is:

 

 

=={{header|UNIX Shell}}==

#!/bin/bash

 

echo

echo

 

=={{header|Ursala}}==

the built in rational number type.

 

 

a =

#cast %qLL

 

{{out}}

<pre><

=={{header|VBA}}==

Using Excel. The resulting matrix should be smaller than 5461 elements.

matrix_multiplication = WorksheetFunction.MMult(a, b)

 

=={{header|VBScript}}==

Dim matrix1(2,2)

matrix1(0,0) = 3 : matrix1(0,1) = 7 : matrix1(0,2) = 4

Next

End Sub

 

{{Out}}

 

=={{header|Visual FoxPro}}==

LOCAL ARRAY a[4,2], b[2,3], c[4,3]

CLOSE DATABASES ALL

ENDIF

ENDPROC

 

=={{header|Wren}}==

{{libheader|Wren-matrix}}

{{libheader|Wren-fmt}}

 

var a = Matrix.new([

Fmt.mprint(b, 2, 0)

System.print("\nMatrix A x B:\n")

 

{{out}}

 

=={{header|XPL0}}==

real M, \4x4 matrix [M] * [V] -> [V]

V; \column vector

N(3,C):= W(3,C);

];

 

=={{header|XSLT 1.0}}==

With input document ...

 

<mult>

<A>

<r><c>4</c><c>5</c><c>6</c></r>

</B>

 

... and this referenced stylesheet ...

 

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

>

</xsl:template>

 

{{out}} (in a browser):

 

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

{{out}}

<pre>

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

{{out}}

<pre>

 

=={{header|zonnon}}==

module MatrixOps;

type

Multiplication;

end MatrixOps.

 

=={{header|ZPL}}==

program matmultSUMMA;

 

return retval;

end;