Merge pull request #36 from libmir/mir-2.0

update mir-algorithm

Makefile

@@ -7,11 +7,11 @@ clean:
 
 doc:
 	rm -rf docs
-	# allow failure
-	dub build -b=ddox --compiler=dmd && mv docs ddox || true
+	## allow failure
+	# dub build -b=ddox --compiler=dmd && mv docs ddox || true
 	dub run -b=docs --compiler=dmd
 	mv docs/package.html docs/index.html
-	mv ddox docs/ddox || true
+	# mv ddox docs/ddox || true
 
 ddoc:
 	rm -rf docs

dub.json

@@ -7,8 +7,8 @@
     ],
     "description": "numpy-like API wrappers of mir",
     "dependencies": {
-        "mir-algorithm": ">=0.8.0 <2.0.0",
-        "mir-random": "~>0.4.0"
+        "mir-algorithm": "~>2.0.1",
+        "mir-random": "~>1.0.0"
     },
     "copyright": "Copyright © 2017, karita",
     "license": "BSL-1.0",

source/numir/core/creation.d

@@ -405,8 +405,8 @@ unittest
 /++
 Returns a slice with numbers evenly spaced over a log scale.
 
-In linear space, the sequence starts at `base ^^ start` (`base to the power of
-`start) and ends with `base ^^ stop`.
+In linear space, the sequence starts at `base ^^ start`
+(`base to the power of `start) and ends with `base ^^ stop`.
 
 Params:
     start = `base ^^ start` is the value of the first element
