Add row vector, array and int_array construction utilities

stan/math/prim/fun.hpp

@@ -40,7 +40,6 @@
 #include <stan/math/prim/fun/columns_dot_product.hpp>
 #include <stan/math/prim/fun/columns_dot_self.hpp>
 #include <stan/math/prim/fun/common_type.hpp>
-#include <stan/math/prim/fun/constant_vector.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/corr_constrain.hpp>
 #include <stan/math/prim/fun/corr_free.hpp>
@@ -198,7 +197,13 @@
 #include <stan/math/prim/fun/num_elements.hpp>
 #include <stan/math/prim/fun/offset_multiplier_constrain.hpp>
 #include <stan/math/prim/fun/offset_multiplier_free.hpp>
+#include <stan/math/prim/fun/one_hot_array.hpp>
+#include <stan/math/prim/fun/one_hot_int_array.hpp>
+#include <stan/math/prim/fun/one_hot_row_vector.hpp>
 #include <stan/math/prim/fun/one_hot_vector.hpp>
+#include <stan/math/prim/fun/ones_array.hpp>
+#include <stan/math/prim/fun/ones_int_array.hpp>
+#include <stan/math/prim/fun/ones_row_vector.hpp>
 #include <stan/math/prim/fun/ones_vector.hpp>
 #include <stan/math/prim/fun/ordered_constrain.hpp>
 #include <stan/math/prim/fun/ordered_free.hpp>
@@ -243,7 +248,6 @@
 #include <stan/math/prim/fun/scaled_add.hpp>
 #include <stan/math/prim/fun/sd.hpp>
 #include <stan/math/prim/fun/segment.hpp>
-#include <stan/math/prim/fun/set_spaced_vector.hpp>
 #include <stan/math/prim/fun/sign.hpp>
 #include <stan/math/prim/fun/simplex_constrain.hpp>
 #include <stan/math/prim/fun/simplex_free.hpp>
@@ -257,6 +261,9 @@
 #include <stan/math/prim/fun/sort_indices.hpp>
 #include <stan/math/prim/fun/sort_indices_asc.hpp>
 #include <stan/math/prim/fun/sort_indices_desc.hpp>
+#include <stan/math/prim/fun/spaced_array.hpp>
+#include <stan/math/prim/fun/spaced_row_vector.hpp>
+#include <stan/math/prim/fun/spaced_vector.hpp>
 #include <stan/math/prim/fun/sqrt.hpp>
 #include <stan/math/prim/fun/square.hpp>
 #include <stan/math/prim/fun/squared_distance.hpp>
@@ -295,6 +302,9 @@
 #include <stan/math/prim/fun/variance.hpp>
 #include <stan/math/prim/fun/welford_covar_estimator.hpp>
 #include <stan/math/prim/fun/welford_var_estimator.hpp>
+#include <stan/math/prim/fun/zeros_array.hpp>
+#include <stan/math/prim/fun/zeros_int_array.hpp>
+#include <stan/math/prim/fun/zeros_row_vector.hpp>
 #include <stan/math/prim/fun/zeros_vector.hpp>
 
 #endif

stan/math/prim/fun/one_hot_array.hpp

