[Jenkins] auto-formatting by clang-format version 6.0.0-1ubuntu2~16.0…

…4.1 (tags/RELEASE_600/final)

stan/math/prim/err/is_matching_dims.hpp

@@ -23,9 +23,9 @@ namespace math {
  * @param y2 second matrix to test
  * @return <code>true</code> if the dimensions of the matrices match
  */
-template <typename EigMat1, typename EigMat2, require_all_matrix_t<EigMat1, EigMat2>* = nullptr>
-inline bool is_matching_dims(const EigMat1& y1,
-                             const EigMat2& y2) {
+template <typename EigMat1, typename EigMat2,
+          require_all_matrix_t<EigMat1, EigMat2>* = nullptr>
+inline bool is_matching_dims(const EigMat1& y1, const EigMat2& y2) {
   return is_size_match(y1.rows(), y2.rows())
          && is_size_match(y1.cols(), y2.cols());
 }
@@ -46,10 +46,13 @@ inline bool is_matching_dims(const EigMat1& y1,
  * @param y2 second matrix to test
  * @return <code>true</code> if the dimensions of the matrices match
  */
- template <bool check_compile, typename EigMat1, typename EigMat2, require_all_matrix_t<EigMat1, EigMat2>* = nullptr>
-inline bool is_matching_dims(const EigMat1& y1,
-                             const EigMat2& y2) {
-  return !(check_compile && (EigMat1::RowsAtCompileTime != EigMat2::RowsAtCompileTime || EigMat1::ColsAtCompileTime != EigMat2::ColsAtCompileTime)) && is_matching_dims(y1, y2);
+template <bool check_compile, typename EigMat1, typename EigMat2,
+          require_all_matrix_t<EigMat1, EigMat2>* = nullptr>
+inline bool is_matching_dims(const EigMat1& y1, const EigMat2& y2) {
+  return !(check_compile
+           && (EigMat1::RowsAtCompileTime != EigMat2::RowsAtCompileTime
+               || EigMat1::ColsAtCompileTime != EigMat2::ColsAtCompileTime))
+         && is_matching_dims(y1, y2);
 }
 
 }  // namespace math

stan/math/rev/core/operator_addition.hpp

@@ -85,9 +85,9 @@ inline var operator+(const var& a, const var& b) {
   var ret(a.val() + b.val());
   if (unlikely(is_any_nan(a.val(), b.val()))) {
     reverse_pass_callback([a, b]() mutable {
-        a.adj() = NOT_A_NUMBER;
-        b.adj() = NOT_A_NUMBER;
-      });
+      a.adj() = NOT_A_NUMBER;
+      b.adj() = NOT_A_NUMBER;
+    });
   } else {
     reverse_pass_callback([ret, a, b]() mutable {
       a.adj() += ret.adj();
@@ -116,13 +116,9 @@ inline var operator+(const var& a, Arith b) {
   } else {
     var ret(a.val() + b);
     if (unlikely(is_any_nan(a.val(), b))) {
-      reverse_pass_callback([a]() mutable {
-          a.adj() = NOT_A_NUMBER;
-        });
+      reverse_pass_callback([a]() mutable { a.adj() = NOT_A_NUMBER; });
     } else {
-      reverse_pass_callback([ret, a]() mutable {
-        a.adj() += ret.adj();
-      });
+      reverse_pass_callback([ret, a]() mutable { a.adj() += ret.adj(); });
     }
     return ret;
   }
@@ -154,17 +150,19 @@ inline var operator+(Arith a, const var& b) {
  * @param b Second variable operand.
  * @return Variable result of adding two variables.
  */
-template <typename VarMat1, typename VarMat2, require_all_rev_matrix_t<VarMat1, VarMat2>* = nullptr>
+template <typename VarMat1, typename VarMat2,
+          require_all_rev_matrix_t<VarMat1, VarMat2>* = nullptr>
 inline auto operator+(const VarMat1& a, const VarMat2& b) {
   check_matching_dims("operator+", "a", a, "b", b);
   using ret_type = decltype(a.val() + b.val());
-  promote_var_matrix_t<ret_type, VarMat1, VarMat2> ret((a.val() + b.val()).eval());
+  promote_var_matrix_t<ret_type, VarMat1, VarMat2> ret(
+      (a.val() + b.val()).eval());
   arena_t<VarMat1> arena_a = a;
   arena_t<VarMat2> arena_b = b;
   reverse_pass_callback([ret, arena_a, arena_b]() mutable {
-      arena_a.adj() += ret.adj_op();
-      arena_b.adj() += ret.adj_op();
-    });
+    arena_a.adj() += ret.adj_op();
+    arena_b.adj() += ret.adj_op();
+  });
   return ret;
 }
 
@@ -177,22 +175,23 @@ inline auto operator+(const VarMat1& a, const VarMat2& b) {
  * @param b Second variable operand.
  * @return Variable result of adding two variables.
  */
-template <typename Arith, typename VarMat, require_st_arithmetic<Arith>* = nullptr,
- require_rev_matrix_t<VarMat>* = nullptr>
+template <typename Arith, typename VarMat,
+          require_st_arithmetic<Arith>* = nullptr,
+          require_rev_matrix_t<VarMat>* = nullptr>
 inline auto operator+(const VarMat& a, const Arith& b) {
   if (is_eigen<Arith>::value) {
     check_matching_dims("operator+", "a", a, "b", b);
   }
-  using ret_inner_type = plain_type_t<decltype((a.val().array() + as_array_or_scalar(b)).matrix())>;
+  using ret_inner_type = plain_type_t<decltype(
+      (a.val().array() + as_array_or_scalar(b)).matrix())>;
   using ret_type = promote_var_matrix_t<ret_inner_type, VarMat>;
   if (is_equal(b, 0.0)) {
     return ret_type(a);
   } else {
     arena_t<VarMat> arena_a = a;
     ret_type ret(a.val().array() + as_array_or_scalar(b));
-    reverse_pass_callback([ret, arena_a]() mutable {
-      arena_a.adj() += ret.adj_op();
-    });
+    reverse_pass_callback(
+        [ret, arena_a]() mutable { arena_a.adj() += ret.adj_op(); });
     return ret;
   }
 }
@@ -206,8 +205,9 @@ inline auto operator+(const VarMat& a, const Arith& b) {
  * @param b Second variable operand.
  * @return Variable result of adding two variables.
  */
- template <typename Arith, typename VarMat, require_st_arithmetic<Arith>* = nullptr,
-  require_rev_matrix_t<VarMat>* = nullptr>
+template <typename Arith, typename VarMat,
+          require_st_arithmetic<Arith>* = nullptr,
+          require_rev_matrix_t<VarMat>* = nullptr>
 inline auto operator+(const Arith& a, const VarMat& b) {
   return b + a;
 }
@@ -222,17 +222,14 @@ inline auto operator+(const Arith& a, const VarMat& b) {
  * @return Variable result of adding two variables.
  */
 template <typename Var, typename EigMat,
- require_eigen_vt<std::is_arithmetic, EigMat>* = nullptr,
- require_var_vt<std::is_arithmetic, Var>* = nullptr>
+          require_eigen_vt<std::is_arithmetic, EigMat>* = nullptr,
+          require_var_vt<std::is_arithmetic, Var>* = nullptr>
 inline auto operator+(const Var& a, const EigMat& b) {
-  arena_t<promote_scalar_t<var, EigMat>>  ret(a.val() + b.array());
-  reverse_pass_callback([ret, a]() mutable {
-    a.adj() += ret.adj().sum();
-  });
+  arena_t<promote_scalar_t<var, EigMat>> ret(a.val() + b.array());
+  reverse_pass_callback([ret, a]() mutable { a.adj() += ret.adj().sum(); });
   return ret;
 }
 
-
 /**
  * Addition operator for a variable and arithmetic matrix (C++).
  *
@@ -242,24 +239,26 @@ inline auto operator+(const Var& a, const EigMat& b) {
  * @param b Second variable operand.
  * @return Variable result of adding two variables.
  */
-template <typename EigMat, typename Var, require_var_vt<std::is_arithmetic, Var>* = nullptr,
- require_eigen_vt<std::is_arithmetic, EigMat>* = nullptr>
+template <typename EigMat, typename Var,
+          require_var_vt<std::is_arithmetic, Var>* = nullptr,
+          require_eigen_vt<std::is_arithmetic, EigMat>* = nullptr>
 inline auto operator+(const EigMat& a, const Var& b) {
   return b + a;
 }
 
 /**
  * Addition operator for a variable and variable matrix (C++).
  *
- * @tparam VarMat An Eigen Matrix type with a variable Scalar type or a `var_value` with an underlying matrix type.
+ * @tparam VarMat An Eigen Matrix type with a variable Scalar type or a
+ * `var_value` with an underlying matrix type.
  * @tparam Var A `var_value` with an underlying arithmetic type.
  * @param a First variable operand.
  * @param b Second variable operand.
  * @return Variable result of adding two variables.
  */
 template <typename Var, typename VarMat,
- require_rev_matrix_t<VarMat>* = nullptr,
- require_var_vt<std::is_arithmetic, Var>* = nullptr>
+          require_rev_matrix_t<VarMat>* = nullptr,
+          require_var_vt<std::is_arithmetic, Var>* = nullptr>
 inline auto operator+(const Var& a, const VarMat& b) {
   arena_t<VarMat> arena_b(b);
   arena_t<VarMat> ret(a.val() + b.val().array());
@@ -270,22 +269,22 @@ inline auto operator+(const Var& a, const VarMat& b) {
   return ret;
 }
 
-
 /**
  * Addition operator for a variable matrix and variable (C++).
  *
- * @tparam VarMat An Eigen Matrix type with a variable Scalar type or a `var_value` with an underlying matrix type.
+ * @tparam VarMat An Eigen Matrix type with a variable Scalar type or a
+ * `var_value` with an underlying matrix type.
  * @tparam Var A `var_value` with an underlying arithmetic type.
  * @param a First variable operand.
  * @param b Second variable operand.
  * @return Variable result of adding two variables.
  */
- template <typename Var, typename VarMat,
-  require_rev_matrix_t<VarMat>* = nullptr,
-  require_var_vt<std::is_arithmetic, Var>* = nullptr>
- inline auto operator+(const VarMat& a, const Var& b) {
-   return b + a;
- }
+template <typename Var, typename VarMat,
+          require_rev_matrix_t<VarMat>* = nullptr,
+          require_var_vt<std::is_arithmetic, Var>* = nullptr>
+inline auto operator+(const VarMat& a, const Var& b) {
+  return b + a;
+}
 
 }  // namespace math
 }  // namespace stan

stan/math/rev/core/operator_plus_equal.hpp

@@ -14,9 +14,9 @@ inline var_value<T>& var_value<T>::operator+=(const var_value<T>& b) {
   vi_ = new vari(this->val() + b.val(), false);
   if (unlikely(is_any_nan(old_vi->val_, b.val()))) {
     reverse_pass_callback([old_vi, b]() mutable {
-        old_vi->adj_ = NOT_A_NUMBER;
-        b.adj() = NOT_A_NUMBER;
-      });
+      old_vi->adj_ = NOT_A_NUMBER;
+      b.adj() = NOT_A_NUMBER;
+    });
   } else {
     reverse_pass_callback([new_vi = this->vi_, old_vi, b]() mutable {
       old_vi->adj_ += new_vi->adj_;
@@ -34,9 +34,8 @@ inline var_value<T>& var_value<T>::operator+=(T b) {
   auto* old_vi = this->vi_;
   vi_ = new vari(this->val() + b, false);
   if (unlikely(is_any_nan(old_vi->val_, b))) {
-    reverse_pass_callback([old_vi, b]() mutable {
-        old_vi->adj_ = NOT_A_NUMBER;
-      });
+    reverse_pass_callback(
+        [old_vi, b]() mutable { old_vi->adj_ = NOT_A_NUMBER; });
   } else {
     reverse_pass_callback([new_vi = this->vi_, old_vi, b]() mutable {
       old_vi->adj_ += new_vi->adj_;

stan/math/rev/fun/add.hpp

@@ -15,8 +15,7 @@ namespace math {
  * @param b second scalar
  * @return the sum of the scalars
  */
-template <typename T1, typename T2,
-          require_any_st_var<T1, T2>* = nullptr>
+template <typename T1, typename T2, require_any_st_var<T1, T2>* = nullptr>
 inline auto add(const T1& a, const T2& b) {
   return a + b;
 }

stan/math/rev/meta/promote_var_matrix.hpp

@@ -17,11 +17,12 @@ namespace stan {
  *  Else the type will be `Matrix<var>`
  */
 template <typename ReturnType, typename... Types>
-using promote_var_matrix_t = std::conditional_t<
-    is_any_var_matrix<Types...>::value,
-    stan::math::var_value<
-        stan::math::promote_scalar_t<double, plain_type_t<ReturnType>>>,
-    arena_t<stan::math::promote_scalar_t<stan::math::var, plain_type_t<ReturnType>>>>;
+using promote_var_matrix_t
+    = std::conditional_t<is_any_var_matrix<Types...>::value,
+                         stan::math::var_value<stan::math::promote_scalar_t<
+                             double, plain_type_t<ReturnType>>>,
+                         arena_t<stan::math::promote_scalar_t<
+                             stan::math::var, plain_type_t<ReturnType>>>>;
 }  // namespace stan
 
 #endif

test/unit/math/mix/core/operator_addition_test.cpp

@@ -11,7 +11,8 @@ TEST(mathMixCore, operatorAddition) {
 
 TEST(mathMixCore, operatorAdditionMatrixSmall) {
   // This calls operator+ under the hood
-  auto f = [](const auto& x1, const auto& x2) { return stan::math::add(x1, x2); };
+  auto f
+      = [](const auto& x1, const auto& x2) { return stan::math::add(x1, x2); };
   stan::test::ad_tolerances tols;
   tols.hessian_hessian_ = 1e-1;
   tols.hessian_fvar_hessian_ = 1e-1;
@@ -42,11 +43,11 @@ TEST(mathMixCore, operatorAdditionMatrixSmall) {
   stan::test::expect_ad_matvar(tols, f, matrix_m11, vector_v1);
   stan::test::expect_ad_matvar(tols, f, row_vector_rv1, matrix_m11);
   stan::test::expect_ad_matvar(tols, f, matrix_m11, matrix_m11);
-
 }
 
 TEST(mathMixCore, operatorAdditionMatrixZeroSize) {
-  auto f = [](const auto& x1, const auto& x2) { return stan::math::add(x1, x2); };
+  auto f
+      = [](const auto& x1, const auto& x2) { return stan::math::add(x1, x2); };
   stan::test::ad_tolerances tols;
   tols.hessian_hessian_ = 1e-1;
   tols.hessian_fvar_hessian_ = 1e-1;
@@ -76,7 +77,8 @@ TEST(mathMixCore, operatorAdditionMatrixZeroSize) {
 }
 
 TEST(mathMixCore, operatorAdditionMatrixNormal) {
-  auto f = [](const auto& x1, const auto& x2) { return stan::math::add(x1, x2); };
+  auto f
+      = [](const auto& x1, const auto& x2) { return stan::math::add(x1, x2); };
   stan::test::ad_tolerances tols;
   tols.hessian_hessian_ = 1e-1;
   tols.hessian_fvar_hessian_ = 1e-1;
@@ -109,7 +111,8 @@ TEST(mathMixCore, operatorAdditionMatrixNormal) {
 }
 
 TEST(mathMixCore, operatorAdditionMatrixFailures) {
-  auto f = [](const auto& x1, const auto& x2) { return stan::math::add(x1, x2); };
+  auto f
+      = [](const auto& x1, const auto& x2) { return stan::math::add(x1, x2); };
   stan::test::ad_tolerances tols;
   tols.hessian_hessian_ = 1e-1;
   tols.hessian_fvar_hessian_ = 1e-1;
@@ -132,5 +135,4 @@ TEST(mathMixCore, operatorAdditionMatrixFailures) {
   stan::test::expect_ad_matvar(tols, f, u_tr, u);
   stan::test::expect_ad_matvar(tols, f, u, vv);
   stan::test::expect_ad_matvar(tols, f, rvv, u);
-
 }