CUTLASS 3.5.0 (#1411)

include/cute/int_tuple.hpp

@@ -218,7 +218,7 @@ static constexpr int depth_v = depth_t<Tuple>::value;
 // product
 //
 
-// Implementation of product (see below) as a function object
+// Implementation of product as a function object
 struct Product
 {
   template <class IntTuple>
@@ -232,7 +232,7 @@ struct Product
       } else {
         return cute::transform_apply(a, Product{}, multiplies_unary_lfold{});
       }
-    } else {
+    } else if constexpr (cute::is_integral<IntTuple>::value) {
       return a;
     }
 
@@ -248,7 +248,7 @@ CUTE_HOST_DEVICE constexpr
 auto
 product_each(Tuple const& t)
 {
-  return transform(wrap(t), [](auto const& x) { return product(x); });
+  return transform(wrap(t), product);
 }
 
 // Take the product of Tuple at the leaves of TupleG
@@ -394,7 +394,7 @@ shape_div(IntTupleA const& a, IntTupleB const& b)
     static_assert(IntTupleA::value % IntTupleB::value == 0 || IntTupleB::value % IntTupleA::value == 0, "Static shape_div failure");
     return C<shape_div(IntTupleA::value, IntTupleB::value)>{};
   } else {                                       // int int
-    //assert(a % b == 0 || b % a == 0);          // Wave dynamic assertion
+    //assert(a % b == 0 || b % a == 0);          // Waive dynamic assertion
     return a / b != 0 ? a / b : signum(a) * signum(b);  // Division with rounding away from zero
   }
 
@@ -855,7 +855,10 @@ elem_geq(T const& t, U const& u) {
   return !elem_less(t, u);
 }
 
+namespace detail {
+
 /** Increment a (dynamic) coord lexicographically within a shape
+ * @pre is_congruent<Coord,Shape>::value
  * \code
  *    auto shape = make_shape(1,2,make_shape(2,3),3);
  *
@@ -866,44 +869,26 @@ elem_geq(T const& t, U const& u) {
  *   assert(i == size(shape));
  * \endcode
  */
-template <class Coord, class Shape>
+template <int I = 0, class Coord, class Shape>
 CUTE_HOST_DEVICE constexpr
 void
-increment(Coord& coord, Shape const& shape);
-
-namespace detail {
-
-template <class Coord, class Shape, int I0, int... Is>
-CUTE_HOST_DEVICE constexpr
-void
-increment(Coord& coord, Shape const& shape, seq<I0,Is...>)
+increment(Coord& coord, Shape const& shape)
 {
-  cute::increment(get<I0>(coord), get<I0>(shape));
-  if constexpr (sizeof...(Is) != 0) {
-    if (back(get<I0>(coord)) == back(get<I0>(shape))) {
-      back(get<I0>(coord)) = 0;
-      increment(coord, shape, seq<Is...>{});
+  if constexpr (is_integral<Coord>::value) {
+    ++coord;
+  } else {
+    increment(get<I>(coord), get<I>(shape));
+    if constexpr (I+1 < tuple_size<Coord>::value) {
+      if (back(get<I>(coord)) == back(get<I>(shape))) {
+        back(get<I>(coord)) = 0;
+        increment<I+1>(coord, shape);
+      }
     }
   }
 }
 
 } // end namespace detail
 
-template <class Coord, class Shape>
-CUTE_HOST_DEVICE constexpr
-void
-increment(Coord& coord, Shape const& shape)
-{
-  if constexpr (is_integral<Coord>::value && is_integral<Shape>::value) {
-    ++coord;
-  } else if constexpr (is_tuple<Coord>::value && is_tuple<Shape>::value) {
-    static_assert(tuple_size<Coord>::value == tuple_size<Shape>::value, "Mismatched ranks");
-    detail::increment(coord, shape, tuple_seq<Coord>{});
-  } else {
-    static_assert(sizeof(Coord) == 0, "Invalid parameters");
-  }
-}
-
 struct ForwardCoordIteratorSentinal
 {};
 
@@ -918,7 +903,7 @@ struct ForwardCoordIterator
   Coord const& operator*() const { return coord; }
 
   CUTE_HOST_DEVICE constexpr
-  ForwardCoordIterator& operator++() { increment(coord, shape); return *this; }
+  ForwardCoordIterator& operator++() { detail::increment(coord, shape); return *this; }
 
   // Sentinel for the end of the implied range
   CUTE_HOST_DEVICE constexpr