1 #ifdef STAN_OPENCL
2 #include <stan/math/opencl/rev.hpp>
3 #include <stan/math.hpp>
4 #include <gtest/gtest.h>
5 #include <test/unit/math/opencl/util.hpp>
6 #include <vector>
7
TEST(muProbDistributionsNegBinomial2,error_checking)8 TEST(muProbDistributionsNegBinomial2, error_checking) {
9 int N = 3;
10
11 std::vector<int> n{1, 0, 12};
12 std::vector<int> n_size{1, 0, 1, 0};
13 std::vector<int> n_value{0, 1, -3};
14
15 Eigen::VectorXd mu(N);
16 mu << 0.3, 0.8, 1.3;
17 Eigen::VectorXd mu_size(N - 1);
18 mu_size << 0.3, 0.8;
19 Eigen::VectorXd mu_value1(N);
20 mu_value1 << 0.3, -0.3, 0.5;
21 Eigen::VectorXd mu_value2(N);
22 mu_value2 << 0.3, INFINITY, 0.5;
23
24 Eigen::VectorXd phi(N);
25 phi << 0.3, 0.8, 1.3;
26 Eigen::VectorXd phi_size(N - 1);
27 phi_size << 0.3, 0.8;
28 Eigen::VectorXd phi_value1(N);
29 phi_value1 << 0.3, -0.8, 0.5;
30 Eigen::VectorXd phi_value2(N);
31 phi_value2 << 0.3, INFINITY, 0.5;
32
33 stan::math::matrix_cl<int> n_cl(n);
34 stan::math::matrix_cl<int> n_size_cl(n_size);
35 stan::math::matrix_cl<int> n_value_cl(n_value);
36 stan::math::matrix_cl<double> mu_cl(mu);
37 stan::math::matrix_cl<double> mu_size_cl(mu_size);
38 stan::math::matrix_cl<double> mu_value1_cl(mu_value1);
39 stan::math::matrix_cl<double> mu_value2_cl(mu_value2);
40 stan::math::matrix_cl<double> phi_cl(phi);
41 stan::math::matrix_cl<double> phi_size_cl(phi_size);
42 stan::math::matrix_cl<double> phi_value1_cl(phi_value1);
43 stan::math::matrix_cl<double> phi_value2_cl(phi_value2);
44
45 EXPECT_NO_THROW(stan::math::neg_binomial_2_lpmf(n_cl, mu_cl, phi_cl));
46
47 EXPECT_THROW(stan::math::neg_binomial_2_lpmf(n_size_cl, mu_cl, phi_cl),
48 std::invalid_argument);
49 EXPECT_THROW(stan::math::neg_binomial_2_lpmf(n_cl, mu_size_cl, phi_cl),
50 std::invalid_argument);
51 EXPECT_THROW(stan::math::neg_binomial_2_lpmf(n_cl, mu_cl, phi_size_cl),
52 std::invalid_argument);
53
54 EXPECT_THROW(stan::math::neg_binomial_2_lpmf(n_value_cl, mu_cl, phi_cl),
55 std::domain_error);
56 EXPECT_THROW(stan::math::neg_binomial_2_lpmf(n_cl, mu_value1_cl, phi_cl),
57 std::domain_error);
58 EXPECT_THROW(stan::math::neg_binomial_2_lpmf(n_cl, mu_value2_cl, phi_cl),
59 std::domain_error);
60 EXPECT_THROW(stan::math::neg_binomial_2_lpmf(n_cl, mu_cl, phi_value1_cl),
61 std::domain_error);
62 EXPECT_THROW(stan::math::neg_binomial_2_lpmf(n_cl, mu_cl, phi_value2_cl),
63 std::domain_error);
64 }
65
66 auto neg_binomial_2_lpmf_functor
__anon606c21e00102(const auto& n, const auto& mu, const auto& phi) 67 = [](const auto& n, const auto& mu, const auto& phi) {
68 return stan::math::neg_binomial_2_lpmf(n, mu, phi);
69 };
70 auto neg_binomial_2_lpmf_functor_propto
__anon606c21e00202(const auto& n, const auto& mu, const auto& phi) 71 = [](const auto& n, const auto& mu, const auto& phi) {
72 return stan::math::neg_binomial_2_lpmf<true>(n, mu, phi);
73 };
74
TEST(muProbDistributionsNegBinomial2,opencl_matches_cpu_small)75 TEST(muProbDistributionsNegBinomial2, opencl_matches_cpu_small) {
76 int N = 3;
77 int M = 2;
78
79 std::vector<int> n{1, 0, 12};
80 Eigen::VectorXd mu(N);
81 mu << 0.3, 0.5, 1.8;
82 Eigen::VectorXd phi(N);
83 phi << 0.3, 0.8, 1.3;
84
85 stan::math::test::compare_cpu_opencl_prim_rev(neg_binomial_2_lpmf_functor, n,
86 mu, phi);
87 stan::math::test::compare_cpu_opencl_prim_rev(
88 neg_binomial_2_lpmf_functor_propto, n, mu, phi);
89 stan::math::test::compare_cpu_opencl_prim_rev(neg_binomial_2_lpmf_functor, n,
90 mu.transpose().eval(),
91 phi.transpose().eval());
92 stan::math::test::compare_cpu_opencl_prim_rev(
93 neg_binomial_2_lpmf_functor_propto, n, mu.transpose().eval(),
94 phi.transpose().eval());
95 }
96
TEST(muProbDistributionsNegBinomial2,opencl_broadcast_n)97 TEST(muProbDistributionsNegBinomial2, opencl_broadcast_n) {
98 int N = 3;
99
100 int n = 2;
101 Eigen::VectorXd mu(N);
102 mu << 0.3, 0.5, 1.8;
103 Eigen::VectorXd phi(N);
104 phi << 0.3, 0.8, 1.3;
105
106 stan::math::test::test_opencl_broadcasting_prim_rev<0>(
107 neg_binomial_2_lpmf_functor, n, mu, phi);
108 stan::math::test::test_opencl_broadcasting_prim_rev<0>(
109 neg_binomial_2_lpmf_functor_propto, n, mu, phi);
110 stan::math::test::test_opencl_broadcasting_prim_rev<0>(
111 neg_binomial_2_lpmf_functor, n, mu.transpose().eval(), phi);
112 stan::math::test::test_opencl_broadcasting_prim_rev<0>(
113 neg_binomial_2_lpmf_functor_propto, n, mu, phi.transpose().eval());
114 }
115
TEST(muProbDistributionsNegBinomial2,opencl_broadcast_mu)116 TEST(muProbDistributionsNegBinomial2, opencl_broadcast_mu) {
117 int N = 3;
118
119 std::vector<int> n{1, 0, 12};
120 double mu = 0.4;
121 Eigen::VectorXd phi(N);
122 phi << 0.3, 0.8, 1.3;
123
124 stan::math::test::test_opencl_broadcasting_prim_rev<1>(
125 neg_binomial_2_lpmf_functor, n, mu, phi);
126 stan::math::test::test_opencl_broadcasting_prim_rev<1>(
127 neg_binomial_2_lpmf_functor_propto, n, mu, phi);
128 stan::math::test::test_opencl_broadcasting_prim_rev<1>(
129 neg_binomial_2_lpmf_functor, n, mu, phi.transpose().eval());
130 stan::math::test::test_opencl_broadcasting_prim_rev<1>(
131 neg_binomial_2_lpmf_functor_propto, n, mu, phi.transpose().eval());
132 }
133
TEST(muProbDistributionsNegBinomial2,opencl_broadcast_phi)134 TEST(muProbDistributionsNegBinomial2, opencl_broadcast_phi) {
135 int N = 3;
136
137 std::vector<int> n{1, 0, 12};
138 Eigen::VectorXd mu(N);
139 mu << 0.3, 0.5, 1.8;
140 double phi = 0.4;
141
142 stan::math::test::test_opencl_broadcasting_prim_rev<2>(
143 neg_binomial_2_lpmf_functor, n, mu, phi);
144 stan::math::test::test_opencl_broadcasting_prim_rev<2>(
145 neg_binomial_2_lpmf_functor_propto, n, mu, phi);
146 stan::math::test::test_opencl_broadcasting_prim_rev<2>(
147 neg_binomial_2_lpmf_functor, n, mu.transpose().eval(), phi);
148 stan::math::test::test_opencl_broadcasting_prim_rev<2>(
149 neg_binomial_2_lpmf_functor_propto, n, mu.transpose().eval(), phi);
150 }
151
TEST(muProbDistributionsNegBinomial2,opencl_matches_cpu_big)152 TEST(muProbDistributionsNegBinomial2, opencl_matches_cpu_big) {
153 int N = 153;
154
155 std::vector<int> n(N);
156 for (int i = 0; i < N; i++) {
157 n[i] = Eigen::Array<int, Eigen::Dynamic, 1>::Random(1, 1).abs()(0) % 1000;
158 }
159 Eigen::Matrix<double, Eigen::Dynamic, 1> mu
160 = Eigen::Array<double, Eigen::Dynamic, 1>::Random(N, 1).abs();
161 Eigen::Matrix<double, Eigen::Dynamic, 1> phi
162 = Eigen::Array<double, Eigen::Dynamic, 1>::Random(N, 1).abs();
163
164 stan::math::test::compare_cpu_opencl_prim_rev(neg_binomial_2_lpmf_functor, n,
165 mu, phi);
166 stan::math::test::compare_cpu_opencl_prim_rev(
167 neg_binomial_2_lpmf_functor_propto, n, mu, phi);
168 stan::math::test::compare_cpu_opencl_prim_rev(neg_binomial_2_lpmf_functor, n,
169 mu.transpose().eval(),
170 phi.transpose().eval());
171 stan::math::test::compare_cpu_opencl_prim_rev(
172 neg_binomial_2_lpmf_functor_propto, n, mu.transpose().eval(),
173 phi.transpose().eval());
174 }
175
TEST(ProbDistributionsNegBinomial2,opencl_scalar_n_mu)176 TEST(ProbDistributionsNegBinomial2, opencl_scalar_n_mu) {
177 int N = 3;
178 int M = 2;
179
180 int n = 1;
181 double mu = 0.3;
182 Eigen::VectorXd phi(N);
183 phi << 0.3, 0.8, 1.3;
184
185 stan::math::test::compare_cpu_opencl_prim_rev(neg_binomial_2_lpmf_functor, n,
186 mu, phi);
187 stan::math::test::compare_cpu_opencl_prim_rev(
188 neg_binomial_2_lpmf_functor_propto, n, mu, phi);
189 }
190
191 #endif
192