[Jenkins] auto-formatting by clang-format version 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

Author: stan-buildbot

stan/math/opencl/prim/frechet_cdf.hpp

@@ -55,10 +55,10 @@ return_type_t<T_y_cl, T_shape_cl, T_scale_cl> frechet_cdf(
 
   auto check_y_positive
       = check_cl(function, "Random variable", y_val, "positive");
-  auto y_positive = y_val>0;
+  auto y_positive = y_val > 0;
   auto check_alpha_positive_finite
       = check_cl(function, "Shape parameter", alpha_val, "positive finite");
-  auto alpha_positive_finite_expr = alpha_val>0 && isfinite(alpha_val);
+  auto alpha_positive_finite_expr = alpha_val > 0 && isfinite(alpha_val);
   auto check_sigma_positive_finite
       = check_cl(function, "Scale parameter", sigma_val, "positive finite");
   auto sigma_positive_finite_expr = 0 < sigma_val && isfinite(sigma_val);
@@ -67,8 +67,8 @@ return_type_t<T_y_cl, T_shape_cl, T_scale_cl> frechet_cdf(
   auto cdf_n = exp(-pow_n);
   auto cdf_expr = colwise_prod(cdf_n);
 
-  auto pow_n_alpha =elt_multiply(pow_n, alpha_val);
-  auto y_deriv_tmp =elt_divide(pow_n_alpha, y_val);
+  auto pow_n_alpha = elt_multiply(pow_n, alpha_val);
+  auto y_deriv_tmp = elt_divide(pow_n_alpha, y_val);
   auto alpha_deriv_tmp = elt_multiply(pow_n, log(elt_divide(y_val, sigma_val)));
   auto sigma_deriv_tmp = elt_divide(pow_n_alpha, -sigma_val);
 
@@ -77,14 +77,14 @@ return_type_t<T_y_cl, T_shape_cl, T_scale_cl> frechet_cdf(
   matrix_cl<double> alpha_deriv_cl;
   matrix_cl<double> sigma_deriv_cl;
 
-  results(check_y_positive, check_alpha_positive_finite, check_sigma_positive_finite,
-          cdf_cl, y_deriv_cl, alpha_deriv_cl, sigma_deriv_cl)
-      = expressions(
-          y_positive, alpha_positive_finite_expr, sigma_positive_finite_expr,
-          cdf_expr,
-        calc_if<!is_constant<T_y_cl>::value>(y_deriv_tmp),
-        calc_if<!is_constant<T_shape_cl>::value>(alpha_deriv_tmp),
-          calc_if<!is_constant<T_scale_cl>::value>(sigma_deriv_tmp));
+  results(check_y_positive, check_alpha_positive_finite,
+          check_sigma_positive_finite, cdf_cl, y_deriv_cl, alpha_deriv_cl,
+          sigma_deriv_cl)
+      = expressions(y_positive, alpha_positive_finite_expr,
+                    sigma_positive_finite_expr, cdf_expr,
+                    calc_if<!is_constant<T_y_cl>::value>(y_deriv_tmp),
+                    calc_if<!is_constant<T_shape_cl>::value>(alpha_deriv_tmp),
+                    calc_if<!is_constant<T_scale_cl>::value>(sigma_deriv_tmp));
 
   T_partials_return cdf = (from_matrix_cl(cdf_cl)).prod();
 
@@ -97,7 +97,8 @@ return_type_t<T_y_cl, T_shape_cl, T_scale_cl> frechet_cdf(
                     calc_if<!is_constant<T_y_cl>::value>(y_deriv),
                     calc_if<!is_constant<T_scale_cl>::value>(sigma_deriv));
 
-  operands_and_partials<decltype(y_col), decltype(alpha_col), decltype(sigma_col)>
+  operands_and_partials<decltype(y_col), decltype(alpha_col),
+                        decltype(sigma_col)>
       ops_partials(y_col, alpha_col, sigma_col);
 
   if (!is_constant<T_y_cl>::value) {

stan/math/opencl/prim/frechet_lccdf.hpp

@@ -69,7 +69,8 @@ return_type_t<T_y_cl, T_shape_cl, T_scale_cl> frechet_lccdf(
 
   auto rep_deriv = elt_divide(pow_n, elt_divide(1.0, exp_n - 1.0));
   auto y_deriv = elt_multiply(elt_divide(-alpha_val, y_val), rep_deriv);
-  auto alpha_deriv = elt_multiply(-log(elt_divide(y_val, sigma_val)), rep_deriv);
+  auto alpha_deriv
+      = elt_multiply(-log(elt_divide(y_val, sigma_val)), rep_deriv);
   auto sigma_deriv = elt_multiply(elt_divide(alpha_val, sigma_val), rep_deriv);
 
   matrix_cl<double> lccdf_cl;

test/unit/math/opencl/rev/frechet_cdf_test.cpp

@@ -56,9 +56,10 @@ TEST(ProbDistributionsFrechetCdf, error_checking) {
                std::domain_error);
 }
 
-auto frechet_cdf_functor = [](const auto& y, const auto& alpha, const auto& sigma) {
-  return stan::math::frechet_cdf(y, alpha, sigma);
-};
+auto frechet_cdf_functor
+    = [](const auto& y, const auto& alpha, const auto& sigma) {
+        return stan::math::frechet_cdf(y, alpha, sigma);
+      };
 
 TEST(ProbDistributionsFrechetCdf, opencl_matches_cpu_small) {
   int N = 3;

test/unit/math/opencl/rev/frechet_lccdf_test.cpp

@@ -56,9 +56,10 @@ TEST(ProbDistributionsFrechetLccdf, error_checking) {
                std::domain_error);
 }
 
-auto frechet_lccdf_functor = [](const auto& y, const auto& alpha, const auto& sigma) {
-  return stan::math::frechet_lccdf(y, alpha, sigma);
-};
+auto frechet_lccdf_functor
+    = [](const auto& y, const auto& alpha, const auto& sigma) {
+        return stan::math::frechet_lccdf(y, alpha, sigma);
+      };
 
 TEST(ProbDistributionsFrechetLccdf, opencl_matches_cpu_small) {
   int N = 3;
@@ -102,8 +103,8 @@ TEST(ProbDistributionsFrechetLccdf, opencl_broadcast_alpha) {
   Eigen::VectorXd sigma(N);
   sigma << 0.3, 0.8, 1.0;
 
-  stan::math::test::test_opencl_broadcasting_prim_rev<1>(frechet_lccdf_functor, y,
-                                                         alpha_scal, sigma);
+  stan::math::test::test_opencl_broadcasting_prim_rev<1>(frechet_lccdf_functor,
+                                                         y, alpha_scal, sigma);
   stan::math::test::test_opencl_broadcasting_prim_rev<1>(
       frechet_lccdf_functor, y.transpose().eval(), alpha_scal, sigma);
 }
@@ -117,8 +118,8 @@ TEST(ProbDistributionsFrechetLccdf, opencl_broadcast_sigma) {
   alpha << 0.3, 0.8, 1.0;
   double sigma_scal = 12.3;
 
-  stan::math::test::test_opencl_broadcasting_prim_rev<2>(frechet_lccdf_functor, y,
-                                                         alpha, sigma_scal);
+  stan::math::test::test_opencl_broadcasting_prim_rev<2>(frechet_lccdf_functor,
+                                                         y, alpha, sigma_scal);
   stan::math::test::test_opencl_broadcasting_prim_rev<2>(
       frechet_lccdf_functor, y.transpose().eval(), alpha, sigma_scal);
 }

test/unit/math/opencl/rev/frechet_lcdf_test.cpp

@@ -56,9 +56,10 @@ TEST(ProbDistributionsFrechetLcdf, error_checking) {
                std::domain_error);
 }
 
-auto frechet_lcdf_functor = [](const auto& y, const auto& alpha, const auto& sigma) {
-  return stan::math::frechet_lcdf(y, alpha, sigma);
-};
+auto frechet_lcdf_functor
+    = [](const auto& y, const auto& alpha, const auto& sigma) {
+        return stan::math::frechet_lcdf(y, alpha, sigma);
+      };
 
 TEST(ProbDistributionsFrechetLcdf, opencl_matches_cpu_small) {
   int N = 3;
@@ -102,8 +103,8 @@ TEST(ProbDistributionsFrechetLcdf, opencl_broadcast_alpha) {
   Eigen::VectorXd sigma(N);
   sigma << 0.3, 0.8, 1.0;
 
-  stan::math::test::test_opencl_broadcasting_prim_rev<1>(frechet_lcdf_functor, y,
-                                                         alpha_scal, sigma);
+  stan::math::test::test_opencl_broadcasting_prim_rev<1>(frechet_lcdf_functor,
+                                                         y, alpha_scal, sigma);
   stan::math::test::test_opencl_broadcasting_prim_rev<1>(
       frechet_lcdf_functor, y.transpose().eval(), alpha_scal, sigma);
 }
@@ -117,8 +118,8 @@ TEST(ProbDistributionsFrechetLcdf, opencl_broadcast_sigma) {
   alpha << 0.3, 0.8, 1.0;
   double sigma_scal = 12.3;
 
-  stan::math::test::test_opencl_broadcasting_prim_rev<2>(frechet_lcdf_functor, y,
-                                                         alpha, sigma_scal);
+  stan::math::test::test_opencl_broadcasting_prim_rev<2>(frechet_lcdf_functor,
+                                                         y, alpha, sigma_scal);
   stan::math::test::test_opencl_broadcasting_prim_rev<2>(
       frechet_lcdf_functor, y.transpose().eval(), alpha, sigma_scal);
 }