add diff and slide to topology module

Author: 9il

source/mir/ndslice/iterator.d

@@ -13,6 +13,7 @@ $(T2 IotaIterator, $(SUBREF topology, iota))
 $(T2 MapIterator, $(SUBREF topology, map))
 $(T2 RetroIterator, $(SUBREF topology, retro))
 $(T2 SliceIterator, $(SUBREF topology, map) in composition with $(LREF MapIterator) for packed slices.)
+$(T2 SlideIterator, $(SUBREF topology, diff) and $(SUBREF topology, slide).)
 $(T2 StrideIterator, $(SUBREF topology, stride))
 $(T2 ZipIterator, $(SUBREF topology, zip))
 )
@@ -612,15 +613,15 @@ auto mapIterator(alias fun, Iterator)(Iterator iterator)
        return MapIterator!(Iterator, fun)(iterator);
 }
 
-auto ConvolutionIterator__map(Iterator, size_t params, alias fun0, alias fun)(ref ConvolutionIterator!(Iterator, params, fun0) it)
+auto SlideIterator__map(Iterator, size_t params, alias fun0, alias fun)(ref SlideIterator!(Iterator, params, fun0) it)
 {
-    return ConvolutionIterator!(Iterator, params, fun)(it._iterator);
+    return SlideIterator!(Iterator, params, fun)(it._iterator);
 }
 
 /++
-`ConvolutionIterator` is used by $(SUBREF topology, map).
+`SlideIterator` is used by $(SUBREF topology, diff) and $(SUBREF topology, slide).
 +/
-struct ConvolutionIterator(Iterator, size_t params, alias fun)
+struct SlideIterator(Iterator, size_t params, alias fun)
     if (params > 1)
 {
 @fastmath:
@@ -629,7 +630,7 @@ struct ConvolutionIterator(Iterator, size_t params, alias fun)
 
     import mir.functional: pipe;
     ///
-    static alias __map(alias fun1) = ConvolutionIterator__map!(Iterator, params, fun, pipe!(fun, fun1));
+    static alias __map(alias fun1) = SlideIterator__map!(Iterator, params, fun, pipe!(fun, fun1));
 
     auto ref opUnary(string op : "*")()
     {
@@ -649,7 +650,7 @@ unittest
 {
     import mir.functional: naryFun;
     auto data = [1, 3, 8, 18];
-    auto diff = ConvolutionIterator!(int*, 2, naryFun!"b - a")(data.ptr);
+    auto diff = SlideIterator!(int*, 2, naryFun!"b - a")(data.ptr);
     assert(*diff == 2);
     assert(diff[1] == 5);
     assert(diff[2] == 10);

source/mir/ndslice/topology.d

@@ -18,7 +18,6 @@ $(T2 repeat, Slice with identical values)
 $(T2 iota, Contiguous Slice with initial flattened (contiguous) index.)
 $(T2 ndiota, Contiguous Slice with initial multidimensional index.)
 $(T2 linspace, Evenly spaced numbers over a specified interval.)
-
 )
 
 $(BOOKTABLE $(H2 Products),
@@ -36,12 +35,14 @@ $(T2 as, Convenience function that creates a lazy view,
 where each element of the original slice is converted to a type `T`.)
 $(T2 bitpack, Bitpack slice over an unsigned integral slice.)
 $(T2 bitwise, Bitwise slice over an unsigned integral slice.)
+$(T2 diff, Differences between vector elements.)
 $(T2 flattened, Contiguous 1-dimensional slice of all elements of a slice.)
 $(T2 map, Multidimensional functional map.)
 $(T2 retro, Reverses order of iteration for all dimensions)
+$(T2 slide, Sliding map for vectors.)
 $(T2 stride, Strides 1-dimensional slice)
-$(T2 zip, Zips slices into a slice of tuples.)
 $(T2 unzip, Selects a slice from a zipped slice.)
+$(T2 zip, Zips slices into a slice of tuples.)
 
 )
 
@@ -2542,6 +2543,77 @@ pure nothrow unittest
 
 private enum TotalDim(NdFields...) = [staticMap!(DimensionCount, NdFields)].sum;
 
+/++
+Sliding map for vectors.
+
+Suitable for simple convolution algorithms.
+
+Params:
+    params = windows length.
+    fun = map functions with `params` arity.
+See_also: $(LREF diff).
++/
+template slide(size_t params, alias fun)
+    if (params <= 'z' - 'a' + 1)
+{
+    import mir.functional: naryFun;
+    static if (params == 1)
+    {
+        alias slide = .map!(naryFun!fun);
+    }
+    else
+    static if (__traits(isSame, naryFun!fun, fun))
+    {
+        /++
+        Params:
+            slice = An 1-dimensional input slice.
+        Returns:
+            1d-slice composed of `fun(slice[i], ..., slice[i + params - 1])`.
+        +/
+        @fastmath auto slide(SliceKind kind, Iterator)
+            (Slice!(kind, [1], Iterator) slice)
+        {
+            auto s = slice.flattened;
+            s._lengths[0] -= params - 1;
+            if (cast(sizediff_t)s._lengths[0] < 0)
+                s._lengths[0] = 0;
+            alias I = SlideIterator!(_IteratorOf!(typeof(s)), params, fun);
+            return Slice!(Contiguous, [1], I)(
+                s._lengths,
+                s._strides,
+                I(s._iterator));
+        }
+    }
+    else alias slide = .slide!(params, naryFun!fun);
+}
+
+///
+unittest
+{
+    auto data = 10.iota;
+    auto sw = data.slide!(3, "a + 2 * b + c");
+    
+    import mir.utility: max;
+    assert(sw.length == max(0, cast(ptrdiff_t)data.length - 3 + 1));
+    assert(sw == sw.length.iota.map!"(a + 1) * 4");
+}
+
+/++
+Differences between vector elements.
+Params:
+    lag = an integer indicating which lag to use
+Returns: lazy difference 1d-slice.
+
+See_also: $(LREF slide).
++/
+alias diff(size_t lag = 1) = slide!(lag + 1, ('a' + lag) ~ " - a");
+
+///
+unittest
+{
+    assert([2, 4, 3, -1].sliced.diff == [2, -1, -4]);
+}
+
 /++
 Cartesian product.