Fixed up clang tidy checks and formatting

src/include/rtg/operators.hpp

@@ -263,25 +263,25 @@ struct reshape
 
 struct gemm
 {
-    std::string name() const { return "gemm";}
+    std::string name() const { return "gemm"; }
     shape compute_shape(std::vector<shape> inputs) const
     {
         check_shapes{inputs}.has(2).same_type();
-        const shape& a = inputs.at(0); 
-        const shape& b = inputs.at(1); 
+        const shape& a = inputs.at(0);
+        const shape& b = inputs.at(1);
         auto t         = a.type();
 
-        if (a.lens()[1] != b.lens()[0])
+        if(a.lens()[1] != b.lens()[0])
             RTG_THROW("Inner dimensions do not match");
         return {t, {a.lens()[0], b.lens()[1]}};
     }
-  
+
     argument compute(shape, std::vector<argument>) const { RTG_THROW("not computable"); }
-  
-    friend std::ostream& operator<<(std::ostream& os, const gemm& op) 
+
+    friend std::ostream& operator<<(std::ostream& os, const gemm& op)
     {
         os << op.name() << "[";
-        os << "]"; 
+        os << "]";
         return os;
     }
 };
@@ -290,20 +290,20 @@ struct unary
 {
     shape compute_shape(std::vector<shape> inputs) const
     {
-      check_shapes{inputs}.has(1);
-      return inputs.at(0);
+        check_shapes{inputs}.has(1);
+        return inputs.at(0);
     }
     argument compute(shape, std::vector<argument>) const { RTG_THROW("not computable"); }
 };
 
 struct identity : unary
 {
-    std::string name() const {return "identity"; }
+    std::string name() const { return "identity"; }
 };
 
 struct abs : unary
 {
-    std::string name() const {return "abs"; }
+    std::string name() const { return "abs"; }
 };
 
 struct exp : unary
@@ -313,55 +313,55 @@ struct exp : unary
 
 struct sin : unary
 {
-    std::string name() const {return "sin"; }
+    std::string name() const { return "sin"; }
 };
 
 struct cos : unary
 {
-    std::string name() const {return "cos"; }
+    std::string name() const { return "cos"; }
 };
 
 struct tan : unary
 {
-    std::string name() const {return "tan"; }
+    std::string name() const { return "tan"; }
 };
 
 struct asin : unary
 {
-    std::string name() const {return "asin"; }
+    std::string name() const { return "asin"; }
 };
 
 struct acos : unary
 {
-    std::string name() const {return "acos"; }
+    std::string name() const { return "acos"; }
 };
 
 struct atan : unary
 {
-    std::string name() const {return "atan"; }
+    std::string name() const { return "atan"; }
 };
 
 struct softmax : unary
 {
-    std::string name() const {return "softmax"; }
+    std::string name() const { return "softmax"; }
 };
 
 struct tanh : unary
 {
-    std::string name() const {return "tanh"; }
+    std::string name() const { return "tanh"; }
 };
 
 struct sigmoid : unary
 {
-    std::string name() const {return "sigmoid"; }
+    std::string name() const { return "sigmoid"; }
 };
 
 struct neg : unary
 {
-    std::string name() const {return "neg"; }
+    std::string name() const { return "neg"; }
 };
 
-struct flatten 
+struct flatten
 {
     std::string name() const { return "flatten"; }
 };
@@ -370,9 +370,9 @@ struct binary
 {
     shape compute_shape(std::vector<shape> inputs) const
     {
-      // TODO(wsttiger@gmail.com) Check this for numpy-style broadcasting operations
-      check_shapes{inputs}.has(2).same_type().same_dims();
-      return inputs.at(0);
+        // TODO(wsttiger@gmail.com) Check this for numpy-style broadcasting operations
+        check_shapes{inputs}.has(2).same_type().same_dims();
+        return inputs.at(0);
     }
 };
 

src/targets/cpu/cpu_target.cpp