@@ -0,0 +1,33 @@
+#ifndef STAN_MATH_PRIM_FUN_ONE_HOT_ARRAY_HPP
+#define STAN_MATH_PRIM_FUN_ONE_HOT_ARRAY_HPP
+
+#include <stan/math/prim/err.hpp>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return an array with 1 in the k-th position and zero elsewhere.
+ *
+ * @param K size of the array
+ * @param k position of the 1 (indexing from 1)
+ * @return An array of size K with all elements initialised to zero
+ * and a 1 in the k-th position.
+ * @throw std::domain_error if K is not positive, or if k is less than 1 or
+ * greater than K.
+ */
+inline std::vector<double> one_hot_array(int K, int k) {
+  static const char* function = "one_hot_array";
+  check_positive(function, "size", K);
+  check_bounded(function, "k", k, 1, K);
+
+  std::vector<double> v(K, 0);
+  v[k - 1] = 1;
+  return v;
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/prim/fun/one_hot_int_array.hpp

@@ -0,0 +1,33 @@
+#ifndef STAN_MATH_PRIM_FUN_ONE_HOT_INT_ARRAY_HPP
+#define STAN_MATH_PRIM_FUN_ONE_HOT_INT_ARRAY_HPP
+
+#include <stan/math/prim/err.hpp>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return an integer array with 1 in the k-th position and zero elsewhere.
+ *
+ * @param K size of the array
+ * @param k position of the 1 (indexing from 1)
+ * @return An integer array of size K with all elements initialised to zero
+ * and a 1 in the k-th position.
+ * @throw std::domain_error if K is not positive, or if k is less than 1 or
+ * greater than K.
+ */
+inline std::vector<int> one_hot_int_array(int K, int k) {
+  static const char* function = "one_hot_int_array";
+  check_positive(function, "size", K);
+  check_bounded(function, "k", k, 1, K);
+
+  std::vector<int> v(K, 0);
+  v[k - 1] = 1;
+  return v;
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/prim/fun/one_hot_row_vector.hpp

@@ -0,0 +1,33 @@
+#ifndef STAN_MATH_PRIM_FUN_ONE_HOT_ROW_VECTOR_HPP
+#define STAN_MATH_PRIM_FUN_ONE_HOT_ROW_VECTOR_HPP
+
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return a row vector with 1 in the k-th position and zero elsewhere
+ *
+ * @param K size of the row vector
+ * @param k position of the 1 (indexing from 1)
+ * @return A row vector of size K with all elements initialised to zero
+ * and a 1 in the k-th position.
+ * @throw std::domain_error if K is not positive, or if k is less than 1 or
+ * greater than K.
+ */
+inline Eigen::RowVectorXd one_hot_row_vector(int K, int k) {
+  static const char* function = "one_hot_row_vector";
+  check_positive(function, "size", K);
+  check_bounded(function, "k", k, 1, K);
+
+  Eigen::RowVectorXd ret = Eigen::RowVectorXd::Zero(K);
+  ret(k - 1) = 1;
+  return ret;
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/prim/fun/ones_array.hpp

@@ -0,0 +1,25 @@
+#ifndef STAN_MATH_PRIM_FUN_ONES_ARRAY_HPP
+#define STAN_MATH_PRIM_FUN_ONES_ARRAY_HPP
+
+#include <stan/math/prim/err.hpp>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return an array of ones.
+ *
+ * @param K size of the array
+ * @return An array of size K with all elements initialised to 1.
+ * @throw std::domain_error if K is negative.
+ */
+inline std::vector<double> ones_array(int K) {
+  check_nonnegative("ones_array", "size", K);
+  return std::vector<double>(K, 1);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/prim/fun/ones_int_array.hpp

@@ -0,0 +1,25 @@
+#ifndef STAN_MATH_PRIM_FUN_ONES_INT_ARRAY_HPP
+#define STAN_MATH_PRIM_FUN_ONES_INT_ARRAY_HPP
+
+#include <stan/math/prim/err.hpp>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return an integer array of ones.
+ *
+ * @param K size of the array
+ * @return An integer array of size K with all elements initialised to 1.
+ * @throw std::domain_error if K is negative.
+ */
+inline std::vector<int> ones_int_array(int K) {
+  check_nonnegative("ones_int_array", "size", K);
+  return std::vector<int>(K, 1);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/prim/fun/ones_row_vector.hpp

@@ -0,0 +1,25 @@
+#ifndef STAN_MATH_PRIM_FUN_ONES_ROW_VECTOR_HPP
+#define STAN_MATH_PRIM_FUN_ONES_ROW_VECTOR_HPP
+
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return a row vector of ones
+ *
+ * @param K size of the row vector
+ * @return A row vector of size K with all elements initialised to 1.
+ * @throw std::domain_error if K is negative.
+ */
+inline Eigen::RowVectorXd ones_row_vector(int K) {
+  check_nonnegative("ones_row_vector", "size", K);
+  return Eigen::RowVectorXd::Constant(K, 1);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/prim/fun/spaced_array.hpp

@@ -0,0 +1,44 @@
+#ifndef STAN_MATH_PRIM_FUN_SPACED_ARRAY_HPP
+#define STAN_MATH_PRIM_FUN_SPACED_ARRAY_HPP
+
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return an array of linearly spaced elements.
+ *
+ * This produces an array from low to high (included) with elements spaced
+ * as (high - low) / (K - 1). For K=1, the array will contain the high value;
+ * for K=0 it returns an empty array.
+ *
+ * @param K size of the array
+ * @param low smallest value
+ * @param high largest value
+ * @return An array of size K with elements linearly spaced between
+ * low and high.
+ * @throw std::domain_error if K is negative, if low is nan or infinite,
+ * if high is nan or infinite, or if high is less than low.
+ */
+inline std::vector<double> spaced_array(int K, double low, double high) {
+  static const char* function = "spaced_array";
+  check_nonnegative(function, "size", K);
+  check_finite(function, "low", low);
+  check_finite(function, "high", high);
+  check_greater_or_equal(function, "high", high, low);
+
+  if (K == 0) {
+    return {};
+  }
+
+  Eigen::VectorXd v = Eigen::VectorXd::LinSpaced(K, low, high);
+  return {&v[0], &v[0] + K};
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/prim/fun/spaced_row_vector.hpp

@@ -0,0 +1,38 @@
+#ifndef STAN_MATH_PRIM_FUN_SPACED_ROW_VECTOR_HPP
+#define STAN_MATH_PRIM_FUN_SPACED_ROW_VECTOR_HPP
+
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return a row vector of linearly spaced elements.
+ *
+ * This produces a row vector from low to high (included) with elements spaced
+ * as (high - low) / (K - 1). For K=1, the vector will contain the high value;
+ * for K=0 it returns an empty vector.
+ *
+ * @param K size of the row vector
+ * @param low smallest value
+ * @param high largest value
+ * @return A row vector of size K with elements linearly spaced between
+ * low and high.
+ * @throw std::domain_error if K is negative, if low is nan or infinite,
+ * if high is nan or infinite, or if high is less than low.
+ */
+inline Eigen::RowVectorXd spaced_row_vector(int K, double low, double high) {
+  static const char* function = "spaced_row_vector";
+  check_nonnegative(function, "size", K);
+  check_finite(function, "low", low);
+  check_finite(function, "high", high);
+  check_greater_or_equal(function, "high", high, low);
+
+  return Eigen::RowVectorXd::LinSpaced(K, low, high);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/prim/fun/set_spaced_vector.hpp → stan/math/prim/fun/spaced_vector.hpp

@@ -1,5 +1,5 @@
-#ifndef STAN_MATH_PRIM_FUN_SET_SPACED_VECTOR_HPP
-#define STAN_MATH_PRIM_FUN_SET_SPACED_VECTOR_HPP
+#ifndef STAN_MATH_PRIM_FUN_SPACED_VECTOR_HPP
+#define STAN_MATH_PRIM_FUN_SPACED_VECTOR_HPP
 
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
@@ -8,7 +8,7 @@ namespace stan {
 namespace math {
 
 /**
- * Return a vector of linearly spaced elements
+ * Return a vector of linearly spaced elements.
  *
  * This produces a vector from low to high (included) with elements spaced
  * as (high - low) / (K - 1). For K=1, the vector will contain the high value;
@@ -22,8 +22,8 @@ namespace math {
  * @throw std::domain_error if K is negative, if low is nan or infinite,
  * if high is nan or infinite, or if high is less than low.
  */
-inline Eigen::VectorXd set_spaced_vector(int K, double low, double high) {
-  static const char* function = "set_spaced_vector";
+inline Eigen::VectorXd spaced_vector(int K, double low, double high) {
+  static const char* function = "spaced_vector";
   check_nonnegative(function, "size", K);
   check_finite(function, "low", low);
   check_finite(function, "high", high);

stan/math/prim/fun/zeros_array.hpp

@@ -0,0 +1,25 @@
+#ifndef STAN_MATH_PRIM_FUN_ZEROS_ARRAY_HPP
+#define STAN_MATH_PRIM_FUN_ZEROS_ARRAY_HPP
+
+#include <stan/math/prim/err.hpp>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return an array of zeros.
+ *
+ * @param K size of the array
+ * @return an array of size K with all elements initialised to 0.
+ * @throw std::domain_error if K is negative.
+ */
+inline std::vector<double> zeros_array(int K) {
+  check_nonnegative("zeros_array", "size", K);
+  return std::vector<double>(K, 0);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif