Don't allow loops on a single line.

Author: dsharlet

.clang-format

@@ -9,6 +9,6 @@ AllowShortFunctionsOnASingleLine: All
 AllowShortCaseLabelsOnASingleLine: true
 AllowShortBlocksOnASingleLine: Always
 AllowShortIfStatementsOnASingleLine: Always
-AllowShortLoopsOnASingleLine: true
+AllowShortLoopsOnASingleLine: false
 ColumnLimit: 100
 PointerAlignment: Left

array.h

@@ -1257,7 +1257,9 @@ NDARRAY_INLINE NDARRAY_HOST_DEVICE void advance(Ptr& ptr, Ptrs&... ptrs) {
 template <class Fn, class... Ptrs>
 NDARRAY_UNIQUE NDARRAY_HOST_DEVICE void for_each_value_in_order_inner_dense(
     index_t extent, Fn&& fn, Ptrs... ptrs) {
-  for (index_t i = 0; i < extent; i++) { fn(*ptrs++...); }
+  for (index_t i = 0; i < extent; i++) {
+    fn(*ptrs++...);
+  }
 }
 
 // TODO: Try to use a variadic dims approach like for_each_index.
@@ -1549,7 +1551,9 @@ NDARRAY_HOST_DEVICE shape_of_rank<Shape::rank()> dynamic_optimize_shape(const Sh
   for (size_t i = 0; i + 1 < rank;) {
     if (can_fuse(dims[i], dims[i + 1])) {
       dims[i] = fuse(dims[i], dims[i + 1]);
-      for (size_t j = i + 1; j + 1 < rank; j++) { dims[j] = dims[j + 1]; }
+      for (size_t j = i + 1; j + 1 < rank; j++) {
+        dims[j] = dims[j + 1];
+      }
       rank--;
     } else {
       i++;
@@ -1580,7 +1584,9 @@ NDARRAY_HOST_DEVICE auto dynamic_optimize_copy_shapes(const ShapeSrc& src, const
     dim<> dst;
   };
   std::array<copy_dims, rank> dims;
-  for (size_t i = 0; i < rank; i++) { dims[i] = {src_dims[i], dst_dims[i]}; }
+  for (size_t i = 0; i < rank; i++) {
+    dims[i] = {src_dims[i], dst_dims[i]};
+  }
 
   // Sort the dims by the dst stride.
   bubble_sort(dims.begin(), dims.end(),
@@ -1593,7 +1599,9 @@ NDARRAY_HOST_DEVICE auto dynamic_optimize_copy_shapes(const ShapeSrc& src, const
         can_fuse(dims[i].dst, dims[i + 1].dst)) {
       dims[i].src = fuse(dims[i].src, dims[i + 1].src);
       dims[i].dst = fuse(dims[i].dst, dims[i + 1].dst);
-      for (size_t j = i + 1; j + 1 < new_rank; j++) { dims[j] = dims[j + 1]; }
+      for (size_t j = i + 1; j + 1 < new_rank; j++) {
+        dims[j] = dims[j + 1];
+      }
       new_rank--;
     } else {
       i++;

examples/benchmark.h

@@ -30,7 +30,9 @@ double benchmark(F op) {
   long iterations = 1;
   for (int trials = 0; trials < max_trials; trials++) {
     auto t1 = std::chrono::high_resolution_clock::now();
-    for (int j = 0; j < iterations; j++) { op(); }
+    for (int j = 0; j < iterations; j++) {
+      op();
+    }
     auto t2 = std::chrono::high_resolution_clock::now();
     time_per_iteration_s =
         std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count() / (iterations * 1e9);

examples/linear_algebra/conv2d.cpp

@@ -73,7 +73,9 @@ void conv2d_tiled(const Input& input, const Filter& filter, const Output& output
         }
         for (index_t y : output_tile.y()) {
           for (index_t x : output_tile.x()) {
-            for (index_t c : output_tile.c()) { output_tile(x, y, c) = accumulator(x, y, c); }
+            for (index_t c : output_tile.c()) {
+              output_tile(x, y, c) = accumulator(x, y, c);
+            }
           }
         }
       }

examples/linear_algebra/matrix.cpp

@@ -34,7 +34,9 @@ __attribute__((noinline)) void multiply_reduce_cols(
   for (index_t i : c.i()) {
     for (index_t j : c.j()) {
       c(i, j) = 0;
-      for (index_t k : a.j()) { c(i, j) += a(i, k) * b(k, j); }
+      for (index_t k : a.j()) {
+        c(i, j) += a(i, k) * b(k, j);
+      }
     }
   }
 }
@@ -45,7 +47,9 @@ template <typename T>
 __attribute__((noinline)) void multiply_ein_reduce_cols(
     const_matrix_ref<T> a, const_matrix_ref<T> b, matrix_ref<T> c) {
   for (index_t i : c.i()) {
-    for (index_t j : c.j()) { c(i, j) = make_ein_sum<T>(ein<k>(a(i, _)) * ein<k>(b(_, j))); }
+    for (index_t j : c.j()) {
+      c(i, j) = make_ein_sum<T>(ein<k>(a(i, _)) * ein<k>(b(_, j)));
+    }
   }
 }
 
@@ -57,7 +61,9 @@ __attribute__((noinline)) void multiply_ref(
   for (int i = 0; i < M; i++) {
     for (int j = 0; j < N; j++) {
       TC sum = 0;
-      for (int k = 0; k < K; k++) { sum += a[i * K + k] * b[k * N + j]; }
+      for (int k = 0; k < K; k++) {
+        sum += a[i * K + k] * b[k * N + j];
+      }
       c[i * N + j] = sum;
     }
   }
@@ -70,9 +76,13 @@ template <typename T>
 __attribute__((noinline)) void multiply_reduce_rows(
     const_matrix_ref<T> a, const_matrix_ref<T> b, matrix_ref<T> c) {
   for (index_t i : c.i()) {
-    for (index_t j : c.j()) { c(i, j) = 0; }
+    for (index_t j : c.j()) {
+      c(i, j) = 0;
+    }
     for (index_t k : a.j()) {
-      for (index_t j : c.j()) { c(i, j) += a(i, k) * b(k, j); }
+      for (index_t j : c.j()) {
+        c(i, j) += a(i, k) * b(k, j);
+      }
     }
   }
 }
@@ -92,11 +102,15 @@ template <typename T>
 __attribute__((noinline)) void multiply_reduce_matrix(
     const_matrix_ref<T> a, const_matrix_ref<T> b, matrix_ref<T> c) {
   for (index_t i : c.i()) {
-    for (index_t j : c.j()) { c(i, j) = 0; }
+    for (index_t j : c.j()) {
+      c(i, j) = 0;
+    }
   }
   for (index_t k : a.j()) {
     for (index_t i : c.i()) {
-      for (index_t j : c.j()) { c(i, j) += a(i, k) * b(k, j); }
+      for (index_t j : c.j()) {
+        c(i, j) += a(i, k) * b(k, j);
+      }
     }
   }
 }
@@ -180,7 +194,9 @@ __attribute__((noinline)) void multiply_reduce_tiles(
       // Perform the matrix multiplication for this tile.
       for (index_t k : a.j()) {
         for (index_t i : c_ijo.i()) {
-          for (index_t j : c_ijo.j()) { accumulator(i, j) += a(i, k) * b(k, j); }
+          for (index_t j : c_ijo.j()) {
+            accumulator(i, j) += a(i, k) * b(k, j);
+          }
         }
       }
 
@@ -191,7 +207,9 @@ __attribute__((noinline)) void multiply_reduce_tiles(
       copy(accumulator, c_ijo);
 #else
       for (index_t i : c_ijo.i()) {
-        for (index_t j : c_ijo.j()) { c_ijo(i, j) = accumulator(i, j); }
+        for (index_t j : c_ijo.j()) {
+          c_ijo(i, j) = accumulator(i, j);
+        }
       }
 #endif
 #endif
@@ -238,7 +256,9 @@ __attribute__((noinline)) void multiply_ein_reduce_tiles(
       copy(accumulator, c_ijo);
 #else
       for (index_t i : c_ijo.i()) {
-        for (index_t j : c_ijo.j()) { c_ijo(i, j) = accumulator(i, j); }
+        for (index_t j : c_ijo.j()) {
+          c_ijo(i, j) = accumulator(i, j);
+        }
       }
 #endif
 #endif

examples/resample/resample.h

@@ -143,7 +143,9 @@ inline kernel_array build_kernels(
     assert(extent > 0);
     assert(sum > 0.0f);
     dense_array<float, 1> kernel_x({{min, extent}});
-    for (index_t rx : kernel_x.x()) { kernel_x(rx) = buffer(rx) / sum; }
+    for (index_t rx : kernel_x.x()) {
+      kernel_x(rx) = buffer(rx) / sum;
+    }
 
     // Make a copy without the padding, and store it in the kernel array.
     kernels(x) = std::move(kernel_x);
@@ -159,10 +161,14 @@ void resample_y(const TIn& in, const TOut& out, const kernel_array& kernels) {
   for (index_t y : out.y()) {
     const dense_array<float, 1>& kernel_y = kernels(y);
     for (index_t c : out.c()) {
-      for (index_t x : out.x()) { out(x, y, c) = 0.0f; }
+      for (index_t x : out.x()) {
+        out(x, y, c) = 0.0f;
+      }
       for (index_t ry : kernel_y.x()) {
         float kernel_y_ry = kernel_y(ry);
-        for (index_t x : out.x()) { out(x, y, c) += in(x, ry, c) * kernel_y_ry; }
+        for (index_t x : out.x()) {
+          out(x, y, c) += in(x, ry, c) * kernel_y_ry;
+        }
       }
     }
   }
@@ -172,7 +178,9 @@ template <class TIn, class TOut>
 void transpose(const TIn& in, const TOut& out) {
   for (index_t c : out.c()) {
     for (index_t y : out.y()) {
-      for (index_t x : out.x()) { out(x, y, c) = in(y, x, c); }
+      for (index_t x : out.x()) {
+        out(x, y, c) = in(y, x, c);
+      }
     }
   }
 }

image.h

@@ -58,7 +58,9 @@ void for_each_image_index(const Shape& s, Fn&& fn) {
   // communication in the c dimension).
   for (index_t y : s.y()) {
     for (index_t x : s.x()) {
-      for (index_t c : s.c()) { fn(std::make_tuple(x, y, c)); }
+      for (index_t c : s.c()) {
+        fn(std::make_tuple(x, y, c));
+      }
     }
   }
 }

matrix.h

@@ -61,7 +61,9 @@ using small_vector = array<T, vector_shape<Length>, auto_allocator<T, Length>>;
 template <class Shape, class Fn>
 void for_each_matrix_index(const Shape& s, Fn&& fn) {
   for (index_t i : s.i()) {
-    for (index_t j : s.j()) { fn(std::make_tuple(i, j)); }
+    for (index_t j : s.j()) {
+      fn(std::make_tuple(i, j));
+    }
   }
 }
 

test/array.cpp

@@ -19,13 +19,17 @@ namespace nda {
 
 TEST(array_default_constructor) {
   dense_array<int, 1> a({10});
-  for (int x = 0; x < 10; x++) { ASSERT_EQ(a(x), 0); }
+  for (int x = 0; x < 10; x++) {
+    ASSERT_EQ(a(x), 0);
+  }
 
   dense_array<int, 2> b({7, 3});
   ASSERT_EQ(b.width(), 7);
   ASSERT_EQ(b.height(), 3);
   for (int y = 0; y < 3; y++) {
-    for (int x = 0; x < 7; x++) { ASSERT_EQ(b(x, y), 0); }
+    for (int x = 0; x < 7; x++) {
+      ASSERT_EQ(b(x, y), 0);
+    }
   }
 
   dense_array<int, 3> c({5, 9, 3});
@@ -34,15 +38,19 @@ TEST(array_default_constructor) {
   ASSERT_EQ(c.channels(), 3);
   for (int z = 0; z < 3; z++) {
     for (int y = 0; y < 9; y++) {
-      for (int x = 0; x < 5; x++) { ASSERT_EQ(c(x, y, z), 0); }
+      for (int x = 0; x < 5; x++) {
+        ASSERT_EQ(c(x, y, z), 0);
+      }
     }
   }
 
   array<int, shape<dim<>, dim<>>> sparse({{-2, 5, 2}, {4, 10, 20}});
   ASSERT_EQ(sparse.rows(), 5);
   ASSERT_EQ(sparse.columns(), 10);
   for (int y = 4; y < 14; y++) {
-    for (int x = -2; x < 3; x++) { ASSERT_EQ(sparse(x, y), 0); }
+    for (int x = -2; x < 3; x++) {
+      ASSERT_EQ(sparse(x, y), 0);
+    }
   }
 
   sparse.clear();
@@ -52,23 +60,31 @@ TEST(array_default_constructor) {
 
 TEST(array_fill_constructor) {
   dense_array<int, 1> a({10}, 3);
-  for (int x = 0; x < 10; x++) { ASSERT_EQ(a(x), 3); }
+  for (int x = 0; x < 10; x++) {
+    ASSERT_EQ(a(x), 3);
+  }
 
   dense_array<int, 2> b({7, 3}, 5);
   for (int y = 0; y < 3; y++) {
-    for (int x = 0; x < 7; x++) { ASSERT_EQ(b(x, y), 5); }
+    for (int x = 0; x < 7; x++) {
+      ASSERT_EQ(b(x, y), 5);
+    }
   }
 
   dense_array<int, 3> c({5, 9, 3}, 7);
   for (int z = 0; z < 3; z++) {
     for (int y = 0; y < 9; y++) {
-      for (int x = 0; x < 5; x++) { ASSERT_EQ(c(x, y, z), 7); }
+      for (int x = 0; x < 5; x++) {
+        ASSERT_EQ(c(x, y, z), 7);
+      }
     }
   }
 
   array<int, shape<dim<>, dim<>>> sparse({{-2, 5, 2}, {4, 10, 20}}, 13);
   for (int y = 4; y < 14; y++) {
-    for (int x = -2; x < 3; x++) { ASSERT_EQ(sparse(x, y), 13); }
+    for (int x = -2; x < 3; x++) {
+      ASSERT_EQ(sparse(x, y), 13);
+    }
   }
 }
 
@@ -104,19 +120,25 @@ TEST(array_assign) {
 TEST(array_fill_assign) {
   dense_array<int, 1> a;
   a.assign({10}, 3);
-  for (int x = 0; x < 10; x++) { ASSERT_EQ(a(x), 3); }
+  for (int x = 0; x < 10; x++) {
+    ASSERT_EQ(a(x), 3);
+  }
 
   dense_array<int, 2> b;
   b.assign({7, 3}, 5);
   for (int y = 0; y < 3; y++) {
-    for (int x = 0; x < 7; x++) { ASSERT_EQ(b(x, y), 5); }
+    for (int x = 0; x < 7; x++) {
+      ASSERT_EQ(b(x, y), 5);
+    }
   }
 
   dense_array<int, 3> c;
   c.assign({5, 9, 3}, 7);
   for (int z = 0; z < 3; z++) {
     for (int y = 0; y < 9; y++) {
-      for (int x = 0; x < 5; x++) { ASSERT_EQ(c(x, y, z), 7); }
+      for (int x = 0; x < 5; x++) {
+        ASSERT_EQ(c(x, y, z), 7);
+      }
     }
   }
 
@@ -126,7 +148,9 @@ TEST(array_fill_assign) {
 
   sparse.assign(sparse_shape, 13);
   for (int y = 4; y < 14; y++) {
-    for (int x = -2; x < 3; x++) { ASSERT_EQ(sparse(x, y), 13); }
+    for (int x = -2; x < 3; x++) {
+      ASSERT_EQ(sparse(x, y), 13);
+    }
   }
 }
 
@@ -175,13 +199,17 @@ TEST(sparse_array) {
 
   array<int, shape<dim<>, dim<>>> sparse(sparse_shape);
   // Fill the storage with a constant.
-  for (size_t i = 0; i < sparse_shape.flat_extent(); i++) { sparse.data()[i] = 7; }
+  for (size_t i = 0; i < sparse_shape.flat_extent(); i++) {
+    sparse.data()[i] = 7;
+  }
   // Assign a different constant.
   sparse.assign(sparse_shape, 3);
 
   // Check that we assigned all of the elements of the array.
   for (int y = 4; y < 14; y++) {
-    for (int x = -2; x < 3; x++) { ASSERT_EQ(sparse(x, y), 3); }
+    for (int x = -2; x < 3; x++) {
+      ASSERT_EQ(sparse(x, y), 3);
+    }
   }
 
   // Check that only the elements of the array were assigned.

test/array_ref.cpp

@@ -21,7 +21,9 @@ namespace nda {
 
 TEST(array_ref_indices) {
   int data[100];
-  for (int i = 0; i < 100; i++) { data[i] = i; }
+  for (int i = 0; i < 100; i++) {
+    data[i] = i;
+  }
 
   dense_array_ref<int, 1> ref_1d(data, {100});
   for_all_indices(ref_1d.shape(), [&](int x) { ASSERT_EQ(ref_1d(x), x); });
@@ -60,7 +62,9 @@ TEST(reinterpret) {
 
 TEST(array_ref_copy) {
   int data[100];
-  for (int i = 0; i < 100; i++) { data[i] = i; }
+  for (int i = 0; i < 100; i++) {
+    data[i] = i;
+  }
 
   array_ref_of_rank<int, 1> evens(data, {dim<>(0, 50, 2)});
   dense_array<int, 1> evens_copy = make_dense_copy(evens);