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

…4.1 (tags/RELEASE_600/final)

stan/math/rev/fun/abs.hpp

@@ -37,7 +37,9 @@ namespace math {
  * @return Absolute value of variable.
  */
 template <typename T>
-inline auto abs(const var_value<T>& a) { return fabs(a); }
+inline auto abs(const var_value<T>& a) {
+  return fabs(a);
+}
 
 /**
  * Return the absolute value of the complex argument.

stan/math/rev/fun/acos.hpp

@@ -60,9 +60,11 @@ inline var acos(const var& x) {
 
 template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
 inline auto acos(const VarMat& x) {
-  return make_callback_var(x.val().array().acos().matrix(), [x](const auto& vi) mutable {
-    x.adj().array() -= vi.adj_.array() / (1.0 - (x.val().array() * x.val().array())).sqrt();
-  });
+  return make_callback_var(
+      x.val().array().acos().matrix(), [x](const auto& vi) mutable {
+        x.adj().array() -= vi.adj_.array()
+                           / (1.0 - (x.val().array() * x.val().array())).sqrt();
+      });
 }
 
 /**

stan/math/rev/fun/acosh.hpp

@@ -61,21 +61,21 @@ namespace math {
  * @return Inverse hyperbolic cosine of the variable.
  */
 
- inline var acosh(const var& x) {
-   return make_callback_var(acosh(x.val()), [x](const auto& vi) mutable {
-     x.adj() += vi.adj_ / std::sqrt(x.val() * x.val() - 1.0);
-   });
- }
+inline var acosh(const var& x) {
+  return make_callback_var(acosh(x.val()), [x](const auto& vi) mutable {
+    x.adj() += vi.adj_ / std::sqrt(x.val() * x.val() - 1.0);
+  });
+}
 
- template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
- inline auto acosh(const VarMat& x) {
-   return make_callback_var(x.val().unaryExpr([](const auto x) {
-      return acosh(x);
-    }),
-    [x](const auto& vi) mutable {
-     x.adj().array() += vi.adj_.array() / (x.val().array() * x.val().array() - 1.0).sqrt();
-   });
- }
+template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
+inline auto acosh(const VarMat& x) {
+  return make_callback_var(
+      x.val().unaryExpr([](const auto x) { return acosh(x); }),
+      [x](const auto& vi) mutable {
+        x.adj().array() += vi.adj_.array()
+                           / (x.val().array() * x.val().array() - 1.0).sqrt();
+      });
+}
 
 /**
  * Return the hyperbolic arc cosine of the complex argument.

stan/math/rev/fun/asin.hpp

@@ -50,18 +50,20 @@ namespace math {
  * @param a Variable in range [-1, 1].
  * @return Arc sine of variable, in radians.
  */
- inline var asin(const var& x) {
-   return make_callback_var(std::asin(x.val()), [x](const auto& vi) mutable {
-     x.adj() += vi.adj_ / std::sqrt(1.0 - (x.val() * x.val()));
-   });
- }
+inline var asin(const var& x) {
+  return make_callback_var(std::asin(x.val()), [x](const auto& vi) mutable {
+    x.adj() += vi.adj_ / std::sqrt(1.0 - (x.val() * x.val()));
+  });
+}
 
- template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
- inline auto asin(const VarMat& x) {
-   return make_callback_var(x.val().array().asin().matrix(), [x](const auto& vi) mutable {
-     x.adj().array() += vi.adj_.array() / (1.0 - (x.val().array() * x.val().array())).sqrt();
-   });
- }
+template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
+inline auto asin(const VarMat& x) {
+  return make_callback_var(
+      x.val().array().asin().matrix(), [x](const auto& vi) mutable {
+        x.adj().array() += vi.adj_.array()
+                           / (1.0 - (x.val().array() * x.val().array())).sqrt();
+      });
+}
 
 /**
  * Return the arc sine of the complex argument.

stan/math/rev/fun/asinh.hpp

@@ -56,22 +56,21 @@ namespace math {
  * @param a The variable.
  * @return Inverse hyperbolic sine of the variable.
  */
- inline var asinh(const var& x) {
-   return make_callback_var(asinh(x.val()), [x](const auto& vi) mutable {
-     x.adj() += vi.adj_ / std::sqrt(x.val() * x.val() + 1.0);
-   });
- }
-
- template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
- inline auto asinh(const VarMat& x) {
-   return make_callback_var(x.val().unaryExpr([](const auto x) {
-      return asinh(x);
-    }),
-    [x](const auto& vi) mutable {
-     x.adj().array() += vi.adj_.array() / (x.val().array() * x.val().array() + 1.0).sqrt();
-   });
- }
+inline var asinh(const var& x) {
+  return make_callback_var(asinh(x.val()), [x](const auto& vi) mutable {
+    x.adj() += vi.adj_ / std::sqrt(x.val() * x.val() + 1.0);
+  });
+}
 
+template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
+inline auto asinh(const VarMat& x) {
+  return make_callback_var(
+      x.val().unaryExpr([](const auto x) { return asinh(x); }),
+      [x](const auto& vi) mutable {
+        x.adj().array() += vi.adj_.array()
+                           / (x.val().array() * x.val().array() + 1.0).sqrt();
+      });
+}
 
 /**
  * Return the hyperbolic arcsine of the complex argument.

stan/math/rev/fun/atan.hpp

@@ -51,18 +51,20 @@ namespace math {
  * @param a Variable in range [-1, 1].
  * @return Arc tangent of variable, in radians.
  */
- inline var atan(const var& x) {
-   return make_callback_var(std::atan(x.val()), [x](const auto& vi) mutable {
-     x.adj() += vi.adj_ / (1.0 + (x.val() * x.val()));
-   });
- }
+inline var atan(const var& x) {
+  return make_callback_var(std::atan(x.val()), [x](const auto& vi) mutable {
+    x.adj() += vi.adj_ / (1.0 + (x.val() * x.val()));
+  });
+}
 
- template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
- inline auto atan(const VarMat& x) {
-   return make_callback_var(x.val().array().atan().matrix(), [x](const auto& vi) mutable {
-     x.adj().array() += vi.adj_.array() / (1.0 + (x.val().array() * x.val().array()));
-   });
- }
+template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
+inline auto atan(const VarMat& x) {
+  return make_callback_var(
+      x.val().array().atan().matrix(), [x](const auto& vi) mutable {
+        x.adj().array()
+            += vi.adj_.array() / (1.0 + (x.val().array() * x.val().array()));
+      });
+}
 /**
  * Return the arc tangent of the complex argument.
  *

stan/math/rev/fun/atan2.hpp

@@ -25,12 +25,12 @@ namespace math {
  * @return The arc tangent of the fraction, in radians.
  */
 inline var atan2(const var& a, const var& b) {
-  return make_callback_var(std::atan2(a.val(), b.val()), [a, b](const auto& vi) mutable {
-    double a_sq_plus_b_sq
-        = (a.val() * a.val()) + (b.val() * b.val());
-    a.adj() += vi.adj_ * b.val() / a_sq_plus_b_sq;
-    b.adj() -= vi.adj_ * a.val() / a_sq_plus_b_sq;
-  });
+  return make_callback_var(
+      std::atan2(a.val(), b.val()), [a, b](const auto& vi) mutable {
+        double a_sq_plus_b_sq = (a.val() * a.val()) + (b.val() * b.val());
+        a.adj() += vi.adj_ * b.val() / a_sq_plus_b_sq;
+        b.adj() -= vi.adj_ * a.val() / a_sq_plus_b_sq;
+      });
 }
 
 /**
@@ -46,11 +46,11 @@ inline var atan2(const var& a, const var& b) {
  * @return The arc tangent of the fraction, in radians.
  */
 inline var atan2(const var& a, double b) {
-  return make_callback_var(std::atan2(a.val(), b), [a, b](const auto& vi) mutable {
-    double a_sq_plus_b_sq
-        = (a.val() * a.val()) + (b * b);
-    a.adj() += vi.adj_ * b / a_sq_plus_b_sq;
-  });
+  return make_callback_var(
+      std::atan2(a.val(), b), [a, b](const auto& vi) mutable {
+        double a_sq_plus_b_sq = (a.val() * a.val()) + (b * b);
+        a.adj() += vi.adj_ * b / a_sq_plus_b_sq;
+      });
 }
 
 /**
@@ -90,14 +90,13 @@ inline var atan2(const var& a, double b) {
  * @return The arc tangent of the fraction, in radians.
  */
 inline var atan2(double a, const var& b) {
-  return make_callback_var(std::atan2(a, b.val()), [a, b](const auto& vi) mutable {
-    double a_sq_plus_b_sq
-        = (a * a) + (b.val() * b.val());
-    b.adj() -= vi.adj_ * a / a_sq_plus_b_sq;
-  });
+  return make_callback_var(
+      std::atan2(a, b.val()), [a, b](const auto& vi) mutable {
+        double a_sq_plus_b_sq = (a * a) + (b.val() * b.val());
+        b.adj() -= vi.adj_ * a / a_sq_plus_b_sq;
+      });
 }
 
-
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/rev/fun/atanh.hpp

@@ -55,22 +55,21 @@ namespace math {
    * @return Inverse hyperbolic tangent of the variable.
    * @throw std::domain_error if a < -1 or a > 1
    */
-   inline var atanh(const var& x) {
-     return make_callback_var(atanh(x.val()), [x](const auto& vi) mutable {
-       x.adj() += vi.adj_ / (1.0 - x.val() * x.val());
-     });
-   }
+inline var atanh(const var& x) {
+  return make_callback_var(atanh(x.val()), [x](const auto& vi) mutable {
+    x.adj() += vi.adj_ / (1.0 - x.val() * x.val());
+  });
+}
 
-   template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
-   inline auto atanh(const VarMat& x) {
-     return make_callback_var(x.val().unaryExpr([](const auto x) {
-        return atanh(x);
-      }),
+template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
+inline auto atanh(const VarMat& x) {
+  return make_callback_var(
+      x.val().unaryExpr([](const auto x) { return atanh(x); }),
       [x](const auto& vi) mutable {
-       x.adj().array() += vi.adj_.array() / (1.0 - x.val().array() * x.val().array());
-     });
-   }
-
+        x.adj().array()
+            += vi.adj_.array() / (1.0 - x.val().array() * x.val().array());
+      });
+}
 
 /**
  * Return the hyperbolic arc tangent of the complex argument.

stan/math/rev/fun/bessel_first_kind.hpp

@@ -9,10 +9,12 @@ namespace stan {
 namespace math {
 
 inline var bessel_first_kind(int v, const var& a) {
-  return make_callback_var(bessel_first_kind(v, a.val()), [v, a](const auto& vi) mutable {
-    a.adj() += vi.adj_ * (v * bessel_first_kind(v, a.val()) / a.val()
-                     - bessel_first_kind(v + 1, a.val()));
-  });
+  return make_callback_var(
+      bessel_first_kind(v, a.val()), [v, a](const auto& vi) mutable {
+        a.adj() += vi.adj_
+                   * (v * bessel_first_kind(v, a.val()) / a.val()
+                      - bessel_first_kind(v + 1, a.val()));
+      });
 }
 
 }  // namespace math

stan/math/rev/fun/cbrt.hpp

@@ -36,21 +36,19 @@ namespace math {
  */
 inline var cbrt(const var& a) {
   return make_callback_var(cbrt(a.val()), [a](const auto& vi) mutable {
-     a.adj() += vi.adj_ / (3.0 * vi.val_ * vi.val_);
+    a.adj() += vi.adj_ / (3.0 * vi.val_ * vi.val_);
   });
 }
 
 template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
 inline auto cbrt(const VarMat& a) {
-  return make_callback_var(a.val().unaryExpr([](const auto x) {
-     return cbrt(x);
-   }),
-   [a](const auto& vi) mutable {
-     a.adj().array() += vi.adj_.array() / (3.0 * vi.val_.array().square());
-  });
+  return make_callback_var(
+      a.val().unaryExpr([](const auto x) { return cbrt(x); }),
+      [a](const auto& vi) mutable {
+        a.adj().array() += vi.adj_.array() / (3.0 * vi.val_.array().square());
+      });
 }
 
-
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/rev/fun/cos.hpp

@@ -51,9 +51,10 @@ inline var cos(const var& a) {
 
 template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
 inline auto cos(const VarMat& a) {
-  return make_callback_var(a.val().array().cos().matrix(), [a](const auto& vi) mutable {
-    a.adj().array() -= vi.adj_.array() * a.val().array().sin();
-  });
+  return make_callback_var(
+      a.val().array().cos().matrix(), [a](const auto& vi) mutable {
+        a.adj().array() -= vi.adj_.array() * a.val().array().sin();
+      });
 }
 /**
  * Return the cosine of the complex argument.

stan/math/rev/fun/cosh.hpp

@@ -41,28 +41,29 @@ namespace math {
  * @param a Variable.
  * @return Hyperbolic cosine of variable.
  */
- inline var cosh(const var& a) {
-   return make_callback_var(std::cosh(a.val()), [a](const auto& vi) mutable {
-     a.adj() += vi.adj_ * std::sinh(a.val());
-   });
- }
+inline var cosh(const var& a) {
+  return make_callback_var(std::cosh(a.val()), [a](const auto& vi) mutable {
+    a.adj() += vi.adj_ * std::sinh(a.val());
+  });
+}
 
- template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
- inline auto cosh(const VarMat& a) {
-   return make_callback_var(a.val().array().cosh().matrix(), [a](const auto& vi) mutable {
-     a.adj().array() += vi.adj_.array() * a.val().array().sinh();
-   });
- }
+template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
+inline auto cosh(const VarMat& a) {
+  return make_callback_var(
+      a.val().array().cosh().matrix(), [a](const auto& vi) mutable {
+        a.adj().array() += vi.adj_.array() * a.val().array().sinh();
+      });
+}
 
- /**
-  * Return the hyperbolic cosine of the complex argument.
-  *
-  * @param[in] z argument
-  * @return hyperbolic cosine of the argument
-  */
- inline std::complex<var> cosh(const std::complex<var>& z) {
-   return stan::math::internal::complex_cosh(z);
- }
+/**
+ * Return the hyperbolic cosine of the complex argument.
+ *
+ * @param[in] z argument
+ * @return hyperbolic cosine of the argument
+ */
+inline std::complex<var> cosh(const std::complex<var>& z) {
+  return stan::math::internal::complex_cosh(z);
+}
 
 }  // namespace math
 }  // namespace stan