@@ -8,7 +8,10 @@ namespace rtg {
 namespace cpu {
 
 template <typename T>
-T zero(const T&) { return T(0); }
+T zero(const T&)
+{
+    return T(0);
+}
 
 struct cpu_convolution
 {
@@ -53,14 +56,11 @@ struct cpu_convolution
 
 struct cpu_reshape
 {
-    reshape op; 
+    reshape op;
     std::string name() const { return "cpu::reshape"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        return op.compute_shape(inputs);
-    }
+    shape compute_shape(std::vector<shape> inputs) const { return op.compute_shape(inputs); }
 
-    argument compute(shape output_shape, std::vector<argument> args) const 
+    argument compute(shape output_shape, std::vector<argument> args) const
     {
         return {output_shape, std::move(args.front().data)};
     }
@@ -70,12 +70,9 @@ struct cpu_gemm
 {
     gemm op;
     std::string name() const { return "cpu::gemm"; }
-    shape compute_shape(std::vector<shape> inputs) const
-    {
-        return op.compute_shape(inputs);
-    }
+    shape compute_shape(std::vector<shape> inputs) const { return op.compute_shape(inputs); }
 
-    argument compute(shape output_shape, std::vector<argument> args) const 
+    argument compute(shape output_shape, std::vector<argument> args) const
     {
         argument result{output_shape};
         visit_all(result, args[0], args[1])([&](auto cmat, auto amat, auto bmat) {
@@ -86,20 +83,25 @@ struct cpu_gemm
             auto a = amat.data();
             auto b = bmat.data();
             auto c = cmat.data();
-            for (int ii = 0; ii < m; ii++) {
-              for (int jj = 0; jj < n; jj++) {
-                c[ii*n+jj] = 0;
-              }
+            for(int ii = 0; ii < m; ii++)
+            {
+                for(int jj = 0; jj < n; jj++)
+                {
+                    c[ii * n + jj] = 0;
+                }
             }
-            for (int ii = 0; ii < m; ii++) {
-              for (int kk = 0; kk < k; kk++) {
-                auto aik = a[ii*k+kk];
-                auto* bkj = &b[kk*n];
-                auto* cij = &c[ii*n];
-                for (int jj = 0; jj < n; jj++, cij++, bkj++) {
-                  *cij += aik*(*bkj);
+            for(int ii = 0; ii < m; ii++)
+            {
+                for(int kk = 0; kk < k; kk++)
+                {
+                    auto aik  = a[ii * k + kk];
+                    auto* bkj = &b[kk * n];
+                    auto* cij = &c[ii * n];
+                    for(int jj = 0; jj < n; jj++, cij++, bkj++)
+                    {
+                        *cij += aik * (*bkj);
+                    }
                 }
-              }
             }
         });
         return result;
@@ -108,176 +110,227 @@ struct cpu_gemm
 
 struct identity_op
 {
-    std::string name() const {return "cpu::identity"; }
-    auto fcn() const { return [](auto x) { return x; }; }
+    std::string name() const { return "cpu::identity"; }
+    auto fcn() const
+    {
+        return [](auto x) { return x; };
+    }
 };
 
-struct abs_op 
+struct abs_op
 {
-    std::string name() const {return "cpu::abs"; }
-    auto fcn() const { return [](auto x) { return std::abs(x); }; }
+    std::string name() const { return "cpu::abs"; }
+    auto fcn() const
+    {
+        return [](auto x) { return std::abs(x); };
+    }
 };
 
-struct exp_op 
+struct exp_op
 {
-    std::string name() const {return "cpu::exp"; }
-    auto fcn() const { return [](auto x) { return std::exp(x); }; }
+    std::string name() const { return "cpu::exp"; }
+    auto fcn() const
+    {
+        return [](auto x) { return std::exp(x); };
+    }
 };
 
-struct sin_op 
+struct sin_op
 {
-    std::string name() const {return "cpu::sin"; }
-    auto fcn() const { return [](auto x) { return std::sin(x); }; }
+    std::string name() const { return "cpu::sin"; }
+    auto fcn() const
+    {
+        return [](auto x) { return std::sin(x); };
+    }
 };
 
-struct cos_op 
+struct cos_op
 {
-    std::string name() const {return "cpu::cos"; }
-    auto fcn() const { return [](auto x) { return std::cos(x); }; }
+    std::string name() const { return "cpu::cos"; }
+    auto fcn() const
+    {
+        return [](auto x) { return std::cos(x); };
+    }
 };
 
-struct tan_op 
+struct tan_op
 {
-    std::string name() const {return "cpu::tan"; }
-    auto fcn() const { return [](auto x) { return std::tan(x); }; }
+    std::string name() const { return "cpu::tan"; }
+    auto fcn() const
+    {
+        return [](auto x) { return std::tan(x); };
+    }
 };
 
-struct asin_op 
+struct asin_op
 {
-    std::string name() const {return "cpu::asin"; }
-    auto fcn() const { return [](auto x) { return std::asin(x); }; }
+    std::string name() const { return "cpu::asin"; }
+    auto fcn() const
+    {
+        return [](auto x) { return std::asin(x); };
+    }
 };
 
-struct acos_op 
+struct acos_op
 {
-    std::string name() const {return "cpu::acos"; }
-    auto fcn() const { return [](auto x) { return std::acos(x); }; }
+    std::string name() const { return "cpu::acos"; }
+    auto fcn() const
+    {
+        return [](auto x) { return std::acos(x); };
+    }
 };
 
-struct atan_op 
+struct atan_op
 {
-    std::string name() const {return "cpu::atan"; }
-    auto fcn() const { return [](auto x) { return std::atan(x); }; }
+    std::string name() const { return "cpu::atan"; }
+    auto fcn() const
+    {
+        return [](auto x) { return std::atan(x); };
+    }
 };
 
 struct tanh_op
 {
-    std::string name() const {return "cpu::tanh"; }
-    auto fcn() const { return [](auto x) { return std::tanh(x); }; }
+    std::string name() const { return "cpu::tanh"; }
+    auto fcn() const
+    {
+        return [](auto x) { return std::tanh(x); };
+    }
 };
 
 struct sigmoid_op
 {
-    std::string name() const {return "cpu::sigmoid"; }
-    auto fcn() const { return [](auto x) { return 1.f/(1.f + std::exp(-x)); }; }
+    std::string name() const { return "cpu::sigmoid"; }
+    auto fcn() const
+    {
+        return [](auto x) { return 1.f / (1.f + std::exp(-x)); };
+    }
 };
 
 struct neg_op
 {
-    std::string name() const {return "cpu::neg"; }
-    auto fcn() const { return [](auto x) { return -x; }; }
+    std::string name() const { return "cpu::neg"; }
+    auto fcn() const
+    {
+        return [](auto x) { return -x; };
+    }
 };
 
 struct relu_op
 {
-    std::string name() const {return "cpu::relu"; }
-    auto fcn() const { return [](auto x) { return x > 0 ? x : 0; }; }
+    std::string name() const { return "cpu::relu"; }
+    auto fcn() const
+    {
+        return [](auto x) { return x > 0 ? x : 0; };
+    }
 };
 
 template <typename Op>
 struct cpu_unary
 {
-  Op op;
-  std::string name() const { return op.name(); }
-  shape compute_shape(std::vector<shape> inputs) const { return inputs.front(); }
-  argument compute(shape output_shape, std::vector<argument> args) const
-  {
-      argument result{output_shape};
-      result.visit([&](auto output) {
-          args[0].visit([&](auto input) {
-              std::transform(input.begin(), input.end(), output.begin(), op.fcn());
-          });
-      });
-      return result;
-  }
+    Op op;
+    std::string name() const { return op.name(); }
+    shape compute_shape(std::vector<shape> inputs) const { return inputs.front(); }
+    argument compute(shape output_shape, std::vector<argument> args) const
+    {
+        argument result{output_shape};
+        result.visit([&](auto output) {
+            args[0].visit([&](auto input) {
+                std::transform(input.begin(), input.end(), output.begin(), op.fcn());
+            });
+        });
+        return result;
+    }
 };
 
 struct softmax2d
 {
-  std::string name() const { return "cpu::softmax2d"; }
-  shape compute_shape(std::vector<shape> inputs) const { return inputs.front(); }
-  argument compute(shape output_shape, std::vector<argument> args) const
-  {
-      argument result{output_shape};
-      visit_all(result, args[0])([&](auto output, auto input) {
-          using value_type = typename decltype(input)::value_type;
-          auto nb = input.get_shape().lens()[0];
-          auto nc = input.get_shape().lens()[1]; 
-          auto nh = input.get_shape().lens()[2]; 
-          auto nw = input.get_shape().lens()[3];
-          for (int b = 0; b < nb; b++) {
-              for (int i = 0; i < nh; i++) {
-                  for (int j = 0; j < nw; j++) {
-                      value_type cmax = std::numeric_limits<value_type>::lowest();
-                      for (int c = 0; c < nc; c++) {
-                          cmax = std::max(cmax, input(b, c, i, j)); 
-                      }
-                      for (int c = 0; c < nc; c++) {
-                          output(b, c, i, j) = std::exp(input(b, c, i, j)-cmax);
-                      }
-                      value_type sum = value_type(0);
-                      for (int c = 0; c < nc; c++) {
-                          sum += output(b, c, i, j);
-                      }
-                      for (int c = 0; c < nc; c++) {
-                          output(b, c, i, j) = output(b, c, i, j)/sum;
-                      }
-                  }
-              }
-         } 
-      });
-      return result;
-  }
+    std::string name() const { return "cpu::softmax2d"; }
+    shape compute_shape(std::vector<shape> inputs) const { return inputs.front(); }
+    argument compute(shape output_shape, std::vector<argument> args) const
+    {
+        argument result{output_shape};
+        visit_all(result, args[0])([&](auto output, auto input) {
+            using value_type = typename decltype(input)::value_type;
+            auto nb          = input.get_shape().lens()[0];
+            auto nc          = input.get_shape().lens()[1];
+            auto nh          = input.get_shape().lens()[2];
+            auto nw          = input.get_shape().lens()[3];
+            dfor(nb, nh, nw)([&](std::size_t b, std::size_t i, std::size_t j) {
+                value_type cmax = std::numeric_limits<value_type>::lowest();
+                for(int c = 0; c < nc; c++)
+                {
+                    cmax = std::max(cmax, input(b, c, i, j));
+                }
+                for(int c = 0; c < nc; c++)
+                {
+                    output(b, c, i, j) = std::exp(input(b, c, i, j) - cmax);
+                }
+                value_type sum = value_type(0);
+                for(int c = 0; c < nc; c++)
+                {
+                    sum += output(b, c, i, j);
+                }
+                for(int c = 0; c < nc; c++)
+                {
+                    output(b, c, i, j) = output(b, c, i, j) / sum;
+                }
+            });
+        });
+        return result;
+    }
 };
 
 struct add_op
 {
     std::string name() const { return "add"; }
-    auto fcn() const { return [](auto x, auto y) {return x + y;};}
+    auto fcn() const
+    {
+        return [](auto x, auto y) { return x + y; };
+    }
 };
 
 struct sub_op
 {
     std::string name() const { return "sub"; }
-    auto fcn() const { return [](auto x, auto y) {return x - y;};}
+    auto fcn() const
+    {
+        return [](auto x, auto y) { return x - y; };
+    }
 };
 
 struct mul_op
 {
     std::string name() const { return "mul"; }
-    auto fcn() const { return [](auto x, auto y) {return x * y;};}
+    auto fcn() const
+    {
+        return [](auto x, auto y) { return x * y; };
+    }
 };
 
 struct div_op
 {
     std::string name() const { return "div"; }
-    auto fcn() const { return [](auto x, auto y) {return x / y;};}
+    auto fcn() const
+    {
+        return [](auto x, auto y) { return x / y; };
+    }
 };
 
 template <typename Op>
 struct cpu_binary
 {
-  Op op;
-  std::string name() const { op.name(); }
-  shape compute_shape(std::vector<shape> inputs) const { return inputs.front(); }
-  argument compute(shape output_shape, std::vector<argument> args) const
-  {
-      argument result{output_shape};
-      visit_all(result, args[0], args[1])([&](auto output, auto input1, auto input2) {
-          std::transform(input1.begin(), input1.end(), input2.begin(), output.begin(), op.fcn());
-          });
-      return result;
-  }
+    Op op;
+    std::string name() const { return op.name(); }
+    shape compute_shape(std::vector<shape> inputs) const { return inputs.front(); }
+    argument compute(shape output_shape, std::vector<argument> args) const
+    {
+        argument result{output_shape};
+        visit_all(result, args[0], args[1])([&](auto output, auto input1, auto input2) {
+            std::transform(input1.begin(), input1.end(), input2.begin(), output.begin(), op.fcn());
+        });
+        return result;
+    }
 };
 
 struct cpu_apply