Add reverse

stan/math/prim/fun.hpp

@@ -233,6 +233,7 @@
 #include <stan/math/prim/fun/rep_row_vector.hpp>
 #include <stan/math/prim/fun/rep_vector.hpp>
 #include <stan/math/prim/fun/resize.hpp>
+#include <stan/math/prim/fun/reverse.hpp>
 #include <stan/math/prim/fun/rising_factorial.hpp>
 #include <stan/math/prim/fun/round.hpp>
 #include <stan/math/prim/fun/row.hpp>

stan/math/prim/fun/reverse.hpp

@@ -0,0 +1,41 @@
+#ifndef STAN_MATH_PRIM_FUN_REVERSE_HPP
+#define STAN_MATH_PRIM_FUN_REVERSE_HPP
+
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <algorithm>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return a copy of the specified array in reversed order.
+ *
+ * @tparam T type of elements in the array
+ * @param x array to reverse
+ * @return Array in reversed order.
+ */
+template <typename T>
+inline std::vector<T> reverse(const std::vector<T>& x) {
+  std::vector<T> rev(x.size());
+  std::reverse_copy(x.begin(), x.end(), rev.begin());
+  return rev;
+}
+
+/**
+ * Return a copy of the specified vector or row vector
+ * in reversed order.
+ *
+ * @tparam T type of container (vector or row vector)
+ * @param x vector or row vector to reverse
+ * @return Vector or row vector in reversed order.
+ */
+template <typename T, typename = require_eigen_vector_t<T>>
+inline auto reverse(const T& x) {
+  return x.reverse().eval();
+}
+
+}  // namespace math
+}  // namespace stan
+#endif

test/unit/math/mix/fun/reverse_test.cpp

@@ -0,0 +1,54 @@
+#include <test/unit/math/test_ad.hpp>
+#include <vector>
+
+TEST(MathMixMatFun, reverse_vector) {
+  auto f = [](const auto& x) { return stan::math::reverse(x); };
+
+  // 0 x 0
+  Eigen::VectorXd x0(0);
+  stan::test::expect_ad(f, x0);
+
+  // 1 x 1
+  Eigen::VectorXd x1(1);
+  x1 << 1;
+  stan::test::expect_ad(f, x1);
+
+  // 4 x 4
+  Eigen::VectorXd x(4);
+  x << 1, 3, 4, -5;
+  stan::test::expect_ad(f, x);
+}
+
+TEST(MathMixMatFun, reverse_row_vector) {
+  auto f = [](const auto& x) { return stan::math::reverse(x); };
+
+  // 0 x 0
+  Eigen::RowVectorXd x0(0);
+  stan::test::expect_ad(f, x0);
+
+  // 1 x 1
+  Eigen::RowVectorXd x1(1);
+  x1 << 1;
+  stan::test::expect_ad(f, x1);
+
+  // 4 x 4
+  Eigen::RowVectorXd x(4);
+  x << 1, 3, 4, -5;
+  stan::test::expect_ad(f, x);
+}
+
+TEST(MathMixMatFun, reverse_array) {
+  auto f = [](const auto& x) { return stan::math::reverse(x); };
+
+  // 0 x 0
+  std::vector<double> x0(0);
+  stan::test::expect_ad(f, x0);
+
+  // 1 x 1
+  std::vector<double> x1{1};
+  stan::test::expect_ad(f, x1);
+
+  // 4 x 4
+  std::vector<double> x{1, 3, 4, -5};
+  stan::test::expect_ad(f, x);
+}

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

@@ -0,0 +1,77 @@
+#include <stan/math/prim.hpp>
+#include <test/unit/math/prim/fun/expect_matrix_eq.hpp>
+#include <gtest/gtest.h>
+#include <vector>
+
+TEST(MathFunctions, reverse_array) {
+  using stan::math::reverse;
+
+  std::vector<double> x0;
+  EXPECT_EQ(0, reverse(x0).size());
+
+  std::vector<double> x1(5);
+  EXPECT_FLOAT_EQ(x1[0], reverse(x1)[0]);
+
+  std::vector<double> x{7, -1.2, 4, -3};
+  std::vector<double> rev{-3, 4, -1.2, 7};
+  std::vector<double> y = stan::math::reverse(x);
+  for (int i = 0; i < x.size(); i++) {
+    EXPECT_FLOAT_EQ(y[i], rev[i]);
+  }
+
+  std::vector<std::vector<double>> cont_x{x0, x1, x};
+  std::vector<std::vector<double>> cont_rev{x, x1, x0};
+  std::vector<std::vector<double>> cont_y = stan::math::reverse(cont_x);
+  for (int i = 0; i < cont_x.size(); i++) {
+    EXPECT_EQ(cont_y[i].size(), cont_rev[i].size());
+    for (int j = 0; j < cont_y[i].size(); j++) {
+      EXPECT_FLOAT_EQ(cont_y[i][j], cont_rev[i][j]);
+    }
+  }
+}
+
+TEST(MathFunctions, reverse_vector) {
+  using stan::math::reverse;
+
+  Eigen::VectorXd x0(0);
+  EXPECT_EQ(0, reverse(x0).size());
+
+  Eigen::VectorXd x1 = Eigen::VectorXd::Constant(1, 5);
+  expect_matrix_eq(x1, reverse(x1));
+
+  Eigen::VectorXd x(4);
+  x << 7, -1.2, 4, -3;
+  Eigen::VectorXd rev(4);
+  rev << -3, 4, -1.2, 7;
+  expect_matrix_eq(rev, reverse(x));
+
+  std::vector<Eigen::VectorXd> cont_x{x0, x1, x};
+  std::vector<Eigen::VectorXd> cont_rev{x, x1, x0};
+  std::vector<Eigen::VectorXd> cont_y = stan::math::reverse(cont_x);
+  for (int i = 0; i < cont_x.size(); i++) {
+    expect_matrix_eq(cont_y[i], cont_rev[i]);
+  }
+}
+
+TEST(MathFunctions, reverse_row_vector) {
+  using stan::math::reverse;
+
+  Eigen::RowVectorXd x0(0);
+  EXPECT_EQ(0, reverse(x0).size());
+
+  Eigen::RowVectorXd x1 = Eigen::RowVectorXd::Constant(1, 5);
+  expect_matrix_eq(x1, reverse(x1));
+
+  Eigen::RowVectorXd x(4);
+  x << 7, -1.2, 4, -3;
+  Eigen::RowVectorXd rev(4);
+  rev << -3, 4, -1.2, 7;
+  expect_matrix_eq(rev, reverse(x));
+
+  std::vector<Eigen::RowVectorXd> cont_x{x0, x1, x};
+  std::vector<Eigen::RowVectorXd> cont_rev{x, x1, x0};
+  std::vector<Eigen::RowVectorXd> cont_y = stan::math::reverse(cont_x);
+  for (int i = 0; i < cont_x.size(); i++) {
+    expect_matrix_eq(cont_y[i], cont_rev[i]);
+  }
+}