add rcmap and rcfilter (#350)

9il · web-flow · commit d446eca25cf7 · 2021-07-01T14:14:48.000+07:00
* add rcmap and rcfilter

* more tests
diff --git a/source/mir/algorithm/iteration.d b/source/mir/algorithm/iteration.d
@@ -4089,6 +4089,105 @@ version(mir_test)
     assert(equal!equal(rc, [ [3, 100], [], [400, 102] ]));
 }
 
+/++
+Implements the higher order filter and map function. The predicate and map functions are passed to
+`mir.functional.naryFun`, and can either accept a string, or any callable
+that can be executed via `pred(element)` and `map(element)`.
+Params:
+    pred = Filter function to apply to each element of range (optional)
+    map = Map function to apply to each  element of range
+Returns:
+    `rcfilter!(pred)(range)` returns a new RCArray containing only elements `map(x)` in `range` for
+    which `pred(x)` returns `true`.
+See_Also:
+    $(HTTP en.wikipedia.org/wiki/Filter_(higher-order_function), Filter (higher-order function))
++/
+template rcfilter(alias pred = "a", alias map = "a")
+{
+    static if (__traits(isSame, naryFun!pred, pred) && __traits(isSame, naryFun!map, map))
+    {
+        /++ 
+        Params:
+            r = An input range of elements to filter.
+        Returns:
+            A new range containing only elements `x` in `range` for which `predicate(x)` returns `true`.
+        +/
+        auto rcfilter(Range)(Range r)
+            if (isIterable!Range && (!isSlice!Range || DimensionCount!Range == 1))
+        {
+                import core.lifetime: forward;
+                import std.range.primitives: isInputRange;
+                import mir.rc.array: RCArray;
+
+                if (false)
+                {
+                    auto p = pred(r.front);
+                    auto e = map(r.front);
+                    r.popFront;
+                    auto d = r.empty;
+                }
+                return () @trusted
+                {
+                    import mir.appender: ScopedBuffer;
+                    alias T = typeof(map(r.front));
+                    ScopedBuffer!T buffer = void;
+                    buffer.initialize;
+                    foreach (ref e; r)
+                    {
+                        if (pred(e))
+                        {
+                            static if (__traits(isSame, naryFun!"a", map))
+                                buffer.put(forward!e);
+                            else
+                                buffer.put(map(forward!e));
+                        }
+                    }
+                    auto ret = RCArray!T(buffer.length);
+                    buffer.moveDataAndEmplaceTo(ret[]);
+                    return ret;
+                } ();
+        }
+
+        /// ditto
+        auto rcfilter(Iterator, size_t N, SliceKind kind)(Slice!(Iterator, N, kind) slice)
+            if (N > 1)
+        {
+            import mir.ndslice.topology: flattened; 
+            import core.lifetime: move;
+            return rcfilter(slice.move.flattened);
+        }
+    }
+    else
+        alias rcfilter = .rcfilter!(naryFun!pred, naryFun!map);
+}
+
+///
+version(mir_test)
+@safe pure nothrow @nogc unittest
+{
+    import mir.ndslice.topology: iota;
+
+    auto val = 3;
+    auto factor = 5;
+    // Filter iota 2x3 matrix below 3
+    assert(iota(2, 3).rcfilter!(a => a < val).moveToSlice.equal(val.iota));
+    // Filter and map below 3
+    assert(6.iota.rcfilter!(a => a < val, a => a * factor).moveToSlice.equal(val.iota * factor));
+}
+
+version(mir_test)
+@safe pure nothrow @nogc unittest
+{
+    import mir.ndslice.topology: iota, as;
+
+    auto val = 3;
+    auto factor = 5;
+    // Filter iota 2x3 matrix below 3
+    assert(iota(2, 3).as!(const int).rcfilter!(a => a < val).moveToSlice.equal(val.iota));
+    // Filter and map below 3
+    assert(6.iota.as!(immutable int).rcfilter!(a => a < val, a => a * factor).moveToSlice.equal(val.iota * factor));
+}
+
 /++
 Implements the homonym function (also known as `accumulate`, $(D
 compress), `inject`, or `foldl`) present in various programming
diff --git a/source/mir/ndslice/topology.d b/source/mir/ndslice/topology.d
@@ -2731,7 +2731,7 @@ Note:
 Params:
     fun = One or more functions.
 See_Also:
-    $(LREF cached), $(LREF vmap), $(LREF indexed),
+    $(LREF cached), $(LREF vmap),  $(LREF rcmap), $(LREF indexed),
     $(LREF pairwise), $(LREF subSlices), $(LREF slide), $(LREF zip),
     $(HTTP en.wikipedia.org/wiki/Map_(higher-order_function), Map (higher-order function))
 +/
@@ -3041,7 +3041,7 @@ Params:
     slice = ndslice
     callable = callable object, structure, delegate, or function pointer.
 See_Also:
-    $(LREF cached), $(LREF map), $(LREF indexed),
+    $(LREF cached), $(LREF map),  $(LREF rcmap), $(LREF indexed),
     $(LREF pairwise), $(LREF subSlices), $(LREF slide), $(LREF zip),
     $(HTTP en.wikipedia.org/wiki/Map_(higher-order_function), Map (higher-order function))
 +/
@@ -3181,7 +3181,7 @@ version(none) version(mir_test) unittest
     }
 }
 
-/// Use map with byDim/alongDim to apply functions to each dimension
+/// Use vmap with byDim/alongDim to apply functions to each dimension
 version(mir_test)
 @safe pure
 unittest
@@ -3214,7 +3214,7 @@ unittest
 }
 
 /++
-Use map with a lambda and with byDim/alongDim, but may need to allocate result. 
+Use vmap with a lambda and with byDim/alongDim, but may need to allocate result. 
 This example uses fuse, which allocates. Note: fuse!1 will transpose the result. 
 +/
 version(mir_test)
@@ -3291,6 +3291,168 @@ private auto unhideStride
         return slice;
 }
 
+/++
+Implements the homonym function (also known as `transform`) present
+in many languages of functional flavor. The call `rmap!(fun)(slice)`
+returns an RC array (1D) or  RC slice (ND) of which elements are obtained by applying `fun`
+for all elements in `slice`. The original slices are
+not changed. Evaluation is done eagerly.
+
+Note:
+    $(SUBREF dynamic, transposed) and
+    $(SUBREF topology, pack) can be used to specify dimensions.
+Params:
+    fun = One or more functions.
+See_Also:
+    $(LREF cached), $(LREF map), $(LREF vmap), $(LREF indexed),
+    $(LREF pairwise), $(LREF subSlices), $(LREF slide), $(LREF zip),
+    $(HTTP en.wikipedia.org/wiki/Map_(higher-order_function), Map (higher-order function))
++/
+template rcmap(fun...)
+    if (fun.length)
+{
+    import mir.functional: adjoin, naryFun, pipe;
+    static if (fun.length == 1)
+    {
+        static if (__traits(isSame, naryFun!(fun[0]), fun[0]))
+        {
+            alias f = fun[0];
+        @optmath:
+            /++
+            Params:
+                slice = An ndslice, array, or an input range.
+            Returns:
+                ndslice or an input range with each fun applied to all the elements. If there is more than one
+                fun, the element type will be `Tuple` containing one element for each fun.
+            +/
+            auto rcmap(Iterator, size_t N, SliceKind kind)
+                (Slice!(Iterator, N, kind) slice)
+            {
+                import core.lifetime: move;
+                auto shape = slice.shape;
+                auto r = slice.move.flattened;
+                if (false)
+                {
+                    auto e = f(r.front);
+                    r.popFront;
+                    auto d = r.empty;
+                }
+                return () @trusted
+                {
+                    import mir.rc.array: RCArray;
+                    import std.traits: Unqual;
+                    import mir.conv: emplaceRef;
+
+                    alias T = typeof(f(r.front));
+                    auto ret = RCArray!T(r.length);
+                    auto next = ret.ptr;
+                    while (!r.empty)
+                    {
+                        emplaceRef(*cast(Unqual!T*)next++, f(r.front));
+                        r.popFront;
+                    }
+                    static if (N == 1)
+                    {
+                        return ret;
+                    }
+                    else
+                    {
+                        return ret.moveToSlice.sliced(shape);
+                    }
+                } ();
+            }
+
+            /// ditto
+            auto rcmap(T)(T[] array)
+            {
+                return rcmap(array.sliced);
+            }
+
+            /// ditto
+            auto rcmap(T)(T withAsSlice)
+                if (hasAsSlice!T)
+            {
+                static if (__traits(hasMember, T, "moveToSlice"))
+                    return rcmap(withAsSlice.moveToSlice);
+                else
+                    return rcmap(withAsSlice.asSlice);
+            }
+
+            /// ditto
+            auto rcmap(Range)(Range r)
+                if (!hasAsSlice!Range && !isSlice!Range && !is(Range : T[], T))
+            {
+                import core.lifetime: forward;
+                import std.range.primitives: isInputRange;
+                import mir.rc.array: RCArray;
+
+                if (false)
+                {
+                    auto e = f(r.front);
+                    r.popFront;
+                    auto d = r.empty;
+                }
+                return () @trusted
+                {
+                    import mir.appender: ScopedBuffer;
+                    alias T = typeof(f(r.front));
+                    ScopedBuffer!T buffer = void;
+                    buffer.initialize;
+                    while (!r.empty)
+                    {
+                        buffer.put(f(r.front));
+                        r.popFront;
+                    }
+                    auto ret = RCArray!T(buffer.length, false);
+                    buffer.moveDataAndEmplaceTo(ret[]);
+                    return ret;
+                } ();
+            }
+        }
+        else alias rcmap = .rcmap!(staticMap!(naryFun, fun));
+    }
+    else alias rcmap = .rcmap!(adjoin!fun);
+}
+
+/// Returns RCArray for input ranges and one-dimensional slices.
+@safe pure nothrow @nogc
+version(mir_test) unittest
+{
+    import mir.algorithm.iteration: filter, equal;
+    auto factor = 10;
+    auto step = 20;
+    assert (3.iota.rcmap!(a => a * factor).moveToSlice.equal(3.iota * factor)); 
+    assert (6.iota.filter!"a % 2".rcmap!(a => a * factor).moveToSlice.equal([3].iota(factor, step))); 
+}
+
+/// For multidimensional case returns `Slice!(RCI!T, N)`.
+@safe pure nothrow @nogc
+version(mir_test) unittest
+{
+    import mir.ndslice.topology : iota;
+    auto factor = 3;
+    auto s = iota(2, 3).rcmap!(a => a * factor);
+    assert(s == iota(2, 3) * factor);
+}
+
+/// String lambdas
+@safe pure nothrow
+version(mir_test) unittest
+{
+    import mir.ndslice.topology : iota;
+    assert(iota(2, 3).rcmap!"a * 2" == iota(2, 3) * 2);
+}
+
+@safe pure nothrow @nogc
+version(mir_test) unittest
+{
+    import mir.algorithm.iteration: filter, equal;
+    auto factor = 10;
+    auto step = 20;
+    assert (3.iota.as!(const int).rcmap!(a => a * factor).moveToSlice.equal(3.iota * factor)); 
+    assert (6.iota.filter!"a % 2".as!(immutable int).rcmap!(a => a * factor).moveToSlice.equal([3].iota(factor, step))); 
+}
+
 /++
 Creates a random access cache for lazyly computed elements.
 Params:
diff --git a/source/mir/rc/array.d b/source/mir/rc/array.d
@@ -887,4 +887,3 @@ unittest
     RCArray!int value = null;
     value = null;
 }
-

Original file line number	Diff line number	Diff line change
`@@ -887,4 +887,3 @@ unittest`
`887`	`887`	`RCArray!int value = null;`
`888`	`888`	`value = null;`
`889`	`889`	`}`
`890`		`-`