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

{{trans|JavaScript}}

to matrixMultiply(a, b)

script rows

 

 

on run

matrixMultiply({¬

 

 

 

-- dotProduct :: [n] -> [n] -> Maybe n

end if

end dotProduct

 

-- foldr :: (a -> b -> a) -> a -> [b] -> a

end tell

end foldr

 

-- map :: (a -> b) -> [a] -> [b]

end tell

end map

 

-- min :: Ord a => a -> a -> a

end if

end min

 

-- Lift 2nd class handler function into 1st class script wrapper

end if

end mReturn

 

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

foldr(mult, 1, xs)

end product

 

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

foldr(add, 0, xs)

end sum

 

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

map(column, item 1 of xss)

end transpose

 

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

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

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]

[ 58, 64]

[139, 154]</pre>

 

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

program Matrix_multiplication type BasicProgram {}

end

end

 

=={{header|Elixir}}==

def mult(m1, m2) do

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

 

 

 

=={{header|Erlang}}==

 

%% Multiplies two matrices. Usage example:

multiply_row_by_col(Row, []) ->

[].

 

{{out}}

[[7,16],[22,40]]

</pre>

 

=={{header|ERRE}}==

PROGRAM MAT_PROD

 

 

END PROGRAM

{{out}}<pre>

9 12 15

</pre>

 

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>

 

 

=={{header|Forth}}==

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

 

 

 

 

 

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

 

 

 

 

 

 

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

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

 

 

 

 

 

{{Out}}

 

=={{header|jq}}==

 

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

[17.0, 74.0, 72.0, 44.0]

</pre>

 

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

+49.00000,+64.00000</pre>

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

Module CheckMatMult {

\\ Matrix Multiplication

}

CheckMatMult2

 

{{out}}

0 0 0 1

</pre>

=={{header|Maple}}==

 

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

 

{{out}}

<pre> [1 2 3]

[ ]

[32 77 122 167]</pre>

 

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

 

 

let a = [[1.0, 1.0, 1.0, 1.0],

[4.0, 16.0, 64.0, 256.0]]

 

[-13/3.0, 19/4.0, -7/3.0, 11/24.0],

[ -1/6.0, 1/4.0, -1/6.0, 1/24.0]]

 

result.add "])"

 

for i in result.low .. result.high:

for j in result[0].low .. result[0].high:

echo b

echo a * b

 

=={{header|OCaml}}==

 

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

(define (matrix-multiply matrix1 matrix2)

(map

matrix2))

matrix1))

 

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

((-7 -6 11) (-17 -20 25))

 

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

-17 -20 25</pre>

 

{{out}}

 

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

if ($a[0].Count -ne $b.Count) {throw "Multiplication impossible"}

foreach ($i in 0..$n) {

$c[$i] = foreach ($j in 0..$p) {

"`$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|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}}==

 

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

end

 

=={{header|Rust}}==

struct Matrix {

dat: [[f32; 3]; 3]

}

 

 

=={{header|Scala}}==

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

(* for display *)

fun toList a =

(* example *)

in

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