concatenation

import mir.ndslice.allocation: slice;
import mir.ndslice.topology: repeat, iota;

// 0 0 0
auto vector = size_t.init.repeat([3]);

// 1 2 3
// 4 5 6
auto matrix = iota([2, 3], 1);

assert(concatenation(vector, matrix).slice == [
    [0, 0, 0],
    [1, 2, 3],
    [4, 5, 6],
]);

vector.popFront;
assert(concatenation!1(vector, matrix).slice == [
    [0, 1, 2, 3],
    [0, 4, 5, 6],
]);

import mir.ndslice.allocation: slice;
import mir.ndslice.topology: iota;
import mir.ndslice.slice : slicedNdField;

// 0, 1, 2
// 3, 4, 5
auto a = iota(2, 3);
// 0, 1
// 2, 3
auto b = iota(2, 2);
// 0, 1, 2, 3, 4
auto c = iota(1, 5);

// 0, 1, 2,   0, 1
// 3, 4, 5,   2, 3
// 
// 0, 1, 2, 3, 4
// construction phase
auto s = concatenation(concatenation!1(a, b), c);

// allocation phase
auto d = s.slice;
assert(d == [
    [0, 1, 2, 0, 1],
    [3, 4, 5, 2, 3],
    [0, 1, 2, 3, 4],
    ]);

// optimal fragmentation for output/writing/buffering
auto testData = [
    [0, 1, 2], [0, 1],
    [3, 4, 5], [2, 3],
    [0, 1, 2, 3, 4],
];
size_t i;
s.forEachFragment!((fragment) {
    pragma(inline, false); //reduces template bloat
    assert(fragment == testData[i++]);
    });
assert(i == testData.length);

// lazy ndslice view
assert(s.slicedNdField == d);

import mir.ndslice.allocation: slice;
import mir.ndslice.topology: iota;
import mir.ndslice.slice : slicedNdField;

size_t i;
auto a = 3.iota;
auto b = iota([6], a.length);
auto s = concatenation(a, b);
assert(s.length == a.length + b.length);
// fast iteration with until
s.until!((elem){ assert(elem == i++); return false; });
// allocation with slice
assert(s.slice == s.length.iota);
// 1D or multidimensional assignment
auto d = slice!double(s.length);
d[] = s;
assert(d == s.length.iota);
d.opIndexOpAssign!"+"(s);
assert(d == iota([s.length], 0, 2));

// lazy ndslice view
assert(s.slicedNdField == s.length.iota);