[Haskell-cafe] Hatlab: My attempt to make a library inspired by Matlab and NumPy

[TeraTux]

Greetings!

I made a library which implements functions similar to those in Matlab or
NumPy. The code is not much clean yet, you can see it at
https://gitlab.com/Hume2/hatlab . The functions with comments are intended
to be used. I want to know if it is a good start or I just wasted time.

The matrices can have arbitrary dimensions, starting from 0D matrices,
which are basically scalars. Operations like + - * / are element-wise. I
also implemented broadcasting of these operations.

I also implemented indexing. Some examples:

a = matrix2D [[1,2,3],[4,5,6],[7,8,9]]
a !# [2,2] -- element at index [2,2]
a !$ [At 1, All] -- 1st row
a !$ [To (-1), All] -- all rows except the last one
a !$ [Where $ a ># 5] -- all elements bigger than 5 (The ># operator
returns a matrix of bools, I will come to that later.)

It is also possible to update a matrix. These operations do not copy all
the elements from the original matrix, they just make another matrix which
points to the original matrix at places where it was not changed. Some
examples:

a = eye 5
b = matrix2D [[1,2,3],[4,5,6],[7,8,9]]
a !:[FromTo 1 4, FromTo 1 4]:= b -- replace the middle square by a
different matrix
a !:[FromTo 1 4, FromTo 1 4]:= 1 -- set all values in the middle square to 1
a !:[FromTo 1 4, FromTo 1 4]:+= 1 -- add one to all values in the middle
square
a !:[FromTo 1 4, FromTo 1 4]:$= cos -- replace all values in the middle
square by their cosine

Operators are broadcasted the same way as in Matlab or NumPy. If one
operand has size 1 and the other one has size N or vice-versa in given
dimension, the operator acts as if the thinner matrix was repeated in the
given dimension N times. Example:

a = matrix1D [10, 20, 30] -- row vector
b = matrix2D [[1], [2], [3]] -- column vector
a + b -- returns [[11, 21, 31], [12, 22, 32], [13, 23, 33]]

There is a function "scalar" which creates a 0D matrix out of any value, so
we can do:

a + (scalar 5) -- returns [15, 25, 35]
a * (scalar 2) -- returns [20, 40, 60]

If a type is in the class Num, Fractional or Floating, the matrix of the
given type is also in the given class. Conversions are performed using the
function "scalar", so we can write:

a + 5
a * 2

because the "5" and "2" are then interpreted as 0D matrices.

Operator * is interpreted as element-wise multiplication. To do matrix
multiplication, use the × operator. It can be also used to multiply
matrices with vectors. Examples:

v = matrix1D [1,2,3]
m = matrix2D [[1,0,1],[2,-1,1],[0,1,-1]]
v × m -- multiply row vector v with matrix m
m × v -- multiply matrix m with column vector v
m × m -- multiply matrix m by itself

There are also functions for element-wise boolean operations. They work
similarly and they have the # suffix. Examples:

a = matrix2D [[True, True], [False, False]]
b = matrix2D [[True, False], [True, False]]
a &# b -- element-wise and
a |# b -- element-wise or

There are also element-wise comparison functions in a similar fashion.
Examples:

a = eye 3
b = ones [3,3]
a ==# b -- returns a matrix of bools saying where the element of matrix a
is equal to the corresponding element in matrix b.
a <# b -- similar as above except that it tests for being less than instead
of equality.
a ==# 1 -- Broadcasting works for these operators too, so this syntax is
valid also.

There are also other functions not described in this mail. I will not
describe them here because this mail is already too long. Don't worry
asking me if you don't understand the meaning of any function from my
comments.

I did not implement any algorithms for linear equation solving, not even
any other matrix algorithms yet. If this library has any potential, I may
do that in the future.

Please, let me know if this library has any potential or it was just a
waste of time.

Hume2
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20220327/805a407a/attachment.html>