• Subject: iota_marray (beta) - Fast Multi-Dimensional Arrays for Lua 5.3
• From: Rodrigo Azevedo <rodrigoams@...>
• Date: Tue, 28 Oct 2014 12:45:38 -0300

`That's a simple beta version of a multi-dimensional array library for Lua 5.3.We are in the final stage of the design and I really appreciate any feedbacks about the user interfaceand functionalities. The aim is to release the more productive library as possible.`
```iota_marray
===========

Fast Multi-Dimensional Arrays for Lua (BETA VERSION)

An multi-dimensional (marray) is a common numeric array with a specific size but indexed by n numbers. We can create a new marray with 2 dimensions (rank 2) and size 6000 in Lua with

local ima = require"marray"
ma = ima.new(10, 20, 30)

for i=1,ma.dim[1] do
for j=1,ma.dim[2] do
for k=1,ma.dim[3] do
ma[i][j][k] = math.random()
end
end
end

where we have made use of the dimensions attribute. We note that marrays have more two intrinsic attributes, namely, ma.rank and ma.size, with obviosly meaning.

The marrays also possess some basic mathematical attributes, you can perform some operations on two identical size marrays, for example

mb = ia.new(10, 600)

mb = ma*3.0
mb = ma - 0.5*mb

are all valid operations, but the result is not so obviouly!

To be more funny the marrays also possess a regular Lua table that can be indexed

ma.name = 'say hello :'
ma.HI = function() return 'HI!' end

then print(ma.name, ma.HI()) will print

say hello : HI!

RESHAPE

We can use the reshape facility

ia.reshape(mb, 10*600)

such that mb is now indexed with 1 index, and initialize very easy

for i=1,mb.dim[1] do
mb[i] = math.random()
end

After the assigmentent, we can reshape again

is.reshape(mb, 10, 600)

to obtain the original shape. You can always reshape a marray, but do not change its size.

SLICES AND VIEWS

The reshape is very funny, but what if we need a sub-portion of the marray? simple, slice it!

v1 = ia.slice(ma, 2, 10)

yields a new VIEW, with rank = mb.rank-1 such that va[i][j] equals ma[i][10][k]. We can also specify an 'end' and 'step' options to slice, such that

v2 = ia.slice(ma, 3, 10, 20, 5)

creates a view with the same rank as mb, but the third dimension goes from 10 to 20 with steps of 5, namely,

v2[i][j][1] == ma[i][j][10]
v2[i][j][2] == ma[i][j][15]
v2[i][j][3] == ma[i][j][20]

with i=1,mb.dim[1] and j=1,mb.dim[2] and k=1,2,3, and the respective dimensions are updated, then

for i=1,v2.dim[1] do
for j=1,v2.dim[2] do
for k=1,v2.dim3[3] do
v2[i][j][k] = math.random()
end
end
end

is also valid. Indexed marrays/views are also 'sliceable',

v3 = ia.toview(ma[5][10])

is such that

v3[i] == ma[5][10][i]

The views always 'remember' the orinal shape of the marray, then you can reshape your marray

ia.reshape(ma, 6000)

and v3[i], v2[i][j][k] and v1[i][j] access to the same numbers as before!

Finally, v3.name == ma.name !

TODO

Index check, I do not check any index.
Mathematical operations on views.
More?
```
To compile you need a (c)BLAS library!

--
Rodrigo Azevedo Moreira da Silva