@@ -444,12 +444,9 @@ Returns:
 +/
 template diag(size_t dimension = 1)
 {
-    auto diag(SliceKind kind, size_t[] packs, Iterator)
-                           (Slice!(kind, packs, Iterator) s, size_t k = 0) pure
-        if (isMatrix!(Slice!(kind, packs, Iterator)))
+    auto diag(S)(S s, size_t k = 0) pure if (isMatrix!S)
     {
         import mir.ndslice.topology : diagonal;
-
         auto sk = s.select!dimension(k, s.length!dimension);
         return sk.diagonal;
     }
@@ -480,15 +477,12 @@ Params:
 Returns:
     diagonal 2-dimensional slice
 +/
-auto diag(SliceKind kind, size_t[] packs, Iterator)
-                       (Slice!(kind, packs, Iterator) s) pure
-    if (isVector!(Slice!(kind, packs, Iterator)))
+auto diag(S)(S s) pure if (isVector!S)
 {
      import mir.ndslice.topology : diagonal;
      import mir.ndslice.slice : DeepElementType;
 
-     alias zeroType = DeepElementType!(Slice!(kind, packs, Iterator));
-
+     alias zeroType = DeepElementType!S;
      auto result = zeros!(zeroType)([s.length, s.length]);
      result.diagonal[] = s;
      return result;

source/numir/core/manipulation.d

@@ -5,6 +5,7 @@ module numir.core.manipulation;
 
 // TODO use more isSlice when template type T assumed to be Slice.
 import mir.ndslice.slice : isSlice;
+import mir.primitives : DimensionCount;
 
 /++
 Create a slice of element type `E` with shape matching the shape of `a` and
@@ -66,21 +67,21 @@ auto concatenate(int axis=0, Slices...)(Slices slices) pure
 {
     import mir.ndslice.concatenation : concatenation;
     import mir.ndslice.allocation : slice;
-    import numir.core.utility : Ndim, view;
+    import numir.core.utility : view;
     import std.format : format;
     import std.meta : staticMap;
 
-    enum int N = Ndim!(Slices[0]);
+    enum int N = DimensionCount!(Slices[0]);
     static assert(-N <= axis, "out of bounds: axis(=%s) < %s".format(axis, -N));
     static assert(axis < N, "out of bounds: %s <= axis(=%s)".format(N, axis));
     static if (axis < 0) {
         enum axis = axis + N;
     }
 
     foreach (S; Slices) {
-        static assert(Ndim!S == N,
+        static assert(DimensionCount!S == N,
                       "all the input arrays must have same number of dimensions: %s"
-                      .format([staticMap!(Ndim, Slices)]));
+                      .format([staticMap!(DimensionCount, Slices)]));
     }
 
     return concatenation!axis(slices).slice;
@@ -134,9 +135,9 @@ Returns:
 +/
 auto unsqueeze(long axis, S)(S s) pure
 {
-    import numir.core.utility : Ndim, view;
+    import numir.core.utility : view;
 
-    enum long n = Ndim!S;
+    enum long n = DimensionCount!S;
     enum size_t[1] input = [1];
     enum a = axis < 0 ? n + axis + 1 : axis;
     ptrdiff_t[n + 1] shape = cast(ptrdiff_t[a]) s.shape[0 .. a]
@@ -178,8 +179,8 @@ Returns:
 +/
 auto squeeze(long axis, S)(S s) pure
 {
-    import numir.core.utility : Ndim, view;
-    enum long n = Ndim!S;
+    import numir.core.utility : view;
+    enum long n = DimensionCount!S;
     enum a = axis < 0 ? n + axis : axis;
     assert(s.shape[a] == 1);
 
@@ -213,7 +214,7 @@ Returns:
     new slice with new length
 
 TODO:
-    support n-dimentional new shape
+    support n-dimensional new shape
 +/
 auto resize(S)(S s, size_t size) pure if (isSlice!S)
 out(ret) {
@@ -253,21 +254,20 @@ unittest {
 
 /++
 Similar to `mir.ndslice.topology.byDim` but `alongDim` does transposed and pack on the input slice along `dim`.
-This `axis` also can be negative as `-dim == Ndim!S - dim` like numpy.
+This `axis` also can be negative as `-dim == DimensionCount!S - dim` like numpy.
 
 Params:
     s = input slice
 
 Returns:
-    s.transposed(0 .. Ndim!S, dim).pack!1
+    s.transposed(0 .. DimensionCount!S, dim).pack!1
 
 See_Also:
     `s.alongDim!axis.map!func` is equivalent to numpy.apply_along_axis https://docs.scipy.org/doc/numpy/reference/generated/numpy.apply_along_axis.html
  +/
 auto alongDim(ptrdiff_t dim, S)(S s) if (isSlice!S)
 {
-    import numir.core.utility : Ndim;
-    enum n = Ndim!S;
+    enum n = DimensionCount!S;
     enum a = dim >= 0 ? dim : n + dim;
     static assert(a < n);
 

source/numir/core/utility.d

@@ -3,7 +3,7 @@ Various slice utility (e.g., ndim, view, type functions)
  +/
 module numir.core.utility;
 
-import mir.ndslice.slice : Slice, SliceKind;
+import mir.ndslice.slice : Slice, SliceKind, isSlice;
 
 /++
 Returns the number of dimensions of type `R`.
@@ -108,64 +108,6 @@ unittest
     assert(e.dtype != typeid(float));
 }
 
-/++
-Returns the number of dimensions of a Slice.
-+/
-template Ndim(S)
-{
-    enum Ndim = ndim(S());
-}
-
-///
-unittest
-{
-    import mir.ndslice.topology : iota;
-
-    auto e = iota(2, 3, 1, 3);
-    static assert(Ndim!(typeof(e)) == 4);
-}
-
-unittest
-{
-    import mir.ndslice.topology : iota, pack;
-
-    auto e = iota(3, 4, 5, 6).pack!2;
-    static assert(Ndim!(typeof(e)) == 4);
-}
-
-/++
-Returns the number of dimensions of a slice.
-
-Params:
-    s = n-dimensional slice
-
-Returns:
-    number of dimensions
-+/
-size_t ndim(SliceKind kind, size_t[] packs, Iterator)(Slice!(kind, packs, Iterator) s)
-{
-    import mir.ndslice.internal: sum;
-
-    return packs.sum;
-}
-
-///
-unittest
-{
-    import mir.ndslice.topology : iota;
-
-    auto e = iota(2, 3, 1, 3);
-    assert(e.ndim == 4);
-}
-
-unittest
-{
-    import mir.ndslice.topology : iota, pack;
-
-    auto e = iota(3, 4, 5, 6).pack!2;
-    assert(e.ndim == 4);
-}
-
 /++
 Return the number of bytes to step in each dimension when traversing a slice.
 
@@ -206,7 +148,7 @@ Returns:
 +/
 auto size(S)(S s) pure
 {
-    return s.elementsCount;
+    return s.elementCount;
 }
 
 ///
@@ -315,3 +257,25 @@ unittest
         assert(e.msg.split(":")[0] == "ReshapeError");
     }
 }
+
+/++
+Returns the number of dimensions of a slice.
+Params:
+    s = n-dimensional slice
+Returns:
+    number of dimensions
++/
+size_t ndim(S)(S s) if (isSlice!S)
+{
+    import mir.primitives : DimensionCount;
+    return DimensionCount!S;
+}
+
+///
+unittest
+{
+    import mir.ndslice.topology : iota;
+
+    auto e = iota(2, 3, 1, 3);
+    assert(e.ndim == 4);
+}