Stan Math Library  2.20.0
reverse mode automatic differentiation
gp_dot_prod_cov.hpp
Go to the documentation of this file.
1 #ifndef STAN_MATH_PRIM_MAT_FUN_COV_DOT_PROD_HPP
2 #define STAN_MATH_PRIM_MAT_FUN_COV_DOT_PROD_HPP
3 
12 #include <vector>
13 
14 namespace stan {
15 namespace math {
16 
38 template <typename T_x, typename T_sigma>
39 Eigen::Matrix<typename return_type<T_x, T_sigma>::type, Eigen::Dynamic,
40  Eigen::Dynamic>
41 gp_dot_prod_cov(const std::vector<Eigen::Matrix<T_x, Eigen::Dynamic, 1>> &x,
42  const T_sigma &sigma) {
43  check_not_nan("gp_dot_prod_cov", "sigma", sigma);
44  check_nonnegative("gp_dot_prod_cov", "sigma", sigma);
45  check_finite("gp_dot_prod_cov", "sigma", sigma);
46 
47  size_t x_size = x.size();
48  for (size_t i = 0; i < x_size; ++i) {
49  check_not_nan("gp_dot_prod_cov", "x", x[i]);
50  check_finite("gp_dot_prod_cov", "x", x[i]);
51  }
52 
53  Eigen::Matrix<typename stan::return_type<T_x, T_sigma>::type, Eigen::Dynamic,
54  Eigen::Dynamic>
55  cov(x_size, x_size);
56  if (x_size == 0)
57  return cov;
58 
59  T_sigma sigma_sq = square(sigma);
60 
61  for (size_t i = 0; i < (x_size - 1); ++i) {
62  cov(i, i) = sigma_sq + dot_self(x[i]);
63  for (size_t j = i + 1; j < x_size; ++j) {
64  cov(i, j) = sigma_sq + dot_product(x[i], x[j]);
65  cov(j, i) = cov(i, j);
66  }
67  }
68  cov(x_size - 1, x_size - 1) = sigma_sq + dot_self(x[x_size - 1]);
69  return cov;
70 }
71 
94 template <typename T_x, typename T_sigma>
95 Eigen::Matrix<typename return_type<T_x, T_sigma>::type, Eigen::Dynamic,
96  Eigen::Dynamic>
97 gp_dot_prod_cov(const std::vector<T_x> &x, const T_sigma &sigma) {
98  check_not_nan("gp_dot_prod_cov", "sigma", sigma);
99  check_nonnegative("gp_dot_prod_cov", "sigma", sigma);
100  check_finite("gp_dot_prod_cov", "sigma", sigma);
101 
102  size_t x_size = x.size();
103  check_not_nan("gp_dot_prod_cov", "x", x);
104  check_finite("gp_dot_prod_cov", "x", x);
105 
106  Eigen::Matrix<typename stan::return_type<T_x, T_sigma>::type, Eigen::Dynamic,
107  Eigen::Dynamic>
108  cov(x_size, x_size);
109  if (x_size == 0)
110  return cov;
111 
112  T_sigma sigma_sq = square(sigma);
113 
114  for (size_t i = 0; i < (x_size - 1); ++i) {
115  cov(i, i) = sigma_sq + x[i] * x[i];
116  for (size_t j = i + 1; j < x_size; ++j) {
117  cov(i, j) = sigma_sq + x[i] * x[j];
118  cov(j, i) = cov(i, j);
119  }
120  }
121  cov(x_size - 1, x_size - 1) = sigma_sq + x[x_size - 1] * x[x_size - 1];
122  return cov;
123 }
124 
147 template <typename T_x1, typename T_x2, typename T_sigma>
148 Eigen::Matrix<typename return_type<T_x1, T_x2, T_sigma>::type, Eigen::Dynamic,
149  Eigen::Dynamic>
150 gp_dot_prod_cov(const std::vector<Eigen::Matrix<T_x1, Eigen::Dynamic, 1>> &x1,
151  const std::vector<Eigen::Matrix<T_x2, Eigen::Dynamic, 1>> &x2,
152  const T_sigma &sigma) {
153  check_not_nan("gp_dot_prod_cov", "sigma", sigma);
154  check_nonnegative("gp_dot_prod_cov", "sigma", sigma);
155  check_finite("gp_dot_prod_cov", "sigma", sigma);
156 
157  size_t x1_size = x1.size();
158  size_t x2_size = x2.size();
159  for (size_t i = 0; i < x1_size; ++i) {
160  check_not_nan("gp_dot_prod_cov", "x1", x1[i]);
161  check_finite("gp_dot_prod_cov", "x1", x1[i]);
162  }
163  for (size_t i = 0; i < x2_size; ++i) {
164  check_not_nan("gp_dot_prod_cov", "x2", x2[i]);
165  check_finite("gp_dot_prod_cov", "x2", x2[i]);
166  }
167  Eigen::Matrix<typename return_type<T_x1, T_x2, T_sigma>::type, Eigen::Dynamic,
168  Eigen::Dynamic>
169  cov(x1_size, x2_size);
170 
171  if (x1_size == 0 || x2_size == 0)
172  return cov;
173 
174  T_sigma sigma_sq = square(sigma);
175 
176  for (size_t i = 0; i < x1_size; ++i) {
177  for (size_t j = 0; j < x2_size; ++j) {
178  cov(i, j) = sigma_sq + dot_product(x1[i], x2[j]);
179  }
180  }
181  return cov;
182 }
183 
206 template <typename T_x1, typename T_x2, typename T_sigma>
207 Eigen::Matrix<typename return_type<T_x1, T_x2, T_sigma>::type, Eigen::Dynamic,
208  Eigen::Dynamic>
209 gp_dot_prod_cov(const std::vector<T_x1> &x1, const std::vector<T_x2> &x2,
210  const T_sigma &sigma) {
211  check_not_nan("gp_dot_prod_cov", "sigma", sigma);
212  check_nonnegative("gp_dot_prod_cov", "sigma", sigma);
213  check_finite("gp_dot_prod_cov", "sigma", sigma);
214 
215  size_t x1_size = x1.size();
216  size_t x2_size = x2.size();
217  check_not_nan("gp_dot_prod_cov", "x1", x1);
218  check_finite("gp_dot_prod_cov", "x1", x1);
219  check_not_nan("gp_dot_prod_cov", "x2", x2);
220  check_finite("gp_dot_prod_cov", "x2", x2);
221 
222  Eigen::Matrix<typename stan::return_type<T_x1, T_x2, T_sigma>::type,
223  Eigen::Dynamic, Eigen::Dynamic>
224  cov(x1_size, x2_size);
225 
226  if (x1_size == 0 || x2_size == 0)
227  return cov;
228 
229  T_sigma sigma_sq = square(sigma);
230 
231  for (size_t i = 0; i < x1_size; ++i) {
232  for (size_t j = 0; j < x2_size; ++j) {
233  cov(i, j) = sigma_sq + x1[i] * x2[j];
234  }
235  }
236  return cov;
237 }
238 } // namespace math
239 } // namespace stan
240 #endif
void check_finite(const char *function, const char *name, const T_y &y)
Check if y is finite.
fvar< T > dot_self(const Eigen::Matrix< fvar< T >, R, C > &v)
Definition: dot_self.hpp:13
void check_nonnegative(const char *function, const char *name, const T_y &y)
Check if y is non-negative.
fvar< T > square(const fvar< T > &x)
Definition: square.hpp:12
void check_not_nan(const char *function, const char *name, const T_y &y)
Check if y is not NaN.
fvar< T > dot_product(const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2)
Definition: dot_product.hpp:14
Eigen::Matrix< typename return_type< T_x, T_sigma >::type, Eigen::Dynamic, Eigen::Dynamic > gp_dot_prod_cov(const std::vector< Eigen::Matrix< T_x, Eigen::Dynamic, 1 >> &x, const T_sigma &sigma)
Returns a dot product covariance matrix.

     [ Stan Home Page ] © 2011–2018, Stan Development Team.