Matrix multiplication: Difference between revisions

=={{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.Text_IO; use Ada.Text_IO;

with Ada.Numerics.Real_Arrays; use Ada.Numerics.Real_Arrays;

Put (A * B);

end Matrix_Product;

Sample output:

<pre>

</pre>

The following code illustrates how matrix multiplication could be implemented from scratch:

package Matrix_Ops is

type Matrix is array (Natural range <>, Natural range <>) of Float;

end "*";

end Matrix_Ops;

 

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

=={{header|C}}==

{{works with|gcc|<nowiki>4.1.2 20070925 (Red Hat 4.1.2-27) Options: gcc -std=gnu99</nowiki>}}

#include <stdio.h>

#define dim 4 /* fixed length square matrices */

vprintf(result_fmt,(void*)&prod);

}

Output:

Product of a and b:

 

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

For most applications involving extensive matrix arithmetic, using the CPAN module called "PDL" (that stands for "Perl Data Language") would probably be the easiest and most efficient approach. That said, here's an implementation of matrix multiplication in plain Perl.

 

{our @a; local *a = shift;

our @b; local *b = shift;

{for (my $c = 0 ; $c < $cols ; ++$c)

{$p[$r][$c] += $a[$r][$_] * $b[$_][$c] foreach 0 .. $n;}}

 

This function takes two references to arrays of arrays and returns the product as a reference to a new anonymous array of arrays.

 

Another one, {{trans|Scheme}}

 

def matrixMul(m1, m2):

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

*m2),

 

=={{header|R}}==

=={{header|Ruby}}==

Using the Matrix class:

 

Matrix[[1, 2],

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

Output:

Matrix[[-7, -6, 11], [-17, -20, 25]]

 

Version for lists: {{trans|Haskell}}

a.map do |ar|

b.transpose.map do |bc|

end

end

 

=={{header|Scheme}}==

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