add rcfuse

Author: 9il

meson.build

@@ -31,7 +31,6 @@ mir_algorithm_src = [
     'source/mir/interpolate/constant.d',
     'source/mir/interpolate/linear.d',
     'source/mir/interpolate/package.d',
-    'source/mir/interpolate/pchip.d',
     'source/mir/interpolate/spline.d',
     'source/mir/interpolate/utility.d',
     'source/mir/math/func/expdigamma.d',

source/mir/interpolate/package.d

@@ -101,7 +101,7 @@ Returns:
     Lazy input range.
 See_also:
     $(SUBREF linear, linear),
-    $(SUBREF pchip, pchip).
+    $(SUBREF spline, spline).
 +/
 auto interp1(Range, Interpolant)(Range range, Interpolant interpolant, size_t interval = 0)
 {

source/mir/interpolate/pchip.d

@@ -171,6 +171,36 @@ version(mir_test)
     static assert(is(typeof(tensor) == Slice!(RCI!ptrdiff_t, 2)));
 }
 
+/++
+Allocates an n-dimensional reference-counted (thread-safe) slice without memory initialisation.
+Params:
+    lengths = List of lengths for each dimension.
+    init = Value to initialize with (optional).
+    slice = Slice to copy shape and data from (optional).
+Returns:
+    n-dimensional slice
++/
+Slice!(RCI!T, N)
+    uninitRCslice(T, size_t N)(size_t[N] lengths...)
+{
+    immutable len = lengths.lengthsProduct;
+    auto _lengths = lengths;
+    return typeof(return)(_lengths, RCI!T(RCArray!T(len, false)));
+}
+
+///
+version(mir_test)
+@safe pure nothrow @nogc unittest
+{
+    import mir.ndslice.slice: Slice;
+    import mir.rc.array: RCI;
+    auto tensor = uninitRCslice!int(5, 6, 7);
+    tensor[] = 1;
+    assert(tensor.length == 5);
+    assert(tensor.elementCount == 5 * 6 * 7);
+    static assert(is(typeof(tensor) == Slice!(RCI!int, 3)));
+}
+
 /++
 Allocates a bitwise packed n-dimensional reference-counted (thread-safe) boolean slice.
 Params:

source/mir/ndslice/allocation.d

@@ -28,24 +28,29 @@ import mir.math.common: optmath;
 @optmath:
 
 /++
-Fuses ndrange `r` into GC-allocated ndslice. Can be used to join rows or columns into a matrix.
+Fuses ndrange `r` into GC-allocated (`fuse`) or RC-allocated (`rcfuse`) ndslice. Can be used to join rows or columns into a matrix.
 
 Params:
     Dimensions = (optional) indexes of dimensions to be brought to the first position
 Returns:
     ndslice
 +/
-template fuse(Dimensions...)
+///
+alias fuse(Dimensions...) = fuseImpl!(false, Dimensions);
+///
+alias rcfuse(Dimensions...) = fuseImpl!(true, Dimensions);
+/// ditto
+template fuseImpl(bool RC, Dimensions...)
 {
     import mir.ndslice.internal: isSize_t, toSize_t;
     static if (!allSatisfy!(isSize_t, Dimensions))
-        alias fuse = .fuse!(staticMap!(toSize_t, Dimensions));
+        alias fuseImpl = .fuseImpl!(RC, staticMap!(toSize_t, Dimensions));
     else
     /++
     Params:
         r = parallelotope (ndrange) with length/shape and input range primitives.
     +/
-    @optmath Slice!(FuseElementType!NDRange*, fuseDimensionCount!NDRange) fuse(NDRange)(NDRange r)
+    @optmath auto fuseImpl(NDRange)(NDRange r)
         if (hasShape!NDRange)
     {
         import mir.conv: emplaceRef;
@@ -54,8 +59,17 @@ template fuse(Dimensions...)
         auto shape = fuseShape(r);
         alias T = FuseElementType!NDRange;
         alias UT = Unqual!T;
-        alias R = typeof(return);
-        Slice!(UT*, fuseDimensionCount!NDRange) ret;
+        static if (RC)
+        {
+            import mir.rc.array: RCI;
+            alias R = Slice!(RCI!T, fuseDimensionCount!NDRange);
+            Slice!(RCI!UT, fuseDimensionCount!NDRange) ret;
+        }
+        else
+        {
+            alias R = Slice!(T*, fuseDimensionCount!NDRange);
+            Slice!(UT*, fuseDimensionCount!NDRange) ret;
+        }
         static if (Dimensions.length)
         {
             import mir.ndslice.topology: iota;
@@ -72,40 +86,66 @@ template fuse(Dimensions...)
                     return ar;
                 }(perm)
             );
-            if (__ctfe)
+            static if (RC)
             {
-                ret = shapep.slice!UT;
-                ret.transposed!InverseDimensions.each!"a = b"(r);
+                ret = shapep.uninitRcslice!UT;
+                ret.lightScope.transposed!InverseDimensions.each!(emplaceRef!T)(r);
             }
             else
             {
-                ret = shapep.uninitSlice!UT;
-                ret.transposed!InverseDimensions.each!(emplaceRef!T)(r);
+                if (__ctfe)
+                {
+                    ret = shapep.slice!UT;
+                    ret.transposed!InverseDimensions.each!"a = b"(r);
+                }
+                else
+                {
+                    ret = shapep.uninitSlice!UT;
+                    ret.transposed!InverseDimensions.each!(emplaceRef!T)(r);
+                }
+
             }
         }
         else
         {
-            if (__ctfe)
+            static if (RC)
             {
-                ret = shape.slice!UT;
-                ret.each!"a = b"(r);
+                ret = shape.uninitRCslice!UT;
+                ret.lightScope.each!(emplaceRef!T)(r);
             }
             else
             {
-                ret = shape.uninitSlice!UT;
-                ret.each!(emplaceRef!T)(r);
+                if (__ctfe)
+                {
+                    ret = shape.slice!UT;
+                    ret.each!"a = b"(r);
+                }
+                else
+                {
+                    ret = shape.uninitSlice!UT;
+                    ret.each!(emplaceRef!T)(r);
+                }
             }
         }
-        return R(ret._structure, (() @trusted => cast(T*)ret._iterator)());
+        static if (RC)
+        {
+            import core.lifetime: move;
+            return move(*(() @trusted => cast(R*)&ret)());
+        }
+        else
+        {
+            return *(() @trusted => cast(R*)&ret)();
+        }
     }
 }
 
 ///
