Adds reinterpret_const with a test. (#86)

Author: jiawen

include/array/array.h

@@ -1240,7 +1240,7 @@ NDARRAY_HOST_DEVICE auto transpose_impl(const Shape& shape, index_sequence<Extra
  shape.template dim<DimIndices>()..., shape.template dim<sizeof...(DimIndices) + Extras>()...);
 }
 
-}  // namespace internal
+} // namespace internal
 
 /** Create a new shape using a list of `DimIndices...` to use as the
  * dimensions of the shape. The new shape's i'th dimension will be the
@@ -1252,7 +1252,8 @@ NDARRAY_HOST_DEVICE auto transpose_impl(const Shape& shape, index_sequence<Extra
  *
  * Examples:
  * - `transpose<2, 0, 1>(s) == make_shape(s.dim<2>(), s.dim<0>(), s.dim<1>())`
- * - `transpose<1, 0>(s) == make_shape(s.dim<1>(), s.dim<0>(), ...)` where ... is all dimensions after dimension 1. */
+ * - `transpose<1, 0>(s) == make_shape(s.dim<1>(), s.dim<0>(), ...)` where ... is all dimensions
+ * after dimension 1. */
 template <size_t... DimIndices, class... Dims,
  class = internal::enable_if_permutation<sizeof...(DimIndices), DimIndices...>>
 NDARRAY_HOST_DEVICE auto transpose(const shape<Dims...>& shape) {
@@ -1391,8 +1392,7 @@ NDARRAY_INLINE NDARRAY_HOST_DEVICE void for_each_value_in_order(
 
 // Scalar buffers are a special case. The enable_if here (and above) are a workaround for a bug in
 // old versions of GCC that causes this overload to be ambiguous.
-template <size_t D, class Fn, class... Ptrs,
- std::enable_if_t<(D == -1), int> = 0>
+template <size_t D, class Fn, class... Ptrs, std::enable_if_t<(D == -1), int> = 0>
 NDARRAY_INLINE NDARRAY_HOST_DEVICE void for_each_value_in_order(
  const std::tuple<>& extent, Fn&& fn, Ptrs... ptrs) {
  fn(*std::get<0>(ptrs)...);
@@ -1553,7 +1553,8 @@ NDARRAY_HOST_DEVICE auto make_compact(const Shape& s) {
 
 /** A `shape` where all extents (and automatically computed compact strides) are constant. */
 template <index_t... Extents>
-using fixed_dense_shape = decltype(make_shape_from_tuple(internal::make_compact_dims<1>(dim<0, Extents>()...)));
+using fixed_dense_shape =
+ decltype(make_shape_from_tuple(internal::make_compact_dims<1>(dim<0, Extents>()...)));
 
 /** Returns `true` if a shape `src` can be assigned to a shape of type
  * `ShapeDst` without error. */
@@ -2870,6 +2871,13 @@ const_array_ref<U, Shape> reinterpret(const array<T, Shape, Alloc>& a) {
  return reinterpret<const U>(a.cref());
 }
 
+/** Reinterpret the const_array_ref `a` of type `T` (aka array_ref<const T>) to have a different
+ * type `U` using `const_cast`. */
+template <class U, class T, class Shape>
+array_ref<U, Shape> reinterpret_const(const const_array_ref<T, Shape>& a) {
+ return array_ref<U, Shape>(const_cast<U*>(a.base()), a.shape());
+}
+
 /** Reinterpret the shape of the array or array_ref `a` to be a new shape
  * `new_shape`, with a base pointer offset `offset`. */
 template <class NewShape, class T, class OldShape>

test/BUILD.bazel

@@ -4,6 +4,7 @@ cc_test(
  srcs = [
  "algorithm.cpp",
  "array.cpp",
+ "array_ref.cpp",
  "ein_reduce.cpp",
  "image.cpp",
  "lifetime.cpp",

test/array_ref.cpp

@@ -60,6 +60,23 @@ TEST(reinterpret) {
  ASSERT_EQ(scalar(), eight);
 }
 
+TEST(reinterpret_const) {
+ array_of_rank<int, 1> a1({3});
+ a1(0) = 5;
+ a1(1) = 2;
+ a1(2) = 6;
+
+ const_array_ref_of_rank<int, 1> a1_cref = a1.cref();
+ array_ref_of_rank<int, 1> a1_ref = reinterpret_const<int>(a1_cref);
+ a1_ref(0) = 10;
+ a1_ref(1) = 20;
+ a1_ref(2) = 30;
+
+ ASSERT_EQ(a1(0), 10);
+ ASSERT_EQ(a1(1), 20);
+ ASSERT_EQ(a1(2), 30);
+}
+
 TEST(array_ref_copy) {
  int data[100];
  for (int i = 0; i < 100; i++) {
@@ -87,8 +104,8 @@ TEST(array_ref_incompatible_shape) {
  }
 
  {
- array_ref<int, nda::shape<nda::fixed_dim<10, nda::dynamic>,
-  nda::fixed_dim<2, nda::dynamic>>> dst;
+ array_ref<int, nda::shape<nda::fixed_dim<10, nda::dynamic>, nda::fixed_dim<2, nda::dynamic>>>
+ dst;
  array_ref<int, nda::shape_of_rank<2>> src(nullptr, {{0, 10}, {0, 3}});
  // Error converting dim 1: expected static extent 2, got 3
  // dst = src;
@@ -194,11 +211,11 @@ TEST(array_ref_static_convertibilty) {
  using AR3 = array_ref_of_rank<int, 3>;
 
  static_assert(std::is_convertible<AR0&, int&>::value,
-  "rank-0 array_ref should be convertible to scalar element");
+ "rank-0 array_ref should be convertible to scalar element");
  static_assert(std::is_convertible<const AR0&, int&>::value,
-  "rank-0 array_ref should be convertible to scalar element");
+ "rank-0 array_ref should be convertible to scalar element");
  static_assert(!std::is_convertible<AR3&, int&>::value,
-  "rank-3 array_ref should not be convertible to element");
+ "rank-3 array_ref should not be convertible to element");
 }
 
 TEST(array_ref_crop_slice) {

test/errors.cpp

@@ -86,9 +86,7 @@ void shape_operator_eq_different_rank() {
  s == s2;
 }
 
-void shape_modify_runtime_dim() {
- s.dim(1).set_min(0);
-}
+void shape_modify_runtime_dim() { s.dim(1).set_min(0); }
 
 void is_compatible_different_dims() { is_compatible<shape_of_rank<3>>(s); }
 
@@ -148,6 +146,15 @@ void make_move_different_rank() { auto a2 = make_move(a, shape_of_rank<2>()); }
 
 void make_move_ref_different_rank() { auto a2 = make_move(ref, shape_of_rank<3>()); }
 
+// When uncommented, this fails to compile as expected, but since the error is due to `const_cast`
+// itself, it will say something like:
+//
+// include/array/array.h:2878:30: error: const_cast from 'nda::array_ref<const int,
+// nda::shape<nda::dim<-9, -9, 1>, nda::dim<-9, -9, -9>, nda::dim<-9, -9, -9>>>::pointer' (aka
+// 'const int *') to 'float *' is not allowed
+//
+// void reinterpret_const_wrong_type() { reinterpret_const<float>(a.cref()); }
+
 void ein_wrong_rank() { ein<0, 1>(a); }
 
 void ein_scalar_arithmetic() { ein<0, 1, 2>(a) + 2; }