Rework mir.interpolate (#213)

* rework constant and linear interpolations

* update spline implementation

* update polynomial interpolation

* add C++ interpolate header

* fix docs

* fix build

* remove DIPS configuration support from unittests

* fix unittest

* improve parabolaDerivatives

* improve unittests

Author: 9il

.travis.yml

@@ -22,7 +22,7 @@ matrix:
     - {d: gdc}
 script:
  - travis_wait 100 dub test --arch "$ARCH" --build=unittest-cov
- - travis_wait 100 dub test --arch "$ARCH" -c dips
+#  - travis_wait 100 dub test --arch "$ARCH" -c dips
  - ./test_examples.sh
 #  - travis_wait 100 dub test --arch "$ARCH" --build=unittest-release
 

cpp_example/main.cpp

@@ -3,6 +3,7 @@
 #include <cstdlib>
 #include <vector>
 #include <map>
+#include "mir/interpolate.h"
 #include "mir/series.h"
 #include "mir/rcarray.h"
 #include "mir/rcptr.h"

include/mir/interpolate.h

@@ -0,0 +1,32 @@
+
+namespace mir {
+    namespace interpolate
+    {
+        enum class SplineType
+        {
+            c2,
+            cardinal,
+            monotone,
+            doubleQuadratic,
+            akima
+        };
+
+        enum class SplineBoundaryType
+        {
+            periodic = -1,
+            notAKnot,
+            firstDerivative,
+            secondDerivative,
+            parabolic,
+            monotone,
+            akima
+        };
+
+        template<class T>
+        struct SplineBoundaryCondition
+        {
+            SplineBoundaryType type = SplineBoundaryType::notAKnot;
+            T value = 0;
+        };
+    }
+}

source/mir/interpolate/constant.d

@@ -17,15 +17,15 @@ module mir.interpolate.constant;
 
 ///
 version(mir_test)
-@safe pure unittest
+@safe pure @nogc unittest
 {
     import mir.ndslice;
     import mir.math.common: approxEqual;
 
-    immutable x = [0, 1, 2, 3];
-    immutable y = [10, 20, 30, 40];
+    static immutable x = [0, 1, 2, 3];
+    static immutable y = [10, 20, 30, 40];
 
-    auto interpolant = constant!int(x.sliced, y.sliced);
+    auto interpolant = constant!int(x.rcslice, y.rcslice!(const int));
 
     assert(interpolant(-1) == 10);
     assert(interpolant(0) == 10);
@@ -38,15 +38,18 @@ version(mir_test)
 }
 
 
-
-import std.traits;
-import mir.primitives;
-import mir.ndslice.slice;
+import core.lifetime: move; 
 import mir.internal.utility;
+import mir.functional;
+import mir.interpolate;
 import mir.math.common: optmath;
-
+import mir.ndslice.slice;
+import mir.primitives;
+import mir.rc.array;
+import mir.utility: min, max;
+import std.meta: AliasSeq, staticMap;
+import std.traits;
 public import mir.interpolate: atInterval;
-import mir.interpolate;
 
 /++
 Constructs multivariate constant interpolant with nodes on rectilinear grid.
@@ -60,97 +63,66 @@ Constraints:
 
 Returns: $(LREF Constant)
 +/
-template constant(T, size_t N = 1, FirstGridIterator = immutable(T)*, NextGridIterators = Repeat!(N - 1, FirstGridIterator))
-    if (is(T == Unqual!T) && N <= 6)
+Constant!(F, N, X) constant(F, size_t N = 1, X = F)
+    (Repeat!(N, Slice!(RCI!(immutable X))) grid, Slice!(RCI!(const F), N) values)
 {
-    static if (N > 1) pragma(msg, "Warning: multivariate constant interpolant was not tested.");
-
-    import std.meta: AliasSeq;
-
-@optmath:
-
-    private alias GridIterators = AliasSeq!(FirstGridIterator, NextGridIterators);
-    private alias GridVectors = Constant!(T, N, GridIterators).GridVectors;
-
-    /++
-    Params:
-        grid = immutable `x` values for interpolant
-        values = `f(x)` values for interpolant
-    Constraints:
-        `grid` and `values` must have the same length >= 3
-    Returns: $(LREF Spline)
-    +/
-    Constant!(T, N, GridIterators) constant(yIterator, SliceKind ykind)(
-        GridVectors grid,
-        Slice!(yIterator, 1, ykind) values
-        ) pure @trusted
-    {
-        static if (__VERSION__ >= 2085) import core.lifetime: move; else import std.algorithm.mutation: move; 
-        auto ret = typeof(return)(grid);
-        ret._data[] = values;
-        return ret.move;
-    }
+    return typeof(return)(forward!grid, values.move);
 }
 
 /++
 Multivariate constant interpolant with nodes on rectilinear grid.
 +/
-struct Constant(F, size_t N = 1, FirstGridIterator = immutable(F)*, NextGridIterators = Repeat!(N - 1, FirstGridIterator))
-    if (N && N <= 6 && NextGridIterators.length == N - 1)
+extern(C++, "mir", "interpolate")
+struct Constant(F, size_t N = 1, X = F)
+    if (N && N <= 6)
 {
-    import mir.rc.array;
-    import std.meta: AliasSeq, staticMap;
-
-    package alias GridIterators = AliasSeq!(FirstGridIterator, NextGridIterators);
-    package alias GridVectors = staticMap!(GridVector, GridIterators);
-
 @optmath:
 
     /// Aligned buffer allocated with `mir.internal.memory`. $(RED For internal use.)
-    mir_slice!(mir_rci!F, N) _data;
+    Slice!(RCI!(const F), N) _data;
     /// Grid iterators. $(RED For internal use.)
-    GridIterators _grid;
+    RCI!(immutable X)[N] _grid;
 
-    import mir.utility: min, max;
+extern(D):
 
     /++
     +/
-    this(GridVectors grid) @safe @nogc
+    this(Repeat!(N, Slice!(RCI!(immutable X))) grid, Slice!(RCI!(const F), N) data) @safe @nogc
     {
-        size_t length = 1;
-        size_t[N] shape;
-        enum  msg =  "constant interpolant: minimal allowed length for the grid equals 1.";
+        enum  msg_min =  "constant interpolant: minimal allowed length for the grid equals 1.";
+        enum  msg_eq =  "constant interpolant: X and Y values length should be equal.";
         version(D_Exceptions)
-            static immutable exc = new Exception(msg);
+        {
+            static immutable exc_min = new Exception(msg_min);
+            static immutable exc_eq = new Exception(msg_eq);
+        }
         foreach(i, ref x; grid)
         {
             if (x.length < 1)
             {
-                version(D_Exceptions)
-                    throw exc;
-                else
-                    assert(0, msg);
+                version(D_Exceptions) throw exc_min;
+                else assert(0, msg_min);
+            }
+            if (x.length != data._lengths[i])
+            {
+                version(D_Exceptions) throw exc_eq;
+                else assert(0, msg_eq);
             }
-            length *= shape[i] = x.length;
+            _grid[i] = x._iterator;
         }
-
-        auto rca = mir_rcarray!F(length);
-        this._data = rca.asSlice.sliced(shape);
-        this._grid = staticMap!(iter, grid);
+        _data = data;
     }
 
 @trusted:
 
     ///
     Constant lightConst()() const @property { return *cast(Constant*)&this; }
-    ///
-    Constant lightImmutable()() immutable @property { return *cast(Constant*)&this; }
 
     ///
-    GridVectors[dimension] grid(size_t dimension = 0)() scope return const @property
+    Slice!(RCI!(immutable X)) grid(size_t dimension = 0)() scope return const @property
         if (dimension < N)
     {
-        return _grid[dimension].sliced(_data._lengths[dimension]);
+        return _grid[dimension].lightConst.sliced(_data._lengths[dimension]);
     }
 
     /++
@@ -175,19 +147,15 @@ struct Constant(F, size_t N = 1, FirstGridIterator = immutable(F)*, NextGridIter
     template opCall(uint derivative = 0)
         if (derivative <= derivativeOrder)
     {
-        @trusted:
         /++
-        `(x)` and `[x]` operators.
+        `(x)` operator.
         Complexity:
             `O(log(grid.length))`
         +/
-        auto opCall(X...)(in X xs) scope const
+        auto opCall(X...)(in X xs) scope const @trusted
             if (X.length == N)
-            // @FUTURE@
-            // X.length == N || derivative == 0 && X.length && X.length <= N
         {
             size_t[N] indexes = void;
-
             foreach(i; Iota!N)
             {
                 static if (isInterval!(typeof(xs[i])))