stan/math/rev/fun/fabs.hpp

@@ -67,18 +67,20 @@ inline auto fabs(const VarMat& a) {
     } else {
       return std::abs(x);
     }
-  }), [a](const auto& vi) mutable {
-    for (Eigen::Index j = 0; j < vi.cols(); ++j) {
-      for (Eigen::Index i = 0; i < vi.rows(); ++i) {
-        const auto x = a.val().coeffRef(i, j);
-        if (unlikely(is_nan(x))) {
-          a.adj().coeffRef(i, j) = NOT_A_NUMBER;
-        } else {
-          a.adj().coeffRef(i, j) -= vi.adj_.coeff(i, j);
-        }
-      }
-    }
-  });
+  }),
+                           [a](const auto& vi) mutable {
+                             for (Eigen::Index j = 0; j < vi.cols(); ++j) {
+                               for (Eigen::Index i = 0; i < vi.rows(); ++i) {
+                                 const auto x = a.val().coeffRef(i, j);
+                                 if (unlikely(is_nan(x))) {
+                                   a.adj().coeffRef(i, j) = NOT_A_NUMBER;
+                                 } else {
+                                   a.adj().coeffRef(i, j)
+                                       -= vi.adj_.coeff(i, j);
+                                 }
+                               }
+                             }
+                           });
 }
 
 }  // namespace math