Revert auto&&

Andrew Johnson · Andrew Johnson · commit 2ca03e7c46eb · 2020-03-18T11:04:23.000+08:00
diff --git a/stan/math/prim/fun/acos.hpp b/stan/math/prim/fun/acos.hpp
@@ -50,7 +50,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto acos(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().acos(); });
+      x, [](const auto& v) { return v.array().acos(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
@@ -50,7 +50,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto asin(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().asin(); });
+      x, [](const auto& v) { return v.array().asin(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
@@ -50,7 +50,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto atan(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().atan(); });
+      x, [](const auto& v) { return v.array().atan(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/ceil.hpp b/stan/math/prim/fun/ceil.hpp
@@ -50,7 +50,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto ceil(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().ceil(); });
+      x, [](const auto& v) { return v.array().ceil(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
@@ -50,7 +50,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto cos(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().cos(); });
+      x, [](const auto& v) { return v.array().cos(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
@@ -50,7 +50,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto cosh(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().cosh(); });
+      x, [](const auto& v) { return v.array().cosh(); });
 }
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/prim/fun/exp.hpp b/stan/math/prim/fun/exp.hpp
@@ -54,7 +54,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto exp(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().exp(); });
+      x, [](const auto& v) { return v.array().exp(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fabs.hpp b/stan/math/prim/fun/fabs.hpp
@@ -50,7 +50,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto fabs(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().abs(); });
+      x, [](const auto& v) { return v.array().abs(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/floor.hpp b/stan/math/prim/fun/floor.hpp
@@ -50,7 +50,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto floor(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().floor(); });
+      x, [](const auto& v) { return v.array().floor(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv.hpp b/stan/math/prim/fun/inv.hpp
@@ -47,7 +47,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto inv(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().inverse(); });
+      x, [](const auto& v) { return v.array().inverse(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_cloglog.hpp b/stan/math/prim/fun/inv_cloglog.hpp
@@ -91,7 +91,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto inv_cloglog(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return 1 - (-v.array().exp()).exp(); });
+      x, [](const auto& v) { return 1 - (-v.array().exp()).exp(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_sqrt.hpp b/stan/math/prim/fun/inv_sqrt.hpp
@@ -52,7 +52,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto inv_sqrt(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().rsqrt(); });
+      x, [](const auto& v) { return v.array().rsqrt(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_square.hpp b/stan/math/prim/fun/inv_square.hpp
@@ -35,7 +35,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto inv_square(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().square().inverse(); });
+      x, [](const auto& v) { return v.array().square().inverse(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
@@ -54,7 +54,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto log(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().log(); });
+      x, [](const auto& v) { return v.array().log(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
@@ -49,7 +49,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto log10(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().log10(); });
+      x, [](const auto& v) { return v.array().log10(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_softmax.hpp b/stan/math/prim/fun/log_softmax.hpp
@@ -42,7 +42,7 @@ namespace math {
  */
 template <typename Container, require_arithmetic_t<scalar_type_t<Container>>...>
 inline auto log_softmax(const Container& x) {
-  return apply_vector_unary<Container>::apply(x, [](auto&& v) {
+  return apply_vector_unary<Container>::apply(x, [](const auto& v) {
     const Eigen::Ref<const plain_type_t<decltype(v)>>& v_ref = v;
     check_nonzero_size("log_softmax", "v", v_ref);
     return (v_ref.array() - log_sum_exp(v_ref)).eval();
diff --git a/stan/math/prim/fun/logit.hpp b/stan/math/prim/fun/logit.hpp
@@ -101,7 +101,7 @@ inline auto logit(const Container& x) {
 template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto logit(const Container& x) {
-  return apply_vector_unary<Container>::apply(x, [](auto&& v) {
+  return apply_vector_unary<Container>::apply(x, [](const auto& v) {
     const Eigen::Ref<const plain_type_t<decltype(v)>>& v_ref = v;
     return (v_ref.array() / (1 - v_ref.array())).log().eval();
   });
diff --git a/stan/math/prim/fun/round.hpp b/stan/math/prim/fun/round.hpp
@@ -49,7 +49,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto round(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().round(); });
+      x, [](const auto& v) { return v.array().round(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
@@ -48,7 +48,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto sin(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [&](auto&& v) { return v.array().sin(); });
+      x, [&](const auto& v) { return v.array().sin(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
@@ -49,7 +49,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto sinh(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().sinh(); });
+      x, [](const auto& v) { return v.array().sinh(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
@@ -49,7 +49,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto sqrt(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().sqrt(); });
+      x, [](const auto& v) { return v.array().sqrt(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/square.hpp b/stan/math/prim/fun/square.hpp
@@ -64,7 +64,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto square(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().square(); });
+      x, [](const auto& v) { return v.array().square(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
@@ -49,7 +49,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto tan(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().tan(); });
+      x, [](const auto& v) { return v.array().tan(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
@@ -49,7 +49,7 @@ template <typename Container,
           require_container_st<is_container, std::is_arithmetic, Container>...>
 inline auto tanh(const Container& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](auto&& v) { return v.array().tanh(); });
+      x, [](const auto& v) { return v.array().tanh(); });
 }
 
 }  // namespace math

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ template <typename Container,`
`50`	`50`	`require_container_st<is_container, std::is_arithmetic, Container>...>`
`51`	`51`	`inline auto acos(const Container& x) {`
`52`	`52`	`return apply_vector_unary<Container>::apply(`
`53`		`- x, [](auto&& v) { return v.array().acos(); });`
	`53`	`+ x, [](const auto& v) { return v.array().acos(); });`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`} // namespace math`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ template <typename Container,`
`54`	`54`	`require_container_st<is_container, std::is_arithmetic, Container>...>`
`55`	`55`	`inline auto exp(const Container& x) {`
`56`	`56`	`return apply_vector_unary<Container>::apply(`
`57`		`- x, [](auto&& v) { return v.array().exp(); });`
	`57`	`+ x, [](const auto& v) { return v.array().exp(); });`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`} // namespace math`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ template <typename Container,`
`47`	`47`	`require_container_st<is_container, std::is_arithmetic, Container>...>`
`48`	`48`	`inline auto inv(const Container& x) {`
`49`	`49`	`return apply_vector_unary<Container>::apply(`
`50`		`- x, [](auto&& v) { return v.array().inverse(); });`
	`50`	`+ x, [](const auto& v) { return v.array().inverse(); });`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`} // namespace math`