Element-wise operations: Difference between revisions
m
→{{header|Wren}}: Minor tidy
No edit summary |
m (→{{header|Wren}}: Minor tidy) |
||
| (34 intermediate revisions by 23 users not shown) | |||
Line 25:
Using Generics, the task is quite trivial in Ada. Here is the main program:
<
procedure Scalar_Ops is
Line 55:
Ada.Text_IO.Put_Line(" M mod 2=" & Image(A mod 2));
Ada.Text_IO.Put_Line("(M*2) mod 3=" & Image((A*2) mod 3));
end Scalar_Ops;</
{{out}}
Line 70:
Our main program uses a generic package Matrix_Scalar. Here is the specification:
<
type Rows is (<>);
type Cols is (<>);
Line 85:
function Image(M: Matrix) return String;
end Matrix_Scalar;</
And here is the corresponding implementation. Note that the function Image (which we just use to output the results) takes much more lines than the function Func we need for actually solving the task:
<
function Func(Left: Matrix; Right: Num) return Matrix is
Line 133:
end Image;
end Matrix_Scalar;</
=={{header|ALGOL 68}}==
Line 140:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}
{{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 '''format'''[ted] ''transput''.}}
<
MODE SCALAR = REAL;
Line 193:
elementwise op(pow, matrix, matrix)
))
)</
{{out}}
<pre>
Line 227:
(2567686153161210000000000000000000000000000.00, 17069174130723200000000000000000000000000000000.00, 10555134955777600000000000000000000000000000000000000000000.00));
</pre>
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
main:
/* create an integer random array */
A=-1,{10}rand array(A), mulby(10), ceil, mov(A)
{","}tok sep
{"\ENF","ORIGINAL ARRAY :",A,"\OFF\n","="}reply(90),
println
{"Increment :\t"}, ++A,{A} println
{"Decrement :\t"}, --A,{A} println
{"post Increment: "}, A++, println
{*"\t",A} println
{"post Decrement: "}, A--, println
{*"\t",A} println
{"A + 5 :\t\t"}, {A} plus (5), println
{"5 + A :\t\t"}, {5} plus (A), println
{"A - 5 :\t\t"}, {A} minus (5), println
{"5 - A :\t\t"}, {5} minus (A), println
{"A * 5 :\t\t"}, {A} mul by (5), println
{"5 * A :\t\t"}, {5} mul by (A), println
{"A / 5 :\t\t"}, {A} div by (5), println
{"5 / A :\t\t"}, {5} div by (A), println
{"A \ 5 :\t\t"}, {A} idiv by (5), println
{"5 \ A :\t\t"}, {5} idiv by (A), println
{"A ^ 5 :\t\t"}, {A} pow by (5), println
{"5 ^ A :\t\t"}, {5} pow by (A), println
{"A % 5 :\t\t"}, {A} module (5), println
{"5 % A :\t\t"}, {5} module (A), println
{"SQRT(A) + 5:\t"}, {A} sqrt, plus(5),
tmp=0,cpy(tmp), println
{"--> CEIL :\t"} {tmp},ceil, println
{"--> FLOOR :\t"} {tmp},floor, println
{"A + A :\t\t"}, {A} plus (A), println
{"A - A :\t\t"}, {A} minus (A), println
{"A * A :\t\t"}, {A} mulby (A), println
{"A / A :\t\t"}, {A} div by (A), println
{"A \ A :\t\t"}, {A} idiv by (A), println
{"A ^ A :\t\t"}, {A} pow by (A), println
{"A % A :\t\t"}, {A} module (A), println
{"Etcetera...\n"}, println
exit(0)
</syntaxhighlight>
{{out}}
<pre>
'''ORIGINAL ARRAY :8,10,8,3,4,7,5,4,8,1'''
==========================================================================================
Increment : 9,11,9,4,5,8,6,5,9,2
Decrement : 8,10,8,3,4,7,5,4,8,1
post Increment: 8,10,8,3,4,7,5,4,8,1
9,11,9,4,5,8,6,5,9,2
post Decrement: 9,11,9,4,5,8,6,5,9,2
8,10,8,3,4,7,5,4,8,1
A + 5 : 13,15,13,8,9,12,10,9,13,6
5 + A : 13,15,13,8,9,12,10,9,13,6
A - 5 : 3,5,3,-2,-1,2,0,-1,3,-4
5 - A : -3,-5,-3,2,1,-2,0,1,-3,4
A * 5 : 40,50,40,15,20,35,25,20,40,5
5 * A : 40,50,40,15,20,35,25,20,40,5
A / 5 : 1.6,2,1.6,0.6,0.8,1.4,1,0.8,1.6,0.2
5 / A : 0.625,0.5,0.625,1.66667,1.25,0.714286,1,1.25,0.625,5
A \ 5 : 1,2,1,0,0,1,1,0,1,0
5 \ A : 0,0,0,1,1,0,1,1,0,5
A ^ 5 : 32768,100000,32768,243,1024,16807,3125,1024,32768,1
5 ^ A : 390625,9.76562e+06,390625,125,625,78125,3125,625,390625,5
A % 5 : 3,0,3,3,4,2,0,4,3,1
5 % A : 5,5,5,2,1,5,0,1,5,0
SQRT(A) + 5: 7.82843,8.16228,7.82843,6.73205,7,7.64575,7.23607,7,7.82843,6
--> CEIL : 8,9,8,7,7,8,8,7,8,6
--> FLOOR : 7,8,7,6,7,7,7,7,7,6
A + A : 16,20,16,6,8,14,10,8,16,2
A - A : 0,0,0,0,0,0,0,0,0,0
A * A : 64,100,64,9,16,49,25,16,64,1
A / A : 1,1,1,1,1,1,1,1,1,1
A \ A : 1,1,1,1,1,1,1,1,1,1
A ^ A : 1.67772e+07,1e+10,1.67772e+07,27,256,823543,3125,256,1.67772e+07,1
A % A : 0,0,0,0,0,0,0,0,0,0
Etcetera...
</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">ElementWise(M, operation, Val){
A := Obj_Copy(M),
for r, obj in A
for c, v in obj {
V := IsObject(Val) ? Val[r, c] : Val
switch, operation {
case "+": A[r, c] := A[r, c] + V
case "-": A[r, c] := A[r, c] - V
case "*": A[r, c] := A[r, c] * V
case "/": A[r, c] := A[r, c] / V
case "Mod": A[r, c] := Mod(A[r, c], V)
case "^": A[r, c] := A[r, c] ** V
}
}
return A
}</syntaxhighlight>
Examples:<syntaxhighlight lang="autohotkey">
M := [[1, 2, 3]
, [4, 5, 6]
, [7, 8, 9]]
output := "M`t=`t" obj2str(M) "`n"
output .= "M + 2`t=`t" obj2str(ElementWise(M, "+", 2)) "`n"
output .= "M - 2`t=`t" obj2str(ElementWise(M, "-", 2)) "`n"
output .= "M * 2`t=`t" obj2str(ElementWise(M, "*", 2)) "`n"
output .= "M / 2`t=`t" obj2str(ElementWise(M, "/", 2)) "`n"
output .= "M Mod 2`t=`t" obj2str(ElementWise(M, "Mod", 2)) "`n"
output .= "M ^ 2`t=`t" obj2str(ElementWise(M, "^", 2)) "`n"
output .= "`n"
output .= "M + M`t=`t" obj2str(ElementWise(M, "+", M)) "`n"
output .= "M - M`t=`t" obj2str(ElementWise(M, "-", M)) "`n"
output .= "M * M`t=`t" obj2str(ElementWise(M, "*", M)) "`n"
output .= "M / M`t=`t" obj2str(ElementWise(M, "/", M)) "`n"
output .= "M Mod M`t=`t" obj2str(ElementWise(M, "Mod", M)) "`n"
output .= "M ^ M`t=`t" obj2str(ElementWise(M, "^", M)) "`n"
MsgBox % output
return
obj2str(A){
output := "["
for r, obj in A{
output .= "["
for c, v in obj
output .= v ", "
output := Trim(output, ", ") "], "
}
return output := Trim(output, ", ") "]"
}</syntaxhighlight>
{{out}}
<pre>M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
M + 2 = [[3, 4, 5], [6, 7, 8], [9, 10, 11]]
M - 2 = [[-1, 0, 1], [2, 3, 4], [5, 6, 7]]
M * 2 = [[2, 4, 6], [8, 10, 12], [14, 16, 18]]
M / 2 = [[0.5, 1, 1.5], [2, 2.5, 3], [3.5, 4, 4.5]]
M Mod 2 = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
M ^ 2 = [[1, 4, 9], [16, 25, 36], [49, 64, 81]]
M + M = [[2, 4, 6], [8, 10, 12], [14, 16, 18]]
M - M = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
M * M = [[1, 4, 9], [16, 25, 36], [49, 64, 81]]
M / M = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
M Mod M = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
M ^ M = [[1, 4, 27], [256, 3125, 46656], [823543, 16777216, 387420489]]</pre>
=={{header|BBC BASIC}}==
All except exponentiation (^) are native operations in BBC BASIC.
<
a() = 7, 8, 7, 4, 0, 9 : b() = 4, 5, 1, 6, 2, 1
Line 282 ⟶ 426:
a$ = LEFT$(LEFT$(a$)) + "]"
NEXT
= a$ + "]"</
{{out}}
<pre>
Line 300 ⟶ 444:
=={{header|C}}==
Matrices are 2D double arrays.
<
#define for_i for(i = 0; i < h; i++)
Line 313 ⟶ 457:
void eop_s_##name(_M a, double s, _M b, int w, int h) {double x;int i,j;\
for_i for_j {x = a[i][j]; b[i][j] = res;}}
OPS(mul, x*s);OPS(div, x/s);OPS(add, x+s);OPS(sub, x-s);OPS(pow, pow(x, s));</
=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
public static class ElementWiseOperations
{
private static readonly Dictionary<string, Func<double, double, double>> operations =
new Dictionary<string, Func<double, double, double>> {
{ "add", (a, b) => a + b },
{ "sub", (a, b) => a - b },
{ "mul", (a, b) => a * b },
{ "div", (a, b) => a / b },
{ "pow", (a, b) => Math.Pow(a, b) }
};
private static readonly Func<double, double, double> nothing = (a, b) => a;
public static double[,] DoOperation(this double[,] m, string name, double[,] other) =>
DoOperation(m, operations.TryGetValue(name, out var operation) ? operation : nothing, other);
public static double[,] DoOperation(this double[,] m, Func<double, double, double> operation, double[,] other) {
if (m == null || other == null) throw new ArgumentNullException();
int rows = m.GetLength(0), columns = m.GetLength(1);
if (rows != other.GetLength(0) || columns != other.GetLength(1)) {
throw new ArgumentException("Matrices have different dimensions.");
}
double[,] result = new double[rows, columns];
for (int r = 0; r < rows; r++) {
for (int c = 0; c < columns; c++) {
result[r, c] = operation(m[r, c], other[r, c]);
}
}
return result;
}
public static double[,] DoOperation(this double[,] m, string name, double number) =>
DoOperation(m, operations.TryGetValue(name, out var operation) ? operation : nothing, number);
public static double[,] DoOperation(this double[,] m, Func<double, double, double> operation, double number) {
if (m == null) throw new ArgumentNullException();
int rows = m.GetLength(0), columns = m.GetLength(1);
double[,] result = new double[rows, columns];
for (int r = 0; r < rows; r++) {
for (int c = 0; c < columns; c++) {
result[r, c] = operation(m[r, c], number);
}
}
return result;
}
public static void Print(this double[,] m) {
if (m == null) throw new ArgumentNullException();
int rows = m.GetLength(0), columns = m.GetLength(1);
for (int r = 0; r < rows; r++) {
Console.WriteLine("[ " + string.Join(", ", Enumerable.Range(0, columns).Select(c => m[r, c])) + " ]");
}
}
}
public class Program
{
public static void Main() {
double[,] matrix = {
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }
};
double[,] tens = {
{ 10, 10, 10, 10 },
{ 20, 20, 20, 20 },
{ 30, 30, 30, 30 }
};
matrix.Print();
WriteLine();
(matrix = matrix.DoOperation("add", tens)).Print();
WriteLine();
matrix.DoOperation((a, b) => b - a, 100).Print();
}
}</syntaxhighlight>
{{out}}
<pre>
[ 1, 2, 3, 4 ]
[ 5, 6, 7, 8 ]
[ 9, 10, 11, 12 ]
[ 11, 12, 13, 14 ]
[ 25, 26, 27, 28 ]
[ 39, 40, 41, 42 ]
[ 89, 88, 87, 86 ]
[ 75, 74, 73, 72 ]
[ 61, 60, 59, 58 ]</pre>
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <cassert>
#include <cmath>
#include <iostream>
#include <valarray>
template <typename scalar_type> class matrix {
public:
matrix(size_t rows, size_t columns) : rows_(rows), columns_(columns) {
elements_.resize(rows * columns);
}
matrix(size_t rows, size_t columns, scalar_type value)
: rows_(rows), columns_(columns), elements_(value, rows * columns) {}
size_t rows() const { return rows_; }
size_t columns() const { return columns_; }
const scalar_type& at(size_t row, size_t column) const {
assert(row < rows_);
assert(column < columns_);
return elements_[index(row, column)];
}
scalar_type& at(size_t row, size_t column) {
assert(row < rows_);
assert(column < columns_);
return elements_[index(row, column)];
}
matrix& operator+=(scalar_type e) {
elements_ += e;
return *this;
}
matrix& operator-=(scalar_type e) {
elements_ -= e;
return *this;
}
matrix& operator*=(scalar_type e) {
elements_ *= e;
return *this;
}
matrix& operator/=(scalar_type e) {
elements_ /= e;
return *this;
}
matrix& operator+=(const matrix& other) {
assert(rows_ == other.rows_);
assert(columns_ == other.columns_);
elements_ += other.elements_;
return *this;
}
matrix& operator-=(const matrix& other) {
assert(rows_ == other.rows_);
assert(columns_ == other.columns_);
elements_ -= other.elements_;
return *this;
}
matrix& operator*=(const matrix& other) {
assert(rows_ == other.rows_);
assert(columns_ == other.columns_);
elements_ *= other.elements_;
return *this;
}
matrix& operator/=(const matrix& other) {
assert(rows_ == other.rows_);
assert(columns_ == other.columns_);
elements_ /= other.elements_;
return *this;
}
matrix& negate() {
for (scalar_type& element : elements_)
element = -element;
return *this;
}
matrix& invert() {
for (scalar_type& element : elements_)
element = 1 / element;
return *this;
}
friend matrix pow(const matrix& a, scalar_type b) {
return matrix(a.rows_, a.columns_, std::pow(a.elements_, b));
}
friend matrix pow(const matrix& a, const matrix& b) {
assert(a.rows_ == b.rows_);
assert(a.columns_ == b.columns_);
return matrix(a.rows_, a.columns_, std::pow(a.elements_, b.elements_));
}
private:
matrix(size_t rows, size_t columns, std::valarray<scalar_type>&& values)
: rows_(rows), columns_(columns), elements_(std::move(values)) {}
size_t index(size_t row, size_t column) const {
return row * columns_ + column;
}
size_t rows_;
size_t columns_;
std::valarray<scalar_type> elements_;
};
template <typename scalar_type>
matrix<scalar_type> operator+(const matrix<scalar_type>& a, scalar_type b) {
matrix<scalar_type> c(a);
c += b;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator-(const matrix<scalar_type>& a, scalar_type b) {
matrix<scalar_type> c(a);
c -= b;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator*(const matrix<scalar_type>& a, scalar_type b) {
matrix<scalar_type> c(a);
c *= b;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator/(const matrix<scalar_type>& a, scalar_type b) {
matrix<scalar_type> c(a);
c /= b;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator+(scalar_type a, const matrix<scalar_type>& b) {
matrix<scalar_type> c(b);
c += a;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator-(scalar_type a, const matrix<scalar_type>& b) {
matrix<scalar_type> c(b);
c.negate() += a;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator*(scalar_type a, const matrix<scalar_type>& b) {
matrix<scalar_type> c(b);
c *= a;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator/(scalar_type a, const matrix<scalar_type>& b) {
matrix<scalar_type> c(b);
c.invert() *= a;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator+(const matrix<scalar_type>& a,
const matrix<scalar_type>& b) {
matrix<scalar_type> c(a);
c += b;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator-(const matrix<scalar_type>& a,
const matrix<scalar_type>& b) {
matrix<scalar_type> c(a);
c -= b;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator*(const matrix<scalar_type>& a,
const matrix<scalar_type>& b) {
matrix<scalar_type> c(a);
c *= b;
return c;
}
template <typename scalar_type>
matrix<scalar_type> operator/(const matrix<scalar_type>& a,
const matrix<scalar_type>& b) {
matrix<scalar_type> c(a);
c /= b;
return c;
}
template <typename scalar_type>
void print(std::ostream& out, const matrix<scalar_type>& matrix) {
out << '[';
size_t rows = matrix.rows(), columns = matrix.columns();
for (size_t row = 0; row < rows; ++row) {
if (row > 0)
out << ", ";
out << '[';
for (size_t column = 0; column < columns; ++column) {
if (column > 0)
out << ", ";
out << matrix.at(row, column);
}
out << ']';
}
out << "]\n";
}
void test_matrix_matrix() {
const size_t rows = 3, columns = 2;
matrix<double> a(rows, columns);
for (size_t i = 0; i < rows; ++i) {
for (size_t j = 0; j < columns; ++j)
a.at(i, j) = double(columns * i + j + 1);
}
matrix<double> b(a);
std::cout << "a + b:\n";
print(std::cout, a + b);
std::cout << "\na - b:\n";
print(std::cout, a - b);
std::cout << "\na * b:\n";
print(std::cout, a * b);
std::cout << "\na / b:\n";
print(std::cout, a / b);
std::cout << "\npow(a, b):\n";
print(std::cout, pow(a, b));
}
void test_matrix_scalar() {
const size_t rows = 3, columns = 4;
matrix<double> a(rows, columns);
for (size_t i = 0; i < rows; ++i) {
for (size_t j = 0; j < columns; ++j)
a.at(i, j) = double(columns * i + j + 1);
}
std::cout << "a + 10:\n";
print(std::cout, a + 10.0);
std::cout << "\na - 10:\n";
print(std::cout, a - 10.0);
std::cout << "\n10 - a:\n";
print(std::cout, 10.0 - a);
std::cout << "\na * 10:\n";
print(std::cout, a * 10.0);
std::cout << "\na / 10:\n";
print(std::cout, a / 10.0);
std::cout << "\npow(a, 0.5):\n";
print(std::cout, pow(a, 0.5));
}
int main() {
test_matrix_matrix();
std::cout << '\n';
test_matrix_scalar();
return 0;
}</syntaxhighlight>
{{out}}
<pre>
a + b:
[[2, 4], [6, 8], [10, 12]]
a - b:
[[0, 0], [0, 0], [0, 0]]
a * b:
[[1, 4], [9, 16], [25, 36]]
a / b:
[[1, 1], [1, 1], [1, 1]]
pow(a, b):
[[1, 4], [27, 256], [3125, 46656]]
a + 10:
[[11, 12, 13, 14], [15, 16, 17, 18], [19, 20, 21, 22]]
a - 10:
[[-9, -8, -7, -6], [-5, -4, -3, -2], [-1, 0, 1, 2]]
10 - a:
[[9, 8, 7, 6], [5, 4, 3, 2], [1, 0, -1, -2]]
a * 10:
[[10, 20, 30, 40], [50, 60, 70, 80], [90, 100, 110, 120]]
a / 10:
[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8], [0.9, 1, 1.1, 1.2]]
pow(a, 0.5):
[[1, 1.41421, 1.73205, 2], [2.23607, 2.44949, 2.64575, 2.82843], [3, 3.16228, 3.31662, 3.4641]]
</pre>
=={{header|Clojure}}==
This function is for vector matrices; for list matrices, change the (vector?) function to the (list?) function and remove all the (vec) functions.
<
(vec (repeat i1 (vec (repeat i2 value)))))
Line 324 ⟶ 870:
(vec (map #(vec (map f %1 %2)) mtx1 mtx2)))
(recur f (initial-mtx (count mtx2) (count (first mtx2)) mtx1) mtx2)
))</
The mtx1 argument can either be a matrix or scalar; the function will sort the difference.
=={{header|Common Lisp}}==
Element-wise matrix-matrix operations. Matrices are represented as 2D-arrays.
<
(let* ((len (array-total-size A))
(m (car (array-dimensions A)))
Line 347 ⟶ 893:
(defun m* (A B) (element-wise-matrix #'* A B))
(defun m/ (A B) (element-wise-matrix #'/ A B))
(defun m^ (A B) (element-wise-matrix #'expt A B))</
Elementwise scalar-matrix operations.
<
(let* ((len (array-total-size A))
(m (car (array-dimensions A)))
Line 368 ⟶ 914:
(defun .* (c A) (element-wise-scalar #'* A c))
(defun ./ (A c) (element-wise-scalar #'/ A c))
(defun .^ (A c) (element-wise-scalar #'expt A c))</
=={{header|D}}==
<
T[][] elementwise(string op, T, U)(in T[][] A, in U B) {
Line 385 ⟶ 931:
writefln("%s:\n[%([%(%d, %)],\n %)]]\n\n[%([%(%d, %)],\n %)]]\n",
op, elementwise!op(M, 2), elementwise!op(M, M));
}</
{{out}}
<pre>+:
Line 433 ⟶ 979:
This alternative version offers more guarantees, same output:
<
T[][] elementwise(string op, T, U)(in T[][] A, in U B)
Line 468 ⟶ 1,014:
writefln(matFormat, elementwise!op(matrix, matrix));
}
}</
=={{header|Excel}}==
===LAMBDA===
Excel arithmetic operators are automatically lifted over array / matrix (grid) arguments.
In the examples below we are assuming the following bindings in the work-book Name Manager:
(See [https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ LAMBDA: The ultimate Excel worksheet function])
{{Works with|Office 365 betas 2021}}
<syntaxhighlight lang="lisp">EVAL
=LAMBDA(s, EVALUATE(s))
matrix
={1,2,3;4,5,6;7,8,9}</syntaxhighlight>
{{Out}}
{| class="wikitable"
|-
|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx
! colspan="4" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=EVAL(A2)
|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"
|
| A
| B
| C
| D
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2
| style="text-align:right; font-weight:bold" | matrix + matrix
| style="text-align:right; background-color:#cbcefb" | 2
| style="text-align:right" | 4
| style="text-align:right" | 6
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 3
| style="font-weight:bold" |
| style="text-align:right" | 8
| style="text-align:right" | 10
| style="text-align:right" | 12
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 4
| style="font-weight:bold" |
| style="text-align:right" | 14
| style="text-align:right" | 16
| style="text-align:right" | 18
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 5
| style="font-weight:bold" |
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 6
| style="text-align:right; font-weight:bold" | matrix - matrix
| style="text-align:right" | 0
| style="text-align:right" | 0
| style="text-align:right" | 0
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 7
| style="font-weight:bold" |
| style="text-align:right" | 0
| style="text-align:right" | 0
| style="text-align:right" | 0
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 8
| style="font-weight:bold" |
| style="text-align:right" | 0
| style="text-align:right" | 0
| style="text-align:right" | 0
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 9
| style="font-weight:bold" |
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 10
| style="text-align:right; font-weight:bold" | matrix * matrix
| style="text-align:right" | 1
| style="text-align:right" | 4
| style="text-align:right" | 9
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 11
|
| style="text-align:right" | 16
| style="text-align:right" | 25
| style="text-align:right" | 36
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 12
|
| style="text-align:right" | 49
| style="text-align:right" | 64
| style="text-align:right" | 81
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 13
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 14
| style="text-align:right; font-weight:bold" | matrix / matrix
| style="text-align:right" | 1
| style="text-align:right" | 4
| style="text-align:right" | 9
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 15
|
| style="text-align:right" | 16
| style="text-align:right" | 25
| style="text-align:right" | 36
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 16
|
| style="text-align:right" | 49
| style="text-align:right" | 64
| style="text-align:right" | 81
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 17
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 18
| style="text-align:right; font-weight:bold" | matrix + {1,2,3}
| style="text-align:right" | 2
| style="text-align:right" | 4
| style="text-align:right" | 6
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 19
|
| style="text-align:right" | 5
| style="text-align:right" | 7
| style="text-align:right" | 9
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 20
|
| style="text-align:right" | 8
| style="text-align:right" | 10
| style="text-align:right" | 12
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 21
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 22
| style="text-align:right; font-weight:bold" | matrix - {1,2,3}
| style="text-align:right" | 0
| style="text-align:right" | 0
| style="text-align:right" | 0
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 23
|
| style="text-align:right" | 3
| style="text-align:right" | 3
| style="text-align:right" | 3
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 24
|
| style="text-align:right" | 6
| style="text-align:right" | 6
| style="text-align:right" | 6
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 25
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 26
| style="text-align:right; font-weight:bold" | matrix * {1,2,3}
| style="text-align:right" | 1
| style="text-align:right" | 4
| style="text-align:right" | 9
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 27
|
| style="text-align:right" | 4
| style="text-align:right" | 10
| style="text-align:right" | 18
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 28
|
| style="text-align:right" | 7
| style="text-align:right" | 16
| style="text-align:right" | 27
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 29
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 30
| style="text-align:right; font-weight:bold" | matrix / {1,2,3}
| style="text-align:right" | 1
| style="text-align:right" | 1
| style="text-align:right" | 1
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 31
|
| style="text-align:right" | 4
| style="text-align:right" | 2.5
| style="text-align:right" | 2
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 32
|
| style="text-align:right" | 7
| style="text-align:right" | 4
| style="text-align:right" | 3
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 33
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 34
| style="text-align:right; font-weight:bold" | matrix + 2
| style="text-align:right" | 3
| style="text-align:right" | 4
| style="text-align:right" | 5
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 35
| style="font-weight:bold" |
| style="text-align:right" | 6
| style="text-align:right" | 7
| style="text-align:right" | 8
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 36
| style="font-weight:bold" |
| style="text-align:right" | 9
| style="text-align:right" | 10
| style="text-align:right" | 11
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 37
| style="font-weight:bold" |
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 38
| style="text-align:right; font-weight:bold" | matrix - 1
| style="text-align:right" | 0
| style="text-align:right" | 1
| style="text-align:right" | 2
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 39
| style="font-weight:bold" |
| style="text-align:right" | 3
| style="text-align:right" | 4
| style="text-align:right" | 5
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 40
| style="font-weight:bold" |
| style="text-align:right" | 6
| style="text-align:right" | 7
| style="text-align:right" | 8
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 41
| style="font-weight:bold" |
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 42
| style="text-align:right; font-weight:bold" | matrix * 2
| style="text-align:right" | 2
| style="text-align:right" | 4
| style="text-align:right" | 6
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 43
| style="font-weight:bold" |
| style="text-align:right" | 8
| style="text-align:right" | 10
| style="text-align:right" | 12
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 44
| style="font-weight:bold" |
| style="text-align:right" | 14
| style="text-align:right" | 16
| style="text-align:right" | 18
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 45
| style="font-weight:bold" |
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 46
| style="text-align:right; font-weight:bold" | matrix / 2
| style="text-align:right" | 0.5
| style="text-align:right" | 1
| style="text-align:right" | 1.5
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 47
|
| style="text-align:right" | 2
| style="text-align:right" | 2.5
| style="text-align:right" | 3
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 48
|
| style="text-align:right" | 3.5
| style="text-align:right" | 4
| style="text-align:right" | 4.5
|}
=={{header|Factor}}==
The <code>math.matrices</code> vocabulary provides matrix-matrix and matrix-scalar arithmetic words. I wasn't able to find any for exponentiation, so I wrote them.
<syntaxhighlight lang="factor">USING: combinators.extras formatting kernel math.functions
math.matrices math.vectors prettyprint sequences ;
: show ( a b words -- )
[
3dup execute( x x -- x ) [ unparse ] dip
"%u %u %s = %u\n" printf
] 2with each ; inline
: m^n ( m n -- m ) [ ^ ] curry matrix-map ;
: m^ ( m m -- m ) [ v^ ] 2map ;
{ { 1 2 } { 3 4 } } { { 5 6 } { 7 8 } } { m+ m- m* m/ m^ }
{ { -1 9 4 } { 5 -13 0 } } 3 { m+n m-n m*n m/n m^n }
[ show ] 3bi@</syntaxhighlight>
{{out}}
<pre>
{ { 1 2 } { 3 4 } } { { 5 6 } { 7 8 } } m+ = { { 6 8 } { 10 12 } }
{ { 1 2 } { 3 4 } } { { 5 6 } { 7 8 } } m- = { { -4 -4 } { -4 -4 } }
{ { 1 2 } { 3 4 } } { { 5 6 } { 7 8 } } m* = { { 5 12 } { 21 32 } }
{ { 1 2 } { 3 4 } } { { 5 6 } { 7 8 } } m/ = { { 1/5 1/3 } { 3/7 1/2 } }
{ { 1 2 } { 3 4 } } { { 5 6 } { 7 8 } } m^ = { { 1 64 } { 2187 65536 } }
{ { -1 9 4 } { 5 -13 0 } } 3 m+n = { { 2 12 7 } { 8 -10 3 } }
{ { -1 9 4 } { 5 -13 0 } } 3 m-n = { { -4 6 1 } { 2 -16 -3 } }
{ { -1 9 4 } { 5 -13 0 } } 3 m*n = { { -3 27 12 } { 15 -39 0 } }
{ { -1 9 4 } { 5 -13 0 } } 3 m/n = { { -1/3 3 1+1/3 } { 1+2/3 -4-1/3 0 } }
{ { -1 9 4 } { 5 -13 0 } } 3 m^n = { { -1 729 64 } { 125 -2197 0 } }
</pre>
=={{header|Fortran}}==
All element based operations are suported by default in Fortran(90+)
<syntaxhighlight lang="fortran">
program element_operations
implicit none
real(kind=4), dimension(3,3) :: a,b
integer :: i
a=reshape([(i,i=1,9)],shape(a))
print*,'addition'
b=a+a
call print_arr(b)
print*,'multiplication'
b=a*a
call print_arr(b)
print*,'division'
b=a/b
call print_arr(b)
print*,'exponentiation'
b=a**a
call print_arr(b)
print*,'trignometric'
b=cos(a)
call print_arr(b)
print*,'mod'
b=mod(int(a),3)
call print_arr(b)
print*,'element selection'
b=0
where(a>3) b=1
call print_arr(b)
print*,'elemental functions can be applied to single values:'
print*,square(3.0)
print*,'or element wise to arrays:'
b=square(a)
call print_arr(b)
contains
elemental real function square(a)
real, intent(in) :: a
square=a*a
end function square
subroutine print_arr(arr)
real, intent(in) :: arr(:,:)
integer :: i
do i=1,size(arr,dim=2)
print*,arr(:,i)
end do
end subroutine print_arr
end program element_operations
</syntaxhighlight>
{{out}}
<pre>
addition
2.00000000 4.00000000 6.00000000
8.00000000 10.0000000 12.0000000
14.0000000 16.0000000 18.0000000
multiplication
1.00000000 4.00000000 9.00000000
16.0000000 25.0000000 36.0000000
49.0000000 64.0000000 81.0000000
division
1.00000000 0.500000000 0.333333343
0.250000000 0.200000003 0.166666672
0.142857149 0.125000000 0.111111112
exponentiation
1.00000000 4.00000000 27.0000000
256.000000 3125.00000 46656.0000
823543.000 16777216.0 387420480.
trignometric
0.540302277 -0.416146845 -0.989992499
-0.653643608 0.283662200 0.960170269
0.753902256 -0.145500034 -0.911130250
mod
1.00000000 2.00000000 0.00000000
1.00000000 2.00000000 0.00000000
1.00000000 2.00000000 0.00000000
element selection
0.00000000 0.00000000 0.00000000
1.00000000 1.00000000 1.00000000
1.00000000 1.00000000 1.00000000
elemental functions can be applied to single values:
9.00000000
or element wise to arrays:
1.00000000 4.00000000 9.00000000
16.0000000 25.0000000 36.0000000
49.0000000 64.0000000 81.0000000
</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">Dim Shared As Double a(1,2) = {{7, 8, 7}, {4, 0, 9}}
Dim Shared As Double b(1,2) = {{4, 5, 1}, {6, 2, 1}}
Dim Shared As Double c(1,2)
Dim Shared As Double fila, columna
Dim Shared As String p
Sub list(a() As Double)
p = "["
For fila = 0 To Ubound(a,1)
p &= "["
For columna = 0 To Ubound(b,2)
p &= Str(a(fila, columna)) + ", "
Next columna
p = Left(p,Len(p)-2) + "]"
Next fila
p &= "]"
Print p;
End Sub
REM Matrix-Matrix:
Sub Mostrarmm(a() As Double, op As String, b() As Double, c() As Double)
list(a()) : Print " "; op; " "; : list(b()) : Print " = "; : list(c()) : Print
End Sub
Sub addmm(a() As Double, b() As Double, c() As Double)
REM adición
For fila = Lbound(a,1) To Ubound(a,1)
For columna = Lbound(b,2) To Ubound(b,2)
c(fila, columna) = a(fila,columna) + b(fila,columna)
Next columna
Next fila
End Sub
Sub resmm(a() As Double, b() As Double, c() As Double)
REM sustracción
For fila = Lbound(a,1) To Ubound(a,1)
For columna = Lbound(b,2) To Ubound(b,2)
c(fila, columna) = a(fila,columna) - b(fila,columna)
Next columna
Next fila
End Sub
Sub mulmm(a() As Double, b() As Double, c() As Double)
REM multiplicación
For fila = Lbound(a,1) To Ubound(a,1)
For columna = Lbound(b,2) To Ubound(b,2)
c(fila, columna) = a(fila,columna) * b(fila,columna)
Next columna
Next fila
End Sub
Sub divmm(a() As Double, b() As Double, c() As Double)
REM división
For fila = Lbound(a,1) To Ubound(a,1)
For columna = Lbound(b,2) To Ubound(b,2)
c(fila, columna) = a(fila,columna) / b(fila,columna)
Next columna
Next fila
End Sub
Sub powmm(a() As Double, b() As Double, c() As Double)
REM exponenciación
For fila = Lbound(a,1) To Ubound(a,1)
For columna = Lbound(b,2) To Ubound(b,2)
c(fila, columna) = a(fila,columna) ^ b(fila,columna)
Next columna
Next fila
End Sub
REM Matrix-Scalar:
Sub Mostrarms(a() As Double, op As String, b As Double, c() As Double)
list(a()) : Print " "; op; " "; Str(b); " = "; : list(c()) : Print
End Sub
Sub addms(a() As Double, b As Double, c() As Double)
REM adición
For fila = Lbound(a,1) To Ubound(a,1)
For columna = Lbound(a,2) To Ubound(a,2)
c(fila, columna) = a(fila,columna) + b
Next columna
Next fila
End Sub
Sub resms(a() As Double, b As Double, c() As Double)
REM sustracción
For fila = Lbound(a,1) To Ubound(a,1)
For columna = Lbound(a,2) To Ubound(a,2)
c(fila, columna) = a(fila,columna) - b
Next columna
Next fila
End Sub
Sub mulms(a() As Double, b As Double, c() As Double)
REM multiplicación
For fila = Lbound(a,1) To Ubound(a,1)
For columna = Lbound(a,2) To Ubound(a,2)
c(fila, columna) = a(fila,columna) * b
Next columna
Next fila
End Sub
Sub divms(a() As Double, b As Double, c() As Double)
REM división
For fila = Lbound(a,1) To Ubound(a,1)
For columna = Lbound(a,2) To Ubound(a,2)
c(fila, columna) = a(fila,columna) / b
Next columna
Next fila
End Sub
Sub powms(a() As Double, b As Double, c() As Double)
REM exponenciación
For fila = Lbound(a,1) To Ubound(a,1)
For columna = Lbound(a,2) To Ubound(a,2)
c(fila, columna) = a(fila,columna) ^ b
Next columna
Next fila
End Sub
REM Matrix-Matrix:
addmm(a(), b(), c()) : Mostrarmm(a(), "+", b(), c())
resmm(a(), b(), c()) : Mostrarmm(a(), "-", b(), c())
mulmm(a(), b(), c()) : Mostrarmm(a(), "*", b(), c())
divmm(a(), b(), c()) : Mostrarmm(a(), "/", b(), c())
powmm(a(), b(), c()) : Mostrarmm(a(), "^", b(), c())
Print
REM Matrix-Scalar:
addms(a(), 3, c()) : Mostrarms(a(), "+", 3, c())
resms(a(), 3, c()) : Mostrarms(a(), "-", 3, c())
mulms(a(), 3, c()) : Mostrarms(a(), "*", 3, c())
divms(a(), 3, c()) : Mostrarms(a(), "/", 3, c())
powms(a(), 3, c()) : Mostrarms(a(), "^", 3, c())
Sleep</syntaxhighlight>
{{out}}
<pre>[[7, 8, 7][4, 0, 9]] + [[4, 5, 1][6, 2, 1]] = [[11, 13, 8][10, 2, 10]]
[[7, 8, 7][4, 0, 9]] - [[4, 5, 1][6, 2, 1]] = [[3, 3, 6][-2, -2, 8]]
[[7, 8, 7][4, 0, 9]] * [[4, 5, 1][6, 2, 1]] = [[28, 40, 7][24, 0, 9]]
[[7, 8, 7][4, 0, 9]] / [[4, 5, 1][6, 2, 1]] = [[1.75, 1.6, 7][0.6666666666666666, 0, 9]]
[[7, 8, 7][4, 0, 9]] ^ [[4, 5, 1][6, 2, 1]] = [[2401, 32768, 7][4096, 0, 9]]
[[7, 8, 7][4, 0, 9]] + 3 = [[10, 11, 10][7, 3, 12]]
[[7, 8, 7][4, 0, 9]] - 3 = [[4, 5, 4][1, -3, 6]]
[[7, 8, 7][4, 0, 9]] * 3 = [[21, 24, 21][12, 0, 27]]
[[7, 8, 7][4, 0, 9]] / 3 = [[2.333333333333334, 2.666666666666667, 2.333333333333334][1.333333333333333, 0, 3]]
[[7, 8, 7][4, 0, 9]] ^ 3 = [[343, 512, 343][64, 0, 729]]</pre>
=={{header|Go}}==
A package, which can be referred to in other, higher-order tasks.
<
import (
Line 541 ⟶ 1,691:
func MulScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, mul) }
func DivScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, div) }
func ExpScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, exp) }</
Package use:
<
import (
Line 575 ⟶ 1,725:
h("m1 / s:", element.DivScalar(m1, s))
h("m1 ^ s:", element.ExpScalar(m1, s))
}</
{{out}}
<pre>
Line 618 ⟶ 1,768:
[ 1.000 2.236 3.000]
</pre>
=={{header|Groovy}}==
Solution:
<syntaxhighlight lang="groovy">class NaiveMatrix {
List<List<Number>> contents = []
NaiveMatrix(Iterable<Iterable<Number>> elements) {
contents.addAll(elements.collect{ row -> row.collect{ cell -> cell } })
assertWellFormed()
}
void assertWellFormed() {
assert contents != null
assert contents.size() > 0
def nCols = contents[0].size()
assert nCols > 0
assert contents.every { it != null && it.size() == nCols }
}
Map getOrder() { [r: contents.size() , c: contents[0].size()] }
void assertConformable(NaiveMatrix that) { assert this.order == that.order }
NaiveMatrix unaryOp(Closure op) {
new NaiveMatrix(contents.collect{ row -> row.collect{ cell -> op(cell) } } )
}
NaiveMatrix binaryOp(NaiveMatrix m, Closure op) {
assertConformable(m)
new NaiveMatrix(
(0..<(this.order.r)).collect{ i ->
(0..<(this.order.c)).collect{ j -> op(this.contents[i][j],m.contents[i][j]) }
}
)
}
NaiveMatrix binaryOp(Number n, Closure op) {
assert n != null
new NaiveMatrix(contents.collect{ row -> row.collect{ cell -> op(cell,n) } } )
}
def plus = this.&binaryOp.rcurry { a, b -> a+b }
def minus = this.&binaryOp.rcurry { a, b -> a-b }
def multiply = this.&binaryOp.rcurry { a, b -> a*b }
def div = this.&binaryOp.rcurry { a, b -> a/b }
def mod = this.&binaryOp.rcurry { a, b -> a%b }
def power = this.&binaryOp.rcurry { a, b -> a**b }
def negative = this.&unaryOp.curry { - it }
def recip = this.&unaryOp.curry { 1/it }
String toString() {
contents.toString()
}
boolean equals(Object other) {
if (other == null || ! other instanceof NaiveMatrix) return false
def that = other as NaiveMatrix
this.contents == that.contents
}
int hashCode() {
contents.hashCode()
}
}</syntaxhighlight>
The following ''NaiveMatrixCategory'' class allows for modification of regular ''Number'' behavior when interacting with ''NaiveMatrix''.
<syntaxhighlight lang="groovy">import org.codehaus.groovy.runtime.DefaultGroovyMethods
class NaiveMatrixCategory {
static NaiveMatrix plus (Number a, NaiveMatrix b) { b + a }
static NaiveMatrix minus (Number a, NaiveMatrix b) { -b + a }
static NaiveMatrix multiply (Number a, NaiveMatrix b) { b * a }
static NaiveMatrix div (Number a, NaiveMatrix b) { a * b.recip() }
static NaiveMatrix power (Number a, NaiveMatrix b) { b.binaryOp(a) { elt, scalar -> scalar ** elt } }
static NaiveMatrix mod (Number a, NaiveMatrix b) { b.binaryOp(a) { elt, scalar -> scalar % elt } }
static <T> T asType (Number a, Class<T> type) {
type == NaiveMatrix \
? [[a]] as NaiveMatrix
: DefaultGroovyMethods.asType(a, type)
}
}</syntaxhighlight>
Test:
<syntaxhighlight lang="groovy">Number.metaClass.mixin NaiveMatrixCategory
println 'Demo 1: functionality as requested'
def a = [[5,3],[4,2]] as NaiveMatrix
println 'a == ' + a
def b = new NaiveMatrix([[1,2],[7,8]])
println 'b == ' + b
def z = [[0,0],[0,0]] as NaiveMatrix
println "a + b == (${a}) + (${b}) == " + (a + b)
println "a - b == (${a}) - (${b}) == " + (a - b)
println "a * b == (${a}) * (${b}) == " + (a * b)
println "a / b == (${a}) / (${b}) == " + (a / b)
println "a ** b == (${a}) ** (${b}) == " + (a ** b)
println '\nDemo 2: Extended functionality'
println "a % b == (${a}) % (${b}) == " + (a % b)
println '\nDemo 3: Element-wise scalar operations'
println "2 + b == 2 + (${b}) == " + (2 + b)
println "2 - b == 2 - (${b}) == " + (2 - b)
println "2 * b == 2 * (${b}) == " + (2 * b)
println "2 / b == 2 / (${b}) == " + (2 / b)
println "2 ** b == 2 ** (${b}) == " + (2 ** b)
println "2 % b == 2 % (${b}) == " + (2 % b)
println "\na + 2 == (${a}) + 2 == " + (a + 2)
println "a - 2 == (${a}) - 2 == " + (a - 2)
println "a * 2 == (${a}) * 2 == " + (a * 2)
println "a / 2 == (${a}) / 2 == " + (a / 2)
println "a ** 2 == (${a}) ** 2 == " + (a ** 2)
println "a % 2 == (${a}) % 2 == " + (a % 2)</syntaxhighlight>
Output:
<pre>Demo 1: functionality as requested
a == [[5, 3], [4, 2]]
b == [[1, 2], [7, 8]]
a + b == ([[5, 3], [4, 2]]) + ([[1, 2], [7, 8]]) == [[6, 5], [11, 10]]
a - b == ([[5, 3], [4, 2]]) - ([[1, 2], [7, 8]]) == [[4, 1], [-3, -6]]
a * b == ([[5, 3], [4, 2]]) * ([[1, 2], [7, 8]]) == [[5, 6], [28, 16]]
a / b == ([[5, 3], [4, 2]]) / ([[1, 2], [7, 8]]) == [[5, 1.5], [0.5714285714, 0.25]]
a ** b == ([[5, 3], [4, 2]]) ** ([[1, 2], [7, 8]]) == [[5, 9], [16384, 256]]
Demo 2: Extended functionality
a % b == ([[5, 3], [4, 2]]) % ([[1, 2], [7, 8]]) == [[0, 1], [4, 2]]
Demo 3: Element-wise scalar operations
2 + b == 2 + ([[1, 2], [7, 8]]) == [[3, 4], [9, 10]]
2 - b == 2 - ([[1, 2], [7, 8]]) == [[1, 0], [-5, -6]]
2 * b == 2 * ([[1, 2], [7, 8]]) == [[2, 4], [14, 16]]
2 / b == 2 / ([[1, 2], [7, 8]]) == [[2, 1.0], [0.2857142858, 0.250]]
2 ** b == 2 ** ([[1, 2], [7, 8]]) == [[2, 4], [128, 256]]
2 % b == 2 % ([[1, 2], [7, 8]]) == [[0, 0], [2, 2]]
a + 2 == ([[5, 3], [4, 2]]) + 2 == [[7, 5], [6, 4]]
a - 2 == ([[5, 3], [4, 2]]) - 2 == [[3, 1], [2, 0]]
a * 2 == ([[5, 3], [4, 2]]) * 2 == [[10, 6], [8, 4]]
a / 2 == ([[5, 3], [4, 2]]) / 2 == [[2.5, 1.5], [2, 1]]
a ** 2 == ([[5, 3], [4, 2]]) ** 2 == [[25, 9], [16, 4]]
a % 2 == ([[5, 3], [4, 2]]) % 2 == [[1, 1], [0, 0]]</pre>
=={{header|Haskell}}==
Matrices are represented here as Immutable Arrays.
<
{-# LANGUAGE RankNTypes #-}
Line 749 ⟶ 2,047:
print $ m1 **. s
putStrLn "m1 ^^ s"
print $ m1 ^^. s</
{{out}}
<pre>m1
Line 796 ⟶ 2,094:
It would be easy to replace this with another construct to produce a version that works in both languages.
The output flattens each displayed matrix onto a single line to save space here.
<
a := [[1,2,3],[4,5,6],[7,8,9]]
b := [[9,8,7],[6,5,4],[3,2,1]]
Line 832 ⟶ 2,130:
procedure showMat(label, m)
every writes(label | right(!!m,5) | "\n")
end</
{{out}}
Line 853 ⟶ 2,151:
=={{header|J}}==
'''Solution''': J's arithmetical primitives act elementwise by default (in J parlance, such operations are known as "scalar" or "rank zero", which means they generalize to high-order arrays transparently, operating elementwise). Thus: <
vector =: 2 3 5
matrix =: 3 3 $ 7 11 13 17 19 23 29 31 37
Line 876 ⟶ 2,174:
49 121 169
289 361 529
841 961 1369</
Note that in some branches of mathematics, it has been traditional to define multiplication such that it is not performed element-wise. This can introduce some complications ([[wp:Einstein notation]] is arguably the best approach for resolving those complexities in latex, when they occur frequently enough that mentioning and using the notation is not more complicated than explicitly describing the multiply-and-sum) and makes expressing element-wise multiplication complicated. J deals with this conflict by making its multiplication primitive be elementwise (consistent with the rest of the language) and by using a different verb (typically +/ .*) to represent the traditional non-element-wise multiply and sum operation.
=={{header|Java}}==
<syntaxhighlight lang="java">
import java.util.Arrays;
import java.util.HashMap;
Line 940 ⟶ 2,239:
}
}
</syntaxhighlight>
=={{header|jq}}==
Line 964 ⟶ 2,263:
'''Part 1'''
<
# and occurrences of .[1] will refer to the corresponding element in other.
def elementwise( operator; other ):
Line 975 ⟶ 2,274:
([]; reduce range(0; $cols) as $j
(.; .[$i][$j] = ([$self[$i][$j], $other[$i][$j]] | operator) ) )
end ;</
'''Example''':
<
| ( ($m1|elementwise(.[0] + .[1]; $m2) ),
($m1|elementwise(.[0] + 2 * .[1]; $m2) ),
($m1|elementwise(.[0] < .[1]; $m2) ) )
</syntaxhighlight>
{{Out}}
<
[[7,15,6],[17,9,13]]
[[false,true,false],[true,false,false]]
</syntaxhighlight>
'''Part 2'''
Line 997 ⟶ 2,296:
polymorphic. For example, + is defined on strings and other types
besides numbers.
<
def pow(i): . as $in | reduce range(0;i) as $i (1; .*$in);
def operation(x; op; y):
Line 1,019 ⟶ 2,318:
([]; reduce range(0; $cols) as $j
(.; .[$i][$j] = operation($self[$i][$j]; operator; $other[$i][$j] ) ) )
end;</
'''Example''':
<
| ( ($m1|elementwise2("+"; $m2) ),
($m1|elementwise2("//"; $m2)),
($m1|elementwise2(.[0] < .[1]; $m2) ) )</
{{Out}}
<
[[1,0,4],[0,2,4]]
[[false,true,false],[true,false,false]]
</syntaxhighlight>
=={{header|Julia}}==
In Julia operations with `.` before are for convention Element-wise:
<syntaxhighlight lang="julia">@show [1 2 3; 3 2 1] .+ [2 1 2; 0 2 1]
@show [1 2 3; 2 1 2] .+ 1
@show [1 2 3; 2 2 1] .- [1 1 1; 2 1 0]
@show [1 2 1; 1 2 3] .* [3 2 1; 1 0 1]
@show [1 2 3; 3 2 1] .* 2
@show [9 8 6; 3 2 3] ./ [3 1 2; 2 1 2]
@show [3 2 2; 1 2 3] .^ [1 2 3; 2 1 2]</syntaxhighlight>
{{out}}
<pre>[1 2 3; 3 2 1] .+ [2 1 2; 0 2 1] = [3 3 5; 3 4 2]
[1 2 3; 2 1 2] .+ 1 = [2 3 4; 3 2 3]
[1 2 3; 2 2 1] .- [1 1 1; 2 1 0] = [0 1 2; 0 1 1]
[1 2 1; 1 2 3] .* [3 2 1; 1 0 1] = [3 4 1; 1 0 3]
[1 2 3; 3 2 1] .* 2 = [2 4 6; 6 4 2]
[9 8 6; 3 2 3] ./ [3 1 2; 2 1 2] = [3.0 8.0 3.0; 1.5 2.0 1.5]
[3 2 2; 1 2 3] .^ [1 2 3; 2 1 2] = [3 4 8; 1 2 9]</pre>
=={{header|K}}==
{{trans|J}}
<
vector: 2 3 5
matrix: 3 3 # 7 11 13 17 19 23 29 31 37
Line 1,058 ⟶ 2,376:
289 361 529
841 961 1369)
</
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.51
typealias Matrix = Array<DoubleArray>
typealias Op = Double.(Double) -> Double
fun Double.dPow(exp: Double) = Math.pow(this, exp)
fun Matrix.elementwiseOp(other: Matrix, op: Op): Matrix {
require(this.size == other.size && this[0].size == other[0].size)
val result = Array(this.size) { DoubleArray(this[0].size) }
for (i in 0 until this.size) {
for (j in 0 until this[0].size) result[i][j] = this[i][j].op(other[i][j])
}
return result
}
fun Matrix.elementwiseOp(d: Double, op: Op): Matrix {
val result = Array(this.size) { DoubleArray(this[0].size) }
for (i in 0 until this.size) {
for (j in 0 until this[0].size) result[i][j] = this[i][j].op(d)
}
return result
}
fun Matrix.print(name: Char?, scalar: Boolean? = false) {
println(when (scalar) {
true -> "m $name s"
false -> "m $name m"
else -> "m"
} + ":")
for (i in 0 until this.size) println(this[i].asList())
println()
}
fun main(args: Array<String>) {
val ops = listOf(Double::plus, Double::minus, Double::times, Double::div, Double::dPow)
val names = "+-*/^"
val m = arrayOf(
doubleArrayOf(3.0, 5.0, 7.0),
doubleArrayOf(1.0, 2.0, 3.0),
doubleArrayOf(2.0, 4.0, 6.0)
)
m.print(null, null)
for ((i, op) in ops.withIndex()) m.elementwiseOp(m, op).print(names[i])
val s = 2.0
println("s = $s:\n")
for ((i, op) in ops.withIndex()) m.elementwiseOp(s, op).print(names[i], true)
}</syntaxhighlight>
{{out}}
<pre>
m:
[3.0, 5.0, 7.0]
[1.0, 2.0, 3.0]
[2.0, 4.0, 6.0]
m + m:
[6.0, 10.0, 14.0]
[2.0, 4.0, 6.0]
[4.0, 8.0, 12.0]
m - m:
[0.0, 0.0, 0.0]
[0.0, 0.0, 0.0]
[0.0, 0.0, 0.0]
m * m:
[9.0, 25.0, 49.0]
[1.0, 4.0, 9.0]
[4.0, 16.0, 36.0]
m / m:
[1.0, 1.0, 1.0]
[1.0, 1.0, 1.0]
[1.0, 1.0, 1.0]
m ^ m:
[27.0, 3125.0, 823543.0]
[1.0, 4.0, 27.0]
[4.0, 256.0, 46656.0]
s = 2.0:
m + s:
[5.0, 7.0, 9.0]
[3.0, 4.0, 5.0]
[4.0, 6.0, 8.0]
m - s:
[1.0, 3.0, 5.0]
[-1.0, 0.0, 1.0]
[0.0, 2.0, 4.0]
m * s:
[6.0, 10.0, 14.0]
[2.0, 4.0, 6.0]
[4.0, 8.0, 12.0]
m / s:
[1.5, 2.5, 3.5]
[0.5, 1.0, 1.5]
[1.0, 2.0, 3.0]
m ^ s:
[9.0, 25.0, 49.0]
[1.0, 4.0, 9.0]
[4.0, 16.0, 36.0]
</pre>
=={{header|Maple}}==
<syntaxhighlight lang="maple"># Built-in element-wise operator ~
#addition
<1,2,3;4,5,6> +~ 2;
#subtraction
<2,3,1,4;0,-2,-2,1> -~ 4;
#multiplication
<2,3,1,4;0,-2,-2,1> *~ 4;
#division
<2,3,7,9;6,8,4,5;7,0,10,11> /~ 2;
#exponentiation
<1,2,0; 7,2,7; 6,11,3>^~5;</syntaxhighlight>
{{Out|Output}}
<pre>
Matrix(2, 3, [[3, 4, 5], [6, 7, 8]])
Matrix(2, 4, [[-2, -1, -3, 0], [-4, -6, -6, -3]])
Matrix(2, 4, [[8, 12, 4, 16], [0, -8, -8, 4]])
Matrix(3, 4, [[1, 3/2, 7/2, 9/2], [3, 4, 2, 5/2], [7/2, 0, 5, 11/2]])
Matrix(3, 3, [[1, 32, 0], [16807, 32, 16807], [7776, 161051, 243]])
</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
M + S
M - S
Line 1,092 ⟶ 2,546:
20880467999847912034355032910567}, {2567686153161211134561828214731016126483469,
17069174130723235958610643029059314756044734431,
10555134955777783414078330085995832946127396083370199442517}}</
=={{header|MATLAB}}==
<
b = rand(10,10);
scalar_matrix = a * b;
component_wise = b .* b;</
=={{header|Maxima}}==
<
b: matrix([2, 4], [3, 1]);
Line 1,112 ⟶ 2,566:
a^b; /* won't work */
fullmapl("^", a, b);
sin(a);</
=={{header|Nim}}==
<syntaxhighlight lang="nim">import math, strutils
type Matrix[height, width: static Positive; T: SomeNumber] = array[height, array[width, T]]
####################################################################################################
proc `$`(m: Matrix): string =
for i, row in m:
var line = "["
for j, val in row:
line.addSep(" ", 1)
line.add($val)
line.add("]\n")
result.add(line)
####################################################################################################
# Templates.
template elementWise(m1, m2: Matrix; op: proc(v1, v2: m1.T): auto): untyped =
var result: Matrix[m1.height, m1.width, m1.T]
for i in 0..<m1.height:
for j in 0..<m1.width:
result[i][j] = op(m1[i][j], m2[i][j])
result
template scalarOp(m: Matrix; val: SomeNumber; op: proc(v1, v2: SomeNumber): auto): untyped =
var result: Matrix[m.height, m.width, m.T]
for i in 0..<m.height:
for j in 0..<m.width:
result[i][j] = op(m[i][j], val)
result
template scalarOp(val: SomeNumber; m: Matrix; op: proc(v1, v2: SomeNumber): auto): untyped =
var result: Matrix[m.height, m.width, m.T]
for i in 0..<m.height:
for j in 0..<m.width:
result[i][j] = op(val, m[i][j])
result
####################################################################################################
# Access functions.
func `[]`(m: Matrix; i, j: int): m.T =
m[i][j]
func `[]=`(m: var Matrix; i, j: int; val: SomeNumber) =
m[i][j] = val
####################################################################################################
# Elementwise operations.
func `+`(m1, m2: Matrix): Matrix =
elementWise(m1, m2, `+`)
func `-`(m1, m2: Matrix): Matrix =
elementWise(m1, m2, `-`)
func `*`(m1, m2: Matrix): Matrix =
elementWise(m1, m2, `*`)
func `div`(m1, m2: Matrix): Matrix =
elementWise(m1, m2, `div`)
func `mod`(m1, m2: Matrix): Matrix =
elementWise(m1, m2, `mod`)
func `/`(m1, m2: Matrix): Matrix =
elementWise(m1, m2, `/`)
func `^`(m1, m2: Matrix): Matrix =
# Cannot use "elementWise" template as it requires both operator arguments
# to be of type "m1.T" (and second argument of `^` is "Natural", not "int").
for i in 0..<m1.height:
for j in 0..<m1.width:
result[i][j] = m1[i][j] ^ m2[i][j]
func pow(m1, m2: Matrix): Matrix =
elementWise(m1, m2, pow)
####################################################################################################
# Matrix-scalar and scalar-matrix operations.
func `+`(m: Matrix; val: SomeNumber): Matrix =
scalarOp(m, val, `+`)
func `+`(val: SomeNumber; m: Matrix): Matrix =
scalarOp(val, m, `+`)
func `-`(m: Matrix; val: SomeNumber): Matrix =
scalarOp(m, val, `-`)
func `-`(val: SomeNumber; m: Matrix): Matrix =
scalarOp(val, m, `-`)
func `*`(m: Matrix; val: SomeNumber): Matrix =
scalarOp(m, val, `*`)
func `*`(val: SomeNumber; m: Matrix): Matrix =
scalarOp(val, m, `*`)
func `div`(m: Matrix; val: SomeNumber): Matrix =
scalarOp(m, val, `div`)
func `div`(val: SomeNumber; m: Matrix): Matrix =
scalarOp(val, m, `div`)
func `mod`(m: Matrix; val: m.T): Matrix =
scalarOp(m, val, `mod`)
func `mod`(val: SomeNumber; m: Matrix): Matrix =
scalarOp(val, m, `mod`)
proc `/`(m: Matrix; val: SomeNumber): Matrix =
scalarOp(m, val, `/`)
func `/`(val: SomeNumber; m: Matrix): Matrix =
scalarOp(val, m, `/`)
func `^`(m: Matrix; val: Natural): Matrix =
# Cannot use "elementWise" template as it requires both operator arguments
# to be of type "m.T" (and second argument of `^` is "Natural", not "int").
for i in 0..<m.height:
for j in 0..<m.width:
result[i][j] = m[i][j] ^ val
func `^`(val: Natural; m: Matrix): Matrix =
# Cannot use "elementWise" template as it requires both operator arguments
# to be of type "m.T" (and second argument of `^` is "Natural", not "int").
for i in 0..<m.height:
for j in 0..<m.width:
result[i][j] = val ^ m[i][j]
func pow(m: Matrix; val: SomeNumber): Matrix =
scalarOp(m, val, pow)
func `pow`(val: SomeNumber; m: Matrix): Matrix =
scalarOp(val, m, `pow`)
#———————————————————————————————————————————————————————————————————————————————————————————————————
# Operations on integer matrices.
let mint1: Matrix[2, 2, int] = [[1, 2], [3, 4]]
let mint2: Matrix[2, 2, int] = [[2, 1], [4, 2]]
echo "Integer matrices"
echo "----------------\n"
echo "m1:"
echo mint1
echo "m2:"
echo mint2
echo "m1 + m2"
echo mint1 + mint2
echo "m1 - m2"
echo mint1 - mint2
echo "m1 * m2"
echo mint1 * mint2
echo "m1 div m2"
echo mint1 div mint2
echo "m1 mod m2"
echo mint1 mod mint2
echo "m1^m2"
echo mint1^mint2
echo "2 * m1"
echo 2 * mint1
echo "m1 * 2"
echo mint1 * 2
echo "m1^2"
echo mint1 ^ 2
echo "2^m1"
echo 2 ^ mint1
# Operations on float matrices.
let mfloat1: Matrix[2, 3, float] = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]
let mfloat2: Matrix[2, 3, float] = [[2.0, 2.0, 2.0], [3.0, 3.0, 3.0]]
echo "\nFloat matrices"
echo "--------------\n"
echo "m1"
echo mfloat1
echo "m2"
echo mfloat2
echo "m1 + m2"
echo mfloat1 + mfloat2
echo "m1 - m2"
echo mfloat1 - mfloat2
echo "m1 * m2"
echo mfloat1 * mfloat2
echo "m1 / m2"
echo mfloat1 / mfloat2
echo "pow(m1, m2)"
echo pow(mfloat1, mfloat2)
echo "pow(m1, 2.0)"
echo pow(mfloat1, 2.0)
echo "pow(2.0, m1)"
echo pow(2.0, mfloat1)</syntaxhighlight>
{{out}}
<pre>Integer matrices
----------------
m1:
[1 2]
[3 4]
m2:
[2 1]
[4 2]
m1 + m2
[3 3]
[7 6]
m1 - m2
[-1 1]
[-1 2]
m1 * m2
[2 2]
[12 8]
m1 div m2
[0 2]
[0 2]
m1 mod m2
[1 0]
[3 0]
m1^m2
[1 2]
[81 16]
2 * m1
[2 4]
[6 8]
m1 * 2
[2 4]
[6 8]
m1^2
[1 4]
[9 16]
2^m1
[2 4]
[8 16]
Float matrices
--------------
m1
[1.0 2.0 3.0]
[4.0 5.0 6.0]
m2
[2.0 2.0 2.0]
[3.0 3.0 3.0]
m1 + m2
[3.0 4.0 5.0]
[7.0 8.0 9.0]
m1 - m2
[-1.0 0.0 1.0]
[1.0 2.0 3.0]
m1 * m2
[2.0 4.0 6.0]
[12.0 15.0 18.0]
m1 / m2
[0.5 1.0 1.5]
[1.333333333333333 1.666666666666667 2.0]
pow(m1, m2)
[1.0 4.0 9.0]
[64.0 125.0 216.0]
pow(m1, 2.0)
[1.0 4.0 9.0]
[16.0 25.0 36.0]
pow(2.0, m1)
[2.0 4.0 8.0]
[16.0 32.0 64.0]</pre>
=={{header|PARI/GP}}==
GP already implements element-wise matrix-matrix addition and subtraction and element-wise scalar-matrix multiplication and division. Other element-wise matrix-matrix functions:
<
divMM(A,B)=matrix(#A[,1],#A,i,j,A[i,j]/B[i,j]);
powMM(A,B)=matrix(#A[,1],#A,i,j,A[i,j]^B[i,j]);</
Other element-wise scalar-matrix functions:
<
subMs(A,s)=A-matrix(#A[,1],#A,i,j,s);
powMs(A,s)=matrix(#A[,1],#A,i,j,A[i,j]^s);</
PARI implements convenience functions <code>vecmul</code> (element-wise matrix-matrix multiplication), <code>vecdiv</code> (element-wise matrix-matrix division), and <code>vecpow</code> (element-wise matrix-scalar exponentiation), as well as <code>vecmodii</code> and <code>vecinv</code>. These operate on vectors, but a <code>t_MAT</code> is simply an array of vectors in PARI so it applies fairly easily.
Line 1,132 ⟶ 2,873:
This example demonstrates Perl's operator overload ability and bulk list operations using <tt>map</tt>.
<syntaxhighlight lang="perl">use v5.36;
use overload
'
'
'
'
'
sub new ($class, $value) { bless $value, ref $class || $class }
sub add { ref($_[1]) ? [map { $_[0][$_] + $_[1][$_] } 0 .. $#{$_[0]} ] : [map { $_[0][$_] + $_[1] } 0 .. $#{$_[0]} ] }
sub sub { ref($_[1]) ? [map { $_[0][$_] - $_[1][$_] } 0 .. $#{$_[0]} ] : [map { $_[0][$_] - $_[1] } 0 .. $#{$_[0]} ] }
sub mul { ref($_[1]) ? [map { $_[0][$_] * $_[1][$_] } 0 .. $#{$_[0]} ] : [map { $_[0][$_] * $_[1] } 0 .. $#{$_[0]} ] }
sub div { ref($_[1]) ? [map { $_[0][$_] / $_[1][$_] } 0 .. $#{$_[0]} ] : [map { $_[0][$_] / $_[1] } 0 .. $#{$_[0]} ] }
sub exp { ref($_[1]) ? [map { $_[0][$_] ** $_[1][$_] } 0 .. $#{$_[0]} ] : [map { $_[0][$_] ** $_[1] } 0 .. $#{$_[0]} ] }
package main;
$a = Elementwise->new([<1 2 3 4 5 6 7 8 9>]);
say <<"END";
a @$a
a OP a
+ @{$a+$a}
Line 1,183 ⟶ 2,904:
* @{$a*$a}
/ @{$a/$a}
a OP 5
+ @{$a+5}
Line 1,189 ⟶ 2,911:
* @{$a*5}
/ @{$a/5}
END</syntaxhighlight>
{{out}}
<pre>a 1 2 3 4 5 6 7 8 9
a OP a
+ 2 4 6 8 10 12 14 16 18
Line 1,199 ⟶ 2,922:
* 1 4 9 16 25 36 49 64 81
/ 1 1 1 1 1 1 1 1 1
a OP 5
+ 6 7 8 9 10 11 12 13 14
Line 1,205 ⟶ 2,929:
* 5 10 15 20 25 30 35 40 45
/ 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8
=={{header|Phix}}==
{{libheader|Phix/basics}}
Phix has builtin sequence ops, which work fine with a multi-dimensional array / matrix:
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">m</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">8</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">7</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">9</span><span style="color: #0000FF;">}},</span>
<span style="color: #000000;">m2</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">}}</span>
<span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"+"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m2</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"="</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m2</span><span style="color: #0000FF;">)}</span>
<span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"-"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m2</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"="</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_sub</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m2</span><span style="color: #0000FF;">)}</span>
<span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"*"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m2</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"="</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m2</span><span style="color: #0000FF;">)}</span>
<span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"/"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m2</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"="</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m2</span><span style="color: #0000FF;">)}</span>
<span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"^"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m2</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"="</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m2</span><span style="color: #0000FF;">)}</span>
<span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"+ 3 ="</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)}</span>
<span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"- 3 ="</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_sub</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)}</span>
<span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"* 3 ="</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)}</span>
<span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"/ 3 ="</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)}</span>
<span style="color: #0000FF;">?{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"^ 3 ="</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)}</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,331 ⟶ 2,963:
=={{header|PicoLisp}}==
<
(mapcar '((L1 L2) (mapcar Fun L1 L2)) Mat1 Mat2) )
(de elementWiseScalar (Fun Mat Scalar)
(elementWiseMatrix Fun Mat (circ (circ Scalar))) )</
Test:
<pre>(let (S 10 M '((7 11 13) (17 19 23) (29 31 37)))
Line 1,365 ⟶ 2,997:
Any arithmetic operation can be applied to elements of arrays.
These examples illustrate element-by-element multiplication, but addition, subtraction, division, and exponentiation can also be written.
<
declare (m(3,3), v(3) fixed;
Line 1,373 ⟶ 3,005:
v = scalar * vector;
v = vector * vector;</
=={{header|Python}}==
<
>>> from operator import add, sub, mul, floordiv
>>> from pprint import pprint as pp
Line 1,418 ⟶ 3,050:
pow : [[10000000, 100000000, 10000000, 10000], [10000, 1000000000, 10000, 10], [100, 1000, 1000000, 10000]]
<lambda> : [[13, 12, 13, 16], [16, 11, 16, 19], [18, 17, 14, 16]]
>>> </
=={{header|R}}==
Line 1,424 ⟶ 3,056:
In R most operations work on vectors and matrices:
<
mat <- matrix(1:4, 2, 2)
Line 1,435 ⟶ 3,067:
mat + mat
mat * mat
mat ^ mat</
{{out}}
Line 1,475 ⟶ 3,107:
=={{header|Racket}}==
{{trans|R}}
<
(define mat (list->array #(2 2) '(1 3 2 4)))
Line 1,487 ⟶ 3,119:
(array* mat mat)
(array-map expt mat mat)
</syntaxhighlight>
{{out}}
Line 1,499 ⟶ 3,131:
(array #[#[1 27] #[4 256]])
</pre>
=={{header|Raku}}==
(formerly Perl 6)
Raku already implements this and other metaoperators as higher-order functions (cross, zip, reduce, triangle, etc.) that are usually accessed through a meta-operator syntactic sugar that is productive over all appropriate operators, including user-defined ones. In this case, a dwimmy element-wise operator (generically known as a "hyper") is indicated by surrounding the operator with double angle quotes. Hypers dwim on the pointy end with cyclic APL semantics as necessary. You can turn the quote the other way to suppress dwimmery on that end. In this case we could have used <tt>»op»</tt> instead of <tt>«op»</tt> since the short side is always on the right.
<syntaxhighlight lang="raku" line>my @a =
[1,2,3],
[4,5,6],
[7,8,9];
sub msay(@x) {
say .map( { ($_%1) ?? $_.nude.join('/') !! $_ } ).join(' ') for @x;
say '';
}
msay @a «+» @a;
msay @a «-» @a;
msay @a «*» @a;
msay @a «/» @a;
msay @a «+» [1,2,3];
msay @a «-» [1,2,3];
msay @a «*» [1,2,3];
msay @a «/» [1,2,3];
msay @a «+» 2;
msay @a «-» 2;
msay @a «*» 2;
msay @a «/» 2;
# In addition to calling the underlying higher-order functions directly, it's possible to name a function.
sub infix:<M+> (\l,\r) { l <<+>> r }
msay @a M+ @a;
msay @a M+ [1,2,3];
msay @a M+ 2;
</syntaxhighlight>
{{out}}
<pre> 2 4 6
8 10 12
14 16 18
0 0 0
0 0 0
0 0 0
1 4 9
16 25 36
49 64 81
1 1 1
1 1 1
1 1 1
2 3 4
6 7 8
10 11 12
0 1 2
2 3 4
4 5 6
1 2 3
8 10 12
21 24 27
1 2 3
2 5/2 3
7/3 8/3 3
3 4 5
6 7 8
9 10 11
-1 0 1
2 3 4
5 6 7
2 4 6
8 10 12
14 16 18
1/2 1 3/2
2 5/2 3
7/2 4 9/2
2 4 6
8 10 12
14 16 18
2 3 4
6 7 8
10 11 12
3 4 5
6 7 8
9 10 11</pre>
=={{header|REXX}}==
===discrete===
<
m= (1 2 3) (4 5 6) (7 8 9)
w= words(m); do
end /*rows*/
cols= rows
call showMat M, 'M matrix'
answer= matAdd(m, 2 );
answer= matSub(m, 7 );
answer= matMul(m, 2.5);
answer= matPow(m, 3 );
answer= matDiv(m, 4 );
answer= matIdv(m, 2 );
answer= matMod(m, 3 );
exit
/*──────────────────────────────────────────────────────────────────────────────────────*/
matAdd: parse arg @,#; call mat#;
matSub: parse arg @,#; call mat#;
matMul: parse arg @,#; call mat#;
matDiv: parse arg @,#; call mat#;
matIdv: parse arg @,#; call mat#;
matPow: parse arg @,#; call mat#;
matMod: parse arg @,#; call mat#;
mat#: w= words(@);
mat@: @= !.1;
/*──────────────────────────────────────────────────────────────────────────────────────*/
showMat: parse arg @, hdr; L= 0; say
say center(hdr, max( length(hdr)+4, cols * (L+1)+4), "─")
n= 0
return</
{{out|output|text= when using the internal default input:}}
<pre style="height:
──M matrix──
1 2 3
Line 1,577 ⟶ 3,306:
===generalized===
<
m= (1 2 3) (4 5 6) (7 8 9)
w= words(m); do
end /*k*/; cols= rows
call showMat M, 'M matrix'
ans= matOp(m, '+2' ); call showMat ans, "M matrix, added 2"
ans= matOp(m, '-7' ); call showMat ans, "M matrix, subtracted 7"
ans= matOp(m, '*2.5' ); call showMat ans, "M matrix, multiplied by 2½"
ans= matOp(m, '**3' ); call showMat ans, "M matrix, cubed"
ans= matOp(m, '/4' ); call showMat ans, "M matrix, divided by 4"
ans= matOp(m, '%2' ); call showMat ans, "M matrix, integer halved"
ans= matOp(m, '//3' ); call showMat ans, "M matrix, modulus 3"
ans= matOp(m, '*3-1' ); call showMat ans, "M matrix, tripled, less one"
exit
/*──────────────────────────────────────────────────────────────────────────────────────*/
matOp:
mat#:
mat@:
/*──────────────────────────────────────────────────────────────────────────────────────*/
showMat: parse arg @, hdr; L= 0; say
say; say center(hdr,max(length(hdr)+4,cols*(L+1)+4),"─")
n= 0
return</
{{out|output|text= when using the internal default input:}}
<pre style="height:
──M matrix──
1 2 3
Line 1,660 ⟶ 3,390:
=={{header|Ruby}}==
<
class Matrix
Line 1,675 ⟶ 3,405:
[:+, :-, :*, :/, :fdiv, :**, :%].each do |op|
puts "m1 %-4s m2 = %s" % [op, m1.element_wise(op, m2)]
end</
{{out}}
<pre>
Line 1,691 ⟶ 3,421:
=={{header|Rust}}==
<
elements: Vec<f32>,
pub height: u32,
Line 1,825 ⟶ 3,555:
// | 15 |
matrix_multiplication(&matrix1, &matrix3).unwrap().print();
}</
=={{header|Sidef}}==
The built-in metaoperators `~W<op>`, `~S<op>` and `~RS<op>` are defined for arbitrary nested arrays.
<syntaxhighlight lang="ruby">var m1 = [[3,1,4],[1,5,9]]
var m2 = [[2,7,1],[8,2,2]]
say ":: Matrix-matrix operations"
say (m1 ~W+ m2)
say (m1 ~W- m2)
say (m1 ~W* m2)
say (m1 ~W/ m2)
say (m1 ~W// m2)
say (m1 ~W** m2)
say (m1 ~W% m2)
say "\n:: Matrix-scalar operations"
say (m1 ~S+ 42)
say (m1 ~S- 42)
say (m1 ~S/ 42)
say (m1 ~S** 10)
# ...
say "\n:: Scalar-matrix operations"
say (m1 ~RS+ 42)
say (m1 ~RS- 42)
say (m1 ~RS/ 42)
say (m1 ~RS** 10)
# ...</syntaxhighlight>
{{out}}
<pre>
:: Matrix-matrix operations
[[5, 8, 5], [9, 7, 11]]
[[1, -6, 3], [-7, 3, 7]]
[[6, 7, 4], [8, 10, 18]]
[[3/2, 1/7, 4], [1/8, 5/2, 9/2]]
[[1, 0, 4], [0, 2, 4]]
[[9, 1, 4], [1, 25, 81]]
[[1, 1, 0], [1, 1, 1]]
:: Matrix-scalar operations
[[45, 43, 46], [43, 47, 51]]
[[-39, -41, -38], [-41, -37, -33]]
[[1/14, 1/42, 2/21], [1/42, 5/42, 3/14]]
[[59049, 1, 1048576], [1, 9765625, 3486784401]]
:: Scalar-matrix operations
[[45, 43, 46], [43, 47, 51]]
[[39, 41, 38], [41, 37, 33]]
[[14, 42, 21/2], [42, 42/5, 14/3]]
[[1000, 10, 10000], [10, 100000, 1000000000]]
</pre>
=={{header|Standard ML}}==
<syntaxhighlight lang="sml">structure Matrix = struct
local
open Array2
fun mapscalar f (x, scalar) =
tabulate RowMajor (nRows x, nCols x, fn (i,j) => f(sub(x,i,j),scalar))
fun map2 f (x, y) =
tabulate RowMajor (nRows x, nCols x, fn (i,j) => f(sub(x,i,j),sub(y,i,j)))
in
infix splus sminus stimes
val op splus = mapscalar Int.+
val op sminus = mapscalar Int.-
val op stimes = mapscalar Int.*
val op + = map2 Int.+
val op - = map2 Int.-
val op * = map2 Int.*
val fromList = fromList
fun toList a =
List.tabulate(nRows a, fn i => List.tabulate(nCols a, fn j => sub(a,i,j)))
end
end;
(* example *)
let open Matrix
infix splus sminus stimes
val m1 = fromList [[1,2],[3,4]]
val m2 = fromList [[4,3],[2,1]]
val s = 2
in
List.map toList [m1+m2, m1-m2, m1*m2,
m1 splus s, m1 sminus s, m1 stimes s]
end;</syntaxhighlight>
'''Output:'''
<syntaxhighlight lang="sml">val it =
[[[5,5],[5,5]],[[~3,~1],[1,3]],[[4,6],[6,4]],[[3,4],[5,6]],[[~1,0],[1,2]],
[[2,4],[6,8]]] : int list list list</syntaxhighlight>
=={{header|Stata}}==
<syntaxhighlight lang="stata">mata
a = rnormal(5,5,0,1)
b = 2
a:+b
a:-b
a:*b
a:/b
a:^b
a = rnormal(5,5,0,1)
b = rnormal(5,1,0,1)
a:+b
a:-b
a:*b
a:/b
a:^b
end</syntaxhighlight>
=={{header|Tcl}}==
<
proc alias {name args} {uplevel 1 [list interp alias {} $name {} {*}$args]}
Line 1,867 ⟶ 3,705:
alias .* elementwiseMatSca {{a b} {expr {$a*$b}}}
alias ./ elementwiseMatSca {{a b} {expr {$a/$b}}}
alias .** elementwiseMatSca {{a b} {expr {$a**$b}}}</
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">import math
struct Matrix {
mut:
ele []f64
stride int
}
fn matrix_from_rows(rows [][]f64) Matrix {
if rows.len == 0 {
return Matrix{[], 0}
}
mut m := Matrix{[]f64{len: rows.len*rows[0].len}, rows[0].len}
for rx, row in rows {
m.ele = m.ele[..rx*m.stride]
m.ele << row
m.ele << m.ele[(rx+1)*m.stride..]
}
return m
}
fn like(m Matrix) Matrix {
return Matrix{[]f64{len: m.ele.len}, m.stride}
}
fn (m Matrix) str() string {
mut s := ""
for e := 0; e < m.ele.len; e += m.stride {
s += "${m.ele[e..e+m.stride]} \n"
}
return s
}
type BinaryFunc64 = fn(f64, f64) f64
fn element_wise_mm(m1 Matrix, m2 Matrix, f BinaryFunc64) Matrix {
mut z := like(m1)
for i, m1e in m1.ele {
z.ele[i] = f(m1e, m2.ele[i])
}
return z
}
fn element_wise_ms(m Matrix, s f64, f BinaryFunc64) Matrix {
mut z := like(m)
for i, e in m.ele {
z.ele[i] = f(e, s)
}
return z
}
fn add(a f64, b f64) f64 { return a + b }
fn sub(a f64, b f64) f64 { return a - b }
fn mul(a f64, b f64) f64 { return a * b }
fn div(a f64, b f64) f64 { return a / b }
fn exp(a f64, b f64) f64 { return math.pow(a, b) }
fn add_matrix(m1 Matrix, m2 Matrix) Matrix { return element_wise_mm(m1, m2, add) }
fn sub_matrix(m1 Matrix, m2 Matrix) Matrix { return element_wise_mm(m1, m2, sub) }
fn mul_matrix(m1 Matrix, m2 Matrix) Matrix { return element_wise_mm(m1, m2, mul) }
fn div_matrix(m1 Matrix, m2 Matrix) Matrix { return element_wise_mm(m1, m2, div) }
fn exp_matrix(m1 Matrix, m2 Matrix) Matrix { return element_wise_mm(m1, m2, exp) }
fn add_scalar(m Matrix, s f64) Matrix { return element_wise_ms(m, s, add) }
fn sub_scalar(m Matrix, s f64) Matrix { return element_wise_ms(m, s, sub) }
fn mul_scalar(m Matrix, s f64) Matrix { return element_wise_ms(m, s, mul) }
fn div_scalar(m Matrix, s f64) Matrix { return element_wise_ms(m, s, div) }
fn exp_scalar(m Matrix, s f64) Matrix { return element_wise_ms(m, s, exp) }
fn h(heading string, m Matrix) {
println(heading)
print(m)
}
fn main() {
m1 := matrix_from_rows([[f64(3), 1, 4], [f64(1), 5, 9]])
m2 := matrix_from_rows([[f64(2), 7, 1], [f64(8), 2, 8]])
h("m1:", m1)
h("m2:", m2)
println('')
h("m1 + m2:", add_matrix(m1, m2))
h("m1 - m2:", sub_matrix(m1, m2))
h("m1 * m2:", mul_matrix(m1, m2))
h("m1 / m2:", div_matrix(m1, m2))
h("m1 ^ m2:", exp_matrix(m1, m2))
println('')
s := .5
println("s: $s")
h("m1 + s:", add_scalar(m1, s))
h("m1 - s:", sub_scalar(m1, s))
h("m1 * s:", mul_scalar(m1, s))
h("m1 / s:", div_scalar(m1, s))
h("m1 ^ s:", exp_scalar(m1, s))
}</syntaxhighlight>
{{out}}
<pre>
m1:
[3, 1, 4]
[1, 5, 9]
m2:
[2, 7, 1]
[8, 2, 8]
m1 + m2:
[5, 8, 5]
[9, 7, 17]
m1 - m2:
[1, -6, 3]
[-7, 3, 1]
m1 * m2:
[6, 7, 4]
[8, 10, 72]
m1 / m2:
[1.5, 0.14285714285714285, 4]
[0.125, 2.5, 1.125]
m1 ^ m2:
[9, 1, 4]
[1, 25, 4.3046721e+07]
s: 0.5
m1 + s:
[3.5, 1.5, 4.5]
[1.5, 5.5, 9.5]
m1 - s:
[2.5, 0.5, 3.5]
[0.5, 4.5, 8.5]
m1 * s:
[1.5, 0.5, 2]
[0.5, 2.5, 4.5]
m1 / s:
[6, 2, 8]
[2, 10, 18]
m1 ^ s:
[1.7320508075688772, 1, 2]
[1, 2.23606797749979, 3]
</pre>
=={{header|Wren}}==
{{libheader|Wren-fmt}}
{{libheader|Wren-matrix}}
The above module already overloads the basic operators to provide (in effect) some of the element wise operations required here.
However, to avoid creating a real hodgepodge, we simply define methods for all the required operations whilst deferring to existing operations where appropriate.
<syntaxhighlight lang="wren">import "./fmt" for Fmt
import "./matrix" for Matrix
// matrix-matrix element wise ops
class MM {
static add(m1, m2) { m1 + m2 }
static sub(m1, m2) { m1 - m2 }
static mul(m1, m2) {
if (!m1.sameSize(m2)) Fiber.abort("Matrices must be of the same size.")
var m = Matrix.new(m1.numRows, m1.numCols)
for (i in 0...m.numRows) {
for (j in 0...m.numCols) m[i, j] = m1[i, j] * m2[i, j]
}
return m
}
static div(m1, m2) {
if (!m1.sameSize(m2)) Fiber.abort("Matrices must be of the same size.")
var m = Matrix.new(m1.numRows, m1.numCols)
for (i in 0...m.numRows) {
for (j in 0...m.numCols) m[i, j] = m1[i, j] / m2[i, j]
}
return m
}
static pow(m1, m2) {
if (!m1.sameSize(m2)) Fiber.abort("Matrices must be of the same size.")
var m = Matrix.new(m1.numRows, m1.numCols)
for (i in 0...m.numRows) {
for (j in 0...m.numCols) m[i, j] = m1[i, j].pow(m2[i, j])
}
return m
}
}
// matrix-scalar element wise ops
class MS {
static add(m, s) { m + s }
static sub(m, s) { m - s }
static mul(m, s) { m * s }
static div(m, s) { m / s }
static pow(m, s) { m.apply { |e| e.pow(s) } }
}
// scalar-matrix element wise ops
class SM {
static add(s, m) { m + s }
static sub(s, m) { -m + s }
static mul(s, m) { m * s }
static div(s, m) {
var n = Matrix.new(m.numRows, m.numCols)
for (i in 0...n.numRows) {
for (j in 0...n.numCols) n[i, j] = s / m[i, j]
}
return n
}
static pow(s, m) {
var n = Matrix.new(m.numRows, m.numCols)
for (i in 0...n.numRows) {
for (j in 0...n.numCols) n[i, j] = s.pow(m[i, j])
}
return n
}
}
var m = Matrix.new([ [3, 5, 7], [1, 2, 3], [2, 4, 6] ])
System.print("m:")
Fmt.mprint(m, 2, 0)
System.print("\nm + m:")
Fmt.mprint(MM.add(m, m), 2, 0)
System.print("\nm - m:")
Fmt.mprint(MM.sub(m, m), 2, 0)
System.print("\nm * m:")
Fmt.mprint(MM.mul(m, m), 2, 0)
System.print("\nm / m:")
Fmt.mprint(MM.div(m, m), 2, 0)
System.print("\nm ^ m:")
Fmt.mprint(MM.pow(m, m), 6, 0)
var s = 2
System.print("\ns = %(s):")
System.print("\nm + s:")
Fmt.mprint(MS.add(m, s), 2, 0)
System.print("\nm - s:")
Fmt.mprint(MS.sub(m, s), 2, 0)
System.print("\nm * s:")
Fmt.mprint(MS.mul(m, s), 2, 0)
System.print("\nm / s:")
Fmt.mprint(MS.div(m, s), 3, 1)
System.print("\nm ^ s:")
Fmt.mprint(MS.pow(m, s), 2, 0)
System.print("\ns + m:")
Fmt.mprint(SM.add(s, m), 2, 0)
System.print("\ns - m:")
Fmt.mprint(SM.sub(s, m), 2, 0)
System.print("\ns * m:")
Fmt.mprint(SM.mul(s, m), 2, 0)
System.print("\ns / m:")
Fmt.mprint(SM.div(s, m), 8, 6)
System.print("\ns ^ m:")
Fmt.mprint(SM.pow(s, m), 3, 0)</syntaxhighlight>
{{out}}
<pre>
m:
| 3 5 7|
| 1 2 3|
| 2 4 6|
m + m:
| 6 10 14|
| 2 4 6|
| 4 8 12|
m - m:
| 0 0 0|
| 0 0 0|
| 0 0 0|
m * m:
| 9 25 49|
| 1 4 9|
| 4 16 36|
m / m:
| 1 1 1|
| 1 1 1|
| 1 1 1|
m ^ m:
| 27 3125 823543|
| 1 4 27|
| 4 256 46656|
s = 2:
m + s:
| 5 7 9|
| 3 4 5|
| 4 6 8|
m - s:
| 1 3 5|
|-1 0 1|
| 0 2 4|
m * s:
| 6 10 14|
| 2 4 6|
| 4 8 12|
m / s:
|1.5 2.5 3.5|
|0.5 1.0 1.5|
|1.0 2.0 3.0|
m ^ s:
| 9 25 49|
| 1 4 9|
| 4 16 36|
s + m:
| 5 7 9|
| 3 4 5|
| 4 6 8|
s - m:
|-1 -3 -5|
| 1 0 -1|
| 0 -2 -4|
s * m:
| 6 10 14|
| 2 4 6|
| 4 8 12|
s / m:
|0.666667 0.400000 0.285714|
|2.000000 1.000000 0.666667|
|1.000000 0.500000 0.333333|
s ^ m:
| 8 32 128|
| 2 4 8|
| 4 16 64|
</pre>
=={{header|zkl}}==
<
M:=GSL.Matrix(3,3).set(3,5,7, 1,2,3, 2,4,6);
x:=2;
Line 1,881 ⟶ 4,055:
println("M %s M:\n%s\n".fmt(op, M.copy().resolve(op)(M).format()));
}
mSqrd:=M.pump(0,M.copy
println("M square elements:\n%s\n".fmt(mSqrd.format()));</
{{out}}
<pre>
| |||