How to sum multidimensional arrays?

[p.shkadzko]

On Thursday, 27 February 2020 at 15:48:53 UTC, bachmeier wrote:
> On Thursday, 27 February 2020 at 14:15:26 UTC, p.shkadzko wrote:
>
> [...]
>
>> This works but it does not look very efficient considering we 
>> flatten and then calling array twice. It will get even worse 
>> with 3D arrays. Is there a better way without relying on 
>> mir.ndslice?
>
> Is there a reason you can't create a struct around a double[] 
> like this?
>
> struct Matrix {
>   double[] data;
> }
>
> Then to add Matrix A to Matrix B, you use A.data[] + B.data[]. 
> But since I'm not sure what exactly you're doing, maybe that 
> won't work.

Right! Ok, here is how I do it.

```
struct Matrix(T)
{
     T[] elems;
     int cols;

     T[][] to2D()
     {
         return elems.chunks(cols).array;
     }
}
```

and Matrix summing and random array generator functions

```
auto matrixSum(Matrix!int m1, Matrix!int m2)
{
     Matrix!int m3;
     m3.cols = m1.cols;
     m3.elems.length = m1.elems.length;
     m3.elems[] = m1.elems[] + m2.elems[];
     return m3.to2D;
}

static T[] rndArr(T)(in T max, in int elems)
{
     Xorshift rnd;
     return generate(() => uniform(0, max, rnd)).take(elems).array;
}
```
Then we do the following

```
auto m1 = Matrix!int(rndArr!int(10, 5000 * 6000), 6000);
auto m2 = Matrix!int(rndArr!int(10, 5000 * 6000), 6000);
auto m3 = matrixSum(m1, m2);
```

And it works effortlessly!
Sum of two 5000 x 6000 int arrays is just 0.105 sec! (on a 
Windows machine though but with weaker CPU).

I bet using mir.ndslice instead of D arrays would be even faster.