Element-wise operations: Difference between revisions

Using Generics, the task is quite trivial in Ada. Here is the main program:

 

 

procedure Scalar_Ops is

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

 

{{out}}

Our main program uses a generic package Matrix_Scalar. Here is the specification:

 

type Rows is (<>);

type Cols is (<>);

function Image(M: Matrix) return String;

 

 

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

end Image;

 

 

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

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

elementwise op(pow, matrix, matrix)

))

{{out}}

<pre>

(2567686153161210000000000000000000000000000.00, 17069174130723200000000000000000000000000000000.00, 10555134955777600000000000000000000000000000000000000000000.00));

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

a$ = LEFT$(LEFT$(a$)) + "]"

NEXT

{{out}}

<pre>

=={{header|C}}==

Matrices are 2D double arrays.

 

#define for_i for(i = 0; i < h; i++)

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

 

using System.Collections.Generic;

using System.Linq;

matrix.DoOperation((a, b) => b - a, 100).Print();

}

{{out}}

<pre>

 

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

#include <cmath>

#include <iostream>

test_matrix_scalar();

return 0;

 

{{out}}

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

 

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

(defun m* (A B) (element-wise-matrix #'* A B))

(defun m/ (A B) (element-wise-matrix #'/ A B))

 

Elementwise scalar-matrix operations.

(let* ((len (array-total-size A))

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

(defun .* (c A) (element-wise-scalar #'* A c))

(defun ./ (A c) (element-wise-scalar #'/ A c))

 

=={{header|D}}==

 

T[][] elementwise(string op, T, U)(in T[][] A, in U B) {

writefln("%s:\n[%([%(%d, %)],\n %)]]\n\n[%([%(%d, %)],\n %)]]\n",

op, elementwise!op(M, 2), elementwise!op(M, M));

{{out}}

<pre>+:

 

This alternative version offers more guarantees, same output:

 

T[][] elementwise(string op, T, U)(in T[][] A, in U B)

writefln(matFormat, elementwise!op(matrix, matrix));

}

 

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

math.matrices math.vectors prettyprint sequences ;

 

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

{{out}}

<pre>

All element based operations are suported by default in Fortran(90+)

 

program element_operations

implicit none

end program element_operations

 

{{out}}

 

</pre>

 

=={{header|Go}}==

A package, which can be referred to in other, higher-order tasks.

 

import (

func MulScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, mul) }

func DivScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, div) }

Package use:

 

import (

h("m1 / s:", element.DivScalar(m1, s))

h("m1 ^ s:", element.ExpScalar(m1, s))

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

 

List<List<Number>> contents = []

contents.hashCode()

}

The following ''NaiveMatrixCategory'' class allows for modification of regular ''Number'' behavior when interacting with ''NaiveMatrix''.

 

class NaiveMatrixCategory {

: DefaultGroovyMethods.asType(a, type)

}

Test:

 

println 'Demo 1: functionality as requested'

println "a / 2 == (${a}) / 2 == " + (a / 2)

println "a ** 2 == (${a}) ** 2 == " + (a ** 2)

Output:

<pre>Demo 1: functionality as requested

=={{header|Haskell}}==

Matrices are represented here as Immutable Arrays.

{-# LANGUAGE RankNTypes #-}

 

print $ m1 **. s

putStrLn "m1 ^^ s"

{{out}}

<pre>m1

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

procedure showMat(label, m)

every writes(label | right(!!m,5) | "\n")

 

{{out}}

 

=={{header|J}}==

vector =: 2 3 5

matrix =: 3 3 $ 7 11 13 17 19 23 29 31 37

49 121 169

289 361 529

 

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

import java.util.Arrays;

import java.util.HashMap;

}

}

 

=={{header|jq}}==

 

'''Part 1'''

# and occurrences of .[1] will refer to the corresponding element in other.

def elementwise( operator; other ):

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

(.; .[$i][$j] = ([$self[$i][$j], $other[$i][$j]] | operator) ) )

'''Example''':

| ( ($m1|elementwise(.[0] + .[1]; $m2) ),

($m1|elementwise(.[0] + 2 * .[1]; $m2) ),

($m1|elementwise(.[0] < .[1]; $m2) ) )

{{Out}}

[[7,15,6],[17,9,13]]

[[false,true,false],[true,false,false]]

 

'''Part 2'''

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

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

(.; .[$i][$j] = operation($self[$i][$j]; operator; $other[$i][$j] ) ) )

'''Example''':

| ( ($m1|elementwise2("+"; $m2) ),

($m1|elementwise2("//"; $m2)),

{{Out}}

[[1,0,4],[0,2,4]]

[[false,true,false],[true,false,false]]

 

=={{header|Julia}}==

In Julia operations with `.` before are for convention Element-wise:

@show [1 2 3; 2 1 2] .+ 1

@show [1 2 3; 2 2 1] .- [1 1 1; 2 1 0]

@show [1 2 3; 3 2 1] .* 2

@show [9 8 6; 3 2 3] ./ [3 1 2; 2 1 2]

 

{{out}}

{{trans|J}}

 

vector: 2 3 5

matrix: 3 3 # 7 11 13 17 19 23 29 31 37

289 361 529

841 961 1369)

 

=={{header|Kotlin}}==

 

typealias Matrix = Array<DoubleArray>

println("s = $s:\n")

for ((i, op) in ops.withIndex()) m.elementwiseOp(s, op).print(names[i], true)

 

{{out}}

 

=={{header|Maple}}==

 

#addition

 

#exponentiation

{{Out|Output}}

<pre>

 

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

M + S

M - S

20880467999847912034355032910567}, {2567686153161211134561828214731016126483469,

17069174130723235958610643029059314756044734431,

 

=={{header|MATLAB}}==

 

b = rand(10,10);

scalar_matrix = a * b;

 

=={{header|Maxima}}==

b: matrix([2, 4], [3, 1]);

 

a^b; /* won't work */

fullmapl("^", a, b);

 

=={{header|Nim}}==

 

type Matrix[height, width: static Positive; T: SomeNumber] = array[height, array[width, T]]

echo pow(mfloat1, 2.0)

echo "pow(2.0, m1)"

 

{{out}}

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

 

Other element-wise scalar-matrix functions:

subMs(A,s)=A-matrix(#A[,1],#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.

 

This example demonstrates Perl's operator overload ability and bulk list operations using <tt>map</tt>.

 

 

use overload

 

 

 

 

 

 

a OP a

+ @{$a+$a}

* @{$a*$a}

/ @{$a/$a}

a OP 5

+ @{$a+5}

* @{$a*5}

/ @{$a/5}

 

{{out}}

<pre>a 1 2 3 4 5 6 7 8 9

a OP a

+ 2 4 6 8 10 12 14 16 18

* 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

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

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(mapcar '((L1 L2) (mapcar Fun L1 L2)) Mat1 Mat2) )

 

(de elementWiseScalar (Fun Mat Scalar)

Test:

<pre>(let (S 10 M '((7 11 13) (17 19 23) (29 31 37)))

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;

 

 

v = scalar * vector;

 

=={{header|Python}}==

>>> from operator import add, sub, mul, floordiv

>>> from pprint import pprint as pp

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

In R most operations work on vectors and matrices:

 

mat <- matrix(1:4, 2, 2)

 

mat + mat

mat * mat

 

{{out}}

=={{header|Racket}}==

{{trans|R}}

 

(define mat (list->array #(2 2) '(1 3 2 4)))

(array* mat mat)

(array-map expt mat mat)

 

{{out}}

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

[1,2,3],

[4,5,6],

 

sub msay(@x) {

say '';

}

msay @a M+ [1,2,3];

msay @a M+ 2;

{{out}}

<pre> 2 4 6

=={{header|REXX}}==

===discrete===

call showMat M, 'M matrix'

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

──M matrix──

1 2 3

 

===generalized===

call showMat M, 'M matrix'

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

──M matrix──

1 2 3

 

=={{header|Ruby}}==

 

class Matrix

[:+, :-, :*, :/, :fdiv, :**, :%].each do |op|

puts "m1 %-4s m2 = %s" % [op, m1.element_wise(op, m2)]

{{out}}

<pre>

 

=={{header|Rust}}==

elements: Vec<f32>,

pub height: u32,

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

var m2 = [[2,7,1],[8,2,2]]

 

say (m1 ~RS/ 42)

say (m1 ~RS** 10)

{{out}}

<pre>

 

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

local

open Array2

List.map toList [m1+m2, m1-m2, m1*m2,

m1 splus s, m1 sminus s, m1 stimes s]

'''Output:'''

[[[5,5],[5,5]],[[~3,~1],[1,3]],[[4,6],[6,4]],[[3,4],[5,6]],[[~1,0],[1,2]],

 

=={{header|Stata}}==

 

a = rnormal(5,5,0,1)

b = 2

a:/b

a:^b

 

=={{header|Tcl}}==

proc alias {name args} {uplevel 1 [list interp alias {} $name {} {*}$args]}

 

alias .* elementwiseMatSca {{a b} {expr {$a*$b}}}

alias ./ elementwiseMatSca {{a b} {expr {$a/$b}}}

 

=={{header|Wren}}==

 

However, to avoid creating a real hodgepodge, we simply define methods for all the required operations whilst deferring to existing operations where appropriate.

 

// matrix-matrix element wise ops

Fmt.mprint(SM.div(s, m), 8, 6)

System.print("\ns ^ m:")

 

{{out}}

 

=={{header|zkl}}==

M:=GSL.Matrix(3,3).set(3,5,7, 1,2,3, 2,4,6);

x:=2;

}

mSqrd:=M.pump(0,M.copy(),fcn(x){ x*x }); // M element by element

{{out}}

<pre>