fix Issue #115

Author: 9il

source/mir/math/numeric.d

@@ -12,6 +12,7 @@ Sponsors: This work has been sponsored by $(SUBREF http://symmetryinvestments.co
 module mir.math.numeric;
 
 import mir.math.common;
+import mir.primitives;
 
 import std.traits;
 
@@ -33,7 +34,7 @@ struct Prod(T)
         exp += lexp;
         if (x.fabs < 0.5f)
         {
-            x *= 2;
+            x += x;
             exp--;
         }
 	}
@@ -54,27 +55,27 @@ struct Prod(T)
 /++
 Compute the product of the input range $(D r) using separate exponent accumulation.
 +/
-Unqual!(ForeachType!Range) prod(Range)(Range r, ref long exp)
-	if (isFloatingPoint!(ForeachType!Range))
+Unqual!(DeepElementType!Range) prod(Range)(Range r, ref long exp)
+	if (isFloatingPoint!(DeepElementType!Range))
 {
+    import mir.ndslice.algorithm: each;
     Prod!(typeof(return)) prod;
-    foreach (e; r)
-	    prod.put(e);
+    r.each!(e => prod.put(e));
     exp = prod.exp;
     return prod.x;
 }
 
 /// ditto
-Unqual!(ForeachType!Range) prod(Range)(Range r)
-	if (isFloatingPoint!(ForeachType!Range))
+Unqual!(DeepElementType!Range) prod(Range)(Range r)
+	if (isFloatingPoint!(DeepElementType!Range))
 {
 
     long exp;
     auto x = .prod(r, exp);
     return Prod!(typeof(return))(exp, x).value;
 }
 
-///
+/// Arrays and Ranges
 version(mir_test)
 unittest
 {
@@ -87,12 +88,33 @@ unittest
 	assert(r.prod == 0.8 * 2.0 ^^ 10);
 }
 
+/// Ndslices
+version(mir_test)
+unittest
+{
+    import mir.math.numeric: prod;
+    import mir.ndslice.slice: sliced;
+    import mir.ndslice.algorithm: reduce;
+
+	enum l = 2.0 ^^ (double.max_exp - 1);
+	enum s = 2.0 ^^ -(double.max_exp - 1);
+    auto c = 0.8;
+    auto u = c * 2.0 ^^ 10;
+	auto r = [l, l, l,
+              s, s, s,
+              u, u, u].sliced(3, 3);
+	long e;
+	assert(r.prod(e) == reduce!"a * b"(1.0, [c, c, c]));
+	assert(e == 30);
+	assert(r.prod == u * u * u);
+}
+
 /++
 Compute the sum of binary logarithms of the input range $(D r).
 The error of this method is much smaller than with a naive sum of log2.
 +/
-Unqual!(ForeachType!Range) sumOfLog2s(Range)(Range r)
-	if (isFloatingPoint!(ForeachType!Range))
+Unqual!(DeepElementType!Range) sumOfLog2s(Range)(Range r)
+	if (isFloatingPoint!(DeepElementType!Range))
 {
     long exp = 0;
     auto x = .prod(r, exp);

source/mir/ndslice/algorithm.d

@@ -408,6 +408,19 @@ unittest
     assert(resT == 3);
 }
 
+/// Dlang Range API support.
+version(mir_test)
+unittest
+{
+    import mir.ndslice.algorithm: each;
+    import std.range: phobos_iota = iota;
+
+    int s;
+    // 0 1 2 3
+    4.phobos_iota.each!(i => s += i);
+    assert(s == 6);
+}
+
 @safe pure nothrow @nogc
 version(mir_test) unittest
 {

source/mir/ndslice/slice.d

@@ -22,7 +22,6 @@ $(T2 slicedNdField, Creates a slice on top of an ndField.)
 $(T2 kindOf, Extracts $(LREF SliceKind).)
 $(T2 packsOf, Extracts dimension packs from a $(LREF Slice). Alias for $(LREF isSlice).)
 $(T2 isSlice, Extracts dimension packs from a type. Extracts `null` if the template argument is not a `Slice`.)
-$(T2 DeepElementType, Extracts the element type of a $(LREF Slice).)
 $(T2 Structure, A tuple of lengths and strides.)
 )
 

source/mir/primitives.d

@@ -147,11 +147,15 @@ size_t elementsCount(Range)(Range range) @property
 
 /++
 Returns the element type of a struct with `.DeepElemType` inner alias or a type of common array.
+Returns `ForeachType` if struct does not have `.DeepElemType` member.
 +/
 template DeepElementType(S)
     if (is(S == struct) || is(S == class) || is(S == interface))
 {
-    alias DeepElementType = S.DeepElemType;
+    static if (__traits(hasMember, S, "DeepElemType"))
+        alias DeepElementType = S.DeepElemType;
+    else
+        alias DeepElementType = ForeachType!S;
 }
 
 /// ditto
@@ -161,7 +165,8 @@ alias DeepElementType(S : T[], T) = T;
 version(mir_test) unittest
 {
     import mir.ndslice.slice;
-    import mir.ndslice.topology : iota;
+    import std.range: std_iota = iota;
+    static assert(is(DeepElementType!(typeof(std_iota(5))) == int));
     static assert(is(DeepElementType!(Slice!(Universal, [4], const(int)[]))     == const(int)));
     static assert(is(DeepElementType!(Slice!(Universal, [4], immutable(int)*))  == immutable(int)));
 }