Review comments

Author: andrjohns

stan/math/prim/fun/all.hpp

@@ -11,13 +11,14 @@ namespace math {
 /**
  * Return true if all values in the input are true.
  *
- * Overload for a single boolean input
+ * Overload for a single integral input
  *
+ * @tparam T The type of integral input.
  * @param x boolean input
  * @return The input unchanged
  */
-template <typename T, require_integral_t<T>* = nullptr>
-constexpr inline T all(T x) {
+template <typename T, require_t<std::is_convertible<T, bool>>* = nullptr>
+constexpr inline bool all(T x) {
   return x;
 }
 
@@ -37,20 +38,23 @@ inline bool all(const ContainerT& x) {
   return x.all();
 }
 
+// Forward-declaration for correct resolution of all(std::vector<std::tuple>)
+template <typename... Types>
+inline bool all(const std::tuple<Types...>& x);
+
 /**
  * Return true if all values in the input are true.
  *
  * Overload for a std::vector/nested inputs. The Eigen::Map/apply_vector_unary
  * approach cannot be used as std::vector<bool> types do not have a .data()
  * member and are not always stored contiguously.
  *
- * @tparam Type of container
+ * @tparam InnerT Type within std::vector
  * @param x Nested container of boolean inputs
  * @return Boolean indicating whether all elements are true
  */
-template <typename ContainerT,
-          require_std_vector_st<std::is_integral, ContainerT>* = nullptr>
-inline bool all(const ContainerT& x) {
+template <typename InnerT>
+inline bool all(const std::vector<InnerT>& x) {
   return std::all_of(x.begin(), x.end(), [](const auto& i) { return all(i); });
 }
 

stan/math/prim/fun/any.hpp

@@ -13,11 +13,12 @@ namespace math {
  *
  * Overload for a single boolean input
  *
+ * @tparam T The type of integral input.
  * @param x boolean input
  * @return The input unchanged
  */
-template <typename T, require_integral_t<T>* = nullptr>
-constexpr inline T any(T x) {
+template <typename T, require_t<std::is_convertible<T, bool>>* = nullptr>
+constexpr inline bool any(T x) {
   return x;
 }
 
@@ -37,20 +38,23 @@ inline bool any(const ContainerT& x) {
   return x.any();
 }
 
+// Forward-declaration for correct resolution of any(std::vector<std::tuple>)
+template <typename... Types>
+inline bool any(const std::tuple<Types...>& x);
+
 /**
  * Return true if any values in the input are true.
  *
  * Overload for a std::vector/nested inputs. The Eigen::Map/apply_vector_unary
  * approach cannot be used as std::vector<bool> types do not have a .data()
  * member and are not always stored contiguously.
  *
- * @tparam Type of container within std::vector
+ * @tparam InnerT Type within std::vector
  * @param x Nested container of boolean inputs
  * @return Boolean indicating whether any elements are true
  */
-template <typename ContainerT,
-          require_std_vector_st<std::is_integral, ContainerT>* = nullptr>
-inline bool any(const ContainerT& x) {
+template <typename InnerT>
+inline bool any(const std::vector<InnerT>& x) {
   return std::any_of(x.begin(), x.end(), [](const auto& i) { return any(i); });
 }
 

stan/math/prim/fun/select.hpp

@@ -9,13 +9,13 @@ namespace stan {
 namespace math {
 
 /**
- * Return the second argument if the first argument is true
- * and otherwise return the third argument.
+ * If first argument is true return the second argument,
+ * else return the third argument.
  *
  * `select(c, y1, y0) = c ? y1 : y0`.
  *
- * @tparam T_true type of the true argument
- * @tparam T_false type of the false argument
+ * @tparam T_true A stan `Scalar` type
+ * @tparam T_false A stan `Scalar` type
  * @param c Boolean condition value.
  * @param y_true Value to return if condition is true.
  * @param y_false Value to return if condition is false.
@@ -29,17 +29,17 @@ inline ReturnT select(const bool c, const T_true y_true,
 }
 
 /**
- * Return the second argument if the first argument is true
- * and otherwise return the third argument. Eigen expressions are
+ * If first argument is true return the second argument,
+ * else return the third argument. Eigen expressions are
  * evaluated so that the return type is the same for both branches.
  *
  * Both containers must have the same plain type. The scalar type
  * of the return is determined by the return_type_t<> type trait.
  *
  * Overload for use with two containers.
  *
- * @tparam T_true type of the true argument
- * @tparam T_false type of the false argument
+ * @tparam T_true A container of stan `Scalar` types
+ * @tparam T_false A container of stan `Scalar` types
  * @param c Boolean condition value.
  * @param y_true Value to return if condition is true.
  * @param y_false Value to return if condition is false.
@@ -59,8 +59,8 @@ inline T_true_plain select(const bool c, T_true&& y_true, T_false&& y_false) {
 }
 
 /**
- * Return the second argument if the first argument is true
- * and otherwise return the third argument.
+ * If first argument is true return the second argument,
+ * else return the third argument.
  *
  * Overload for use when the 'true' return is a container and the 'false'
  * return is a scalar
@@ -69,8 +69,8 @@ inline T_true_plain select(const bool c, T_true&& y_true, T_false&& y_false) {
  * plain type as the provided argument. Consequently, any Eigen expressions are
  * evaluated.
  *
- * @tparam T_true type of the true argument
- * @tparam T_false type of the false argument
+ * @tparam T_true A container of stan `Scalar` types
+ * @tparam T_false A stan `Scalar` type
  * @param c Boolean condition value.
  * @param y_true Value to return if condition is true.
  * @param y_false Value to return if condition is false.
@@ -94,8 +94,8 @@ inline ReturnT select(const bool c, const T_true& y_true,
 }
 
 /**
- * Return the second argument if the first argument is true
- * and otherwise return the third argument.
+ * If first argument is true return the second argument,
+ * else return the third argument.
  *
  * Overload for use when the 'true' return is a scalar and the 'false'
  * return is a container
@@ -104,8 +104,8 @@ inline ReturnT select(const bool c, const T_true& y_true,
  * plain type as the provided argument. Consequently, any Eigen expressions are
  * evaluated.
  *
- * @tparam T_true type of the true argument
- * @tparam T_false type of the false argument
+ * @tparam T_true A stan `Scalar` type
+ * @tparam T_false A container of stan `Scalar` types
  * @param c Boolean condition value.
  * @param y_true Value to return if condition is true.
  * @param y_false Value to return if condition is false.
@@ -129,16 +129,16 @@ inline ReturnT select(const bool c, const T_true y_true,
 }
 
 /**
- * Return the second argument if the first argument is true
- * and otherwise return the third argument. Overload for use with an Eigen
+ * If first argument is true return the second argument,
+ * else return the third argument. Overload for use with an Eigen
  * object of booleans, and two scalars.
  *
  * The chosen scalar is returned as an Eigen object of the same dimension
  * as the input Eigen argument
  *
  * @tparam T_bool type of Eigen boolean object
- * @tparam T_true type of the true argument
- * @tparam T_false type of the false argument
+ * @tparam T_true A stan `Scalar` type
+ * @tparam T_false A stan `Scalar` type
  * @param c Eigen object of boolean condition values.
  * @param y_true Value to return if condition is true.
  * @param y_false Value to return if condition is false.
@@ -147,20 +147,22 @@ template <typename T_bool, typename T_true, typename T_false,
           require_eigen_array_vt<std::is_integral, T_bool>* = nullptr,
           require_all_stan_scalar_t<T_true, T_false>* = nullptr>
 inline auto select(const T_bool c, const T_true y_true, const T_false y_false) {
+  using ret_t = return_type_t<T_true, T_false>;
   return c
       .unaryExpr(
-          [y_true, y_false](bool cond) { return cond ? y_true : y_false; })
+          [y_true, y_false](bool cond) {
+            return cond ? ret_t(y_true) : ret_t(y_false); })
       .eval();
 }
 
 /**
- * Return the second argument if the first argument is true
- * and otherwise return the third argument. Overload for use with an Eigen
+ * If first argument is true return the second argument,
+ * else return the third argument. Overload for use with an Eigen
  * array of booleans, one Eigen array and a scalar as input.
  *
  * @tparam T_bool type of Eigen boolean object
- * @tparam T_true type of the true argument
- * @tparam T_false type of the false argument
+ * @tparam T_true A stan `Scalar` type or Eigen Array type
+ * @tparam T_false A stan `Scalar` type or Eigen Array type
  * @param c Eigen object of boolean condition values.
  * @param y_true Value to return if condition is true.
  * @param y_false Value to return if condition is false.
@@ -171,7 +173,8 @@ template <typename T_bool, typename T_true, typename T_false,
 inline auto select(const T_bool c, const T_true y_true, const T_false y_false) {
   check_consistent_sizes("select", "boolean", c, "left hand side", y_true,
                          "right hand side", y_false);
-  return c.select(y_true, y_false).eval();
+  using ret_t = return_type_t<T_true, T_false>;
+  return c.select(y_true, y_false).template cast<ret_t>().eval();
 }
 
 }  // namespace math

test/unit/math/prim/fun/all_test.cpp

@@ -2,6 +2,7 @@
 #include <gtest/gtest.h>
 #include <cmath>
 #include <limits>
+#include <vector>
 
 TEST(MathFunctions, all) {
   using stan::math::all;
@@ -23,20 +24,24 @@ TEST(MathFunctions, all) {
 
   auto bool_tuple
       = std::make_tuple(true, bool_stdvector, bool_array, nested_bool);
+  std::vector<decltype(bool_tuple)> stdvec_bool_tuple{bool_tuple};
 
   EXPECT_FALSE(all(inp < 2));
   EXPECT_TRUE(all(bool_stdvector));
   EXPECT_TRUE(all(bool_array));
   EXPECT_TRUE(all(nested_bool));
   EXPECT_TRUE(all(bool_tuple));
+  EXPECT_TRUE(all(stdvec_bool_tuple));
 
   bool_array(2) = false;
   nested_bool[1](3) = false;
   bool_stdvector[1] = false;
   std::get<3>(bool_tuple) = nested_bool;
+  stdvec_bool_tuple[0] = bool_tuple;
 
   EXPECT_FALSE(all(bool_array));
   EXPECT_FALSE(all(nested_bool));
   EXPECT_FALSE(all(bool_stdvector));
   EXPECT_FALSE(all(bool_tuple));
+  EXPECT_FALSE(all(stdvec_bool_tuple));
 }

test/unit/math/prim/fun/any_test.cpp

@@ -23,20 +23,24 @@ TEST(MathFunctions, any) {
 
   auto bool_tuple
       = std::make_tuple(false, bool_stdvector, bool_array, nested_bool);
+  std::vector<decltype(bool_tuple)> stdvec_bool_tuple{bool_tuple};
 
   EXPECT_TRUE(any(inp < 2));
   EXPECT_FALSE(any(bool_stdvector));
   EXPECT_FALSE(any(bool_array));
   EXPECT_FALSE(any(nested_bool));
   EXPECT_FALSE(any(bool_tuple));
+  EXPECT_FALSE(any(stdvec_bool_tuple));
 
   bool_array(2) = true;
   nested_bool[1](3) = true;
   bool_stdvector[1] = true;
   std::get<3>(bool_tuple) = nested_bool;
+  stdvec_bool_tuple[0] = bool_tuple;
 
   EXPECT_TRUE(any(bool_array));
   EXPECT_TRUE(any(nested_bool));
   EXPECT_TRUE(any(bool_stdvector));
   EXPECT_TRUE(any(bool_tuple));
+  EXPECT_TRUE(any(stdvec_bool_tuple));
 }