-unittest
+@safe pure nothrow version(mir_test) unittest
 {
     import mir.ndslice.fuse;
-    import mir.ndslice.topology: iota;
     import mir.ndslice.slice : Contiguous, Slice;
+    import mir.ndslice.topology: iota;
+    import mir.rc.array: RCI;
 
     enum ror = [
             [0, 1, 2, 3],
@@ -117,14 +157,19 @@ unittest
     //  8  9 10 11
     auto matrix = ror.fuse;
 
+    auto rcmatrix = ror.rcfuse; // nogc version
+
     assert(matrix == [3, 4].iota);
+    assert(rcmatrix == [3, 4].iota);
     static assert(ror.fuse == [3, 4].iota); // CTFE-able
+
     // matrix is contiguos
     static assert(is(typeof(matrix) == Slice!(int*, 2)));
+    static assert(is(typeof(rcmatrix) == Slice!(RCI!int, 2)));
 }
 
 /// Transposed
-unittest
+@safe pure nothrow version(mir_test) unittest
 {
     import mir.ndslice.fuse;
     import mir.ndslice.topology: iota;
@@ -153,7 +198,7 @@ unittest
 
 
 /// 3D
-unittest
+@safe pure nothrow version(mir_test) unittest
 {
     import mir.ndslice.fuse;
     import mir.ndslice.topology: iota;
@@ -174,7 +219,7 @@ unittest
 }
 
 /// Work with RC Arrays of RC Arrays
-unittest
+@safe pure nothrow version(mir_test) unittest
 {
     import mir.ndslice.fuse;
     import mir.ndslice.slice;