Skip to content

Commit 7a44645

Browse files
author
Andrew Johnson
committed
Merge branch 'develop' into feature/scalar_binary_complex
2 parents f1967ff + 93898d0 commit 7a44645

3 files changed

Lines changed: 50 additions & 48 deletions

File tree

‎.github/FUNDING.yml‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
github: stan-dev
2+
custom: https://mc-stan.org/support/

‎test/unit/math/opencl/matrix_cl_test.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55
#include <stan/math/opencl/copy.hpp>
66
#include <stan/math/opencl/zeros.hpp>
77
#include <stan/math/opencl/sub_block.hpp>
8-
#include <test/unit/math/prim/fun/expect_matrix_eq.hpp>
8+
#include <test/unit/util.hpp>
99
#include <gtest/gtest.h>
1010
#include <algorithm>
1111
#include <vector>
@@ -35,18 +35,18 @@ TEST(MathMatrixCL, matrix_cl_value) {
3535
col_major << 1, 2, 3, 4, 5, 6, 7, 8, 9;
3636
stan::math::matrix_cl<double> cl_from_col_major(col_major);
3737
Eigen::MatrixXd res = stan::math::from_matrix_cl(cl_from_col_major);
38-
expect_matrix_eq(col_major, res);
38+
EXPECT_MATRIX_EQ(col_major, res);
3939

4040
Eigen::Map<Eigen::MatrixXd> map(col_major.data(), 3, 3);
4141
stan::math::matrix_cl<double> cl_from_map(map);
4242
res = stan::math::from_matrix_cl(cl_from_map);
43-
expect_matrix_eq(col_major, res);
43+
EXPECT_MATRIX_EQ(col_major, res);
4444

4545
Eigen::Matrix<double, -1, -1, Eigen::RowMajor> row_major(3, 3);
4646
row_major << 1, 2, 3, 4, 5, 6, 7, 8, 9;
4747
stan::math::matrix_cl<double> cl_from_row_major(row_major);
4848
res = stan::math::from_matrix_cl(cl_from_row_major);
49-
expect_matrix_eq(row_major, res);
49+
EXPECT_MATRIX_EQ(row_major, res);
5050
}
5151

5252
TEST(MathMatrixCL, assignment) {

‎test/unit/math/prim/meta/ref_type_test.cpp‎

Lines changed: 44 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
#include <stan/math/prim/meta.hpp>
2-
#include <test/unit/math/prim/fun/expect_matrix_eq.hpp>
2+
#include <test/unit/util.hpp>
33
#include <gtest/gtest.h>
44

55
TEST(MathMetaPrim, ref_type_non_eigen) {
@@ -18,14 +18,14 @@ TEST(MathMetaPrim, ref_type_non_eigen) {
1818
ref_type_t<const std::vector<double>> c_ref1 = c;
1919
ref_type_t<const std::vector<double>&> c_ref2 = c;
2020

21-
expect_std_vector_eq(a_ref1, a);
22-
expect_std_vector_eq(a_ref2, a);
23-
expect_std_vector_eq(a_ref3, a);
21+
EXPECT_STD_VECTOR_FLOAT_EQ(a_ref1, a);
22+
EXPECT_STD_VECTOR_FLOAT_EQ(a_ref2, a);
23+
EXPECT_STD_VECTOR_FLOAT_EQ(a_ref3, a);
2424
EXPECT_EQ(b_ref1, b);
2525
EXPECT_EQ(b_ref2, b);
2626
EXPECT_EQ(b_ref3, b);
27-
expect_std_vector_eq(c_ref1, c);
28-
expect_std_vector_eq(c_ref2, c);
27+
EXPECT_STD_VECTOR_FLOAT_EQ(c_ref1, c);
28+
EXPECT_STD_VECTOR_FLOAT_EQ(c_ref2, c);
2929
EXPECT_TRUE(std::is_lvalue_reference<ref_type_t<double>>::value);
3030
EXPECT_TRUE(std::is_lvalue_reference<ref_type_t<double&>>::value);
3131
EXPECT_FALSE(std::is_reference<ref_type_t<double&&>>::value);
@@ -57,17 +57,17 @@ TEST(MathMetaPrim, ref_type_eigen_directly_accessible) {
5757
ref_type_t<Eigen::Ref<Eigen::MatrixXd>&> c_ref2 = c;
5858
ref_type_t<Eigen::Ref<Eigen::MatrixXd>&&> c_ref3 = std::move(c2);
5959

60-
expect_matrix_eq(a_ref1, a);
61-
expect_matrix_eq(a_ref2, a);
62-
expect_matrix_eq(a_ref3, a);
60+
EXPECT_MATRIX_EQ(a_ref1, a);
61+
EXPECT_MATRIX_EQ(a_ref2, a);
62+
EXPECT_MATRIX_EQ(a_ref3, a);
6363

64-
expect_matrix_eq(b_ref1, b);
65-
expect_matrix_eq(b_ref2, b);
66-
expect_matrix_eq(b_ref3, b);
64+
EXPECT_MATRIX_EQ(b_ref1, b);
65+
EXPECT_MATRIX_EQ(b_ref2, b);
66+
EXPECT_MATRIX_EQ(b_ref3, b);
6767

68-
expect_matrix_eq(c_ref1, c);
69-
expect_matrix_eq(c_ref2, c);
70-
expect_matrix_eq(c_ref3, c);
68+
EXPECT_MATRIX_EQ(c_ref1, c);
69+
EXPECT_MATRIX_EQ(c_ref2, c);
70+
EXPECT_MATRIX_EQ(c_ref3, c);
7171
EXPECT_TRUE((std::is_same<decltype(a), ref_type_t<decltype(a)&&>>::value));
7272
EXPECT_TRUE((std::is_same<decltype(b), ref_type_t<decltype(b)&&>>::value));
7373
EXPECT_TRUE((std::is_same<decltype(c), ref_type_t<decltype(c)&&>>::value));
@@ -87,9 +87,9 @@ TEST(MathMetaPrim, ref_type_eigen_expression) {
8787
ref_type_t<decltype(a)&&> a_ref3 = m * 3;
8888

8989
Eigen::MatrixXd a_eval = a;
90-
expect_matrix_eq(a_ref1, a_eval);
91-
expect_matrix_eq(a_ref2, a_eval);
92-
expect_matrix_eq(a_ref3, a_eval);
90+
EXPECT_MATRIX_EQ(a_ref1, a_eval);
91+
EXPECT_MATRIX_EQ(a_ref2, a_eval);
92+
EXPECT_MATRIX_EQ(a_ref3, a_eval);
9393

9494
EXPECT_TRUE((
9595
std::is_same<plain_type_t<decltype(a)>, ref_type_t<decltype(a)>>::value));
@@ -115,14 +115,14 @@ TEST(MathMetaPrim, ref_type_for_opencl_for_opencl_non_eigen) {
115115
ref_type_for_opencl_t<const std::vector<double>> c_ref1 = c;
116116
ref_type_for_opencl_t<const std::vector<double>&> c_ref2 = c;
117117

118-
expect_std_vector_eq(a_ref1, a);
119-
expect_std_vector_eq(a_ref2, a);
120-
expect_std_vector_eq(a_ref3, a);
118+
EXPECT_STD_VECTOR_FLOAT_EQ(a_ref1, a);
119+
EXPECT_STD_VECTOR_FLOAT_EQ(a_ref2, a);
120+
EXPECT_STD_VECTOR_FLOAT_EQ(a_ref3, a);
121121
EXPECT_EQ(b_ref1, b);
122122
EXPECT_EQ(b_ref2, b);
123123
EXPECT_EQ(b_ref3, b);
124-
expect_std_vector_eq(c_ref1, c);
125-
expect_std_vector_eq(c_ref2, c);
124+
EXPECT_STD_VECTOR_FLOAT_EQ(c_ref1, c);
125+
EXPECT_STD_VECTOR_FLOAT_EQ(c_ref2, c);
126126
EXPECT_TRUE(std::is_lvalue_reference<ref_type_for_opencl_t<double>>::value);
127127
EXPECT_TRUE(std::is_lvalue_reference<ref_type_for_opencl_t<double&>>::value);
128128
EXPECT_FALSE(std::is_reference<ref_type_for_opencl_t<double&&>>::value);
@@ -155,17 +155,17 @@ TEST(MathMetaPrim, ref_type_for_opencl_eigen_contiguous) {
155155
ref_type_for_opencl_t<ContiguousMap&> c_ref2 = c;
156156
ref_type_for_opencl_t<ContiguousMap&&> c_ref3 = std::move(c2);
157157

158-
expect_matrix_eq(a_ref1, a);
159-
expect_matrix_eq(a_ref2, a);
160-
expect_matrix_eq(a_ref3, a);
158+
EXPECT_MATRIX_EQ(a_ref1, a);
159+
EXPECT_MATRIX_EQ(a_ref2, a);
160+
EXPECT_MATRIX_EQ(a_ref3, a);
161161

162-
expect_matrix_eq(b_ref1, b);
163-
expect_matrix_eq(b_ref2, b);
164-
expect_matrix_eq(b_ref3, b);
162+
EXPECT_MATRIX_EQ(b_ref1, b);
163+
EXPECT_MATRIX_EQ(b_ref2, b);
164+
EXPECT_MATRIX_EQ(b_ref3, b);
165165

166-
expect_matrix_eq(c_ref1, c);
167-
expect_matrix_eq(c_ref2, c);
168-
expect_matrix_eq(c_ref3, c);
166+
EXPECT_MATRIX_EQ(c_ref1, c);
167+
EXPECT_MATRIX_EQ(c_ref2, c);
168+
EXPECT_MATRIX_EQ(c_ref3, c);
169169
EXPECT_TRUE(
170170
(std::is_same<decltype(a), ref_type_for_opencl_t<decltype(a)&&>>::value));
171171
EXPECT_TRUE(
@@ -203,17 +203,17 @@ TEST(MathMetaPrim, ref_type_for_opencl_eigen_non_contiguous) {
203203
ref_type_for_opencl_t<Eigen::Ref<Eigen::MatrixXd>&> c_ref2 = c;
204204
ref_type_for_opencl_t<Eigen::Ref<Eigen::MatrixXd>&&> c_ref3 = std::move(c2);
205205

206-
expect_matrix_eq(a_ref1, a);
207-
expect_matrix_eq(a_ref2, a);
208-
expect_matrix_eq(a_ref3, a);
206+
EXPECT_MATRIX_EQ(a_ref1, a);
207+
EXPECT_MATRIX_EQ(a_ref2, a);
208+
EXPECT_MATRIX_EQ(a_ref3, a);
209209

210-
expect_matrix_eq(b_ref1, b);
211-
expect_matrix_eq(b_ref2, b);
212-
expect_matrix_eq(b_ref3, b);
210+
EXPECT_MATRIX_EQ(b_ref1, b);
211+
EXPECT_MATRIX_EQ(b_ref2, b);
212+
EXPECT_MATRIX_EQ(b_ref3, b);
213213

214-
expect_matrix_eq(c_ref1, c);
215-
expect_matrix_eq(c_ref2, c);
216-
expect_matrix_eq(c_ref3, c);
214+
EXPECT_MATRIX_EQ(c_ref1, c);
215+
EXPECT_MATRIX_EQ(c_ref2, c);
216+
EXPECT_MATRIX_EQ(c_ref3, c);
217217
EXPECT_TRUE((std::is_same<Eigen::MatrixXd,
218218
ref_type_for_opencl_t<decltype(a)&&>>::value));
219219
EXPECT_TRUE((std::is_same<Eigen::MatrixXd,
@@ -233,9 +233,9 @@ TEST(MathMetaPrim, ref_type_for_opencl_eigen_expression) {
233233
ref_type_for_opencl_t<decltype(a)&&> a_ref3 = m * 3;
234234

235235
Eigen::MatrixXd a_eval = a;
236-
expect_matrix_eq(a_ref1, a_eval);
237-
expect_matrix_eq(a_ref2, a_eval);
238-
expect_matrix_eq(a_ref3, a_eval);
236+
EXPECT_MATRIX_EQ(a_ref1, a_eval);
237+
EXPECT_MATRIX_EQ(a_ref2, a_eval);
238+
EXPECT_MATRIX_EQ(a_ref3, a_eval);
239239

240240
EXPECT_TRUE((std::is_same<plain_type_t<decltype(a)>,
241241
ref_type_for_opencl_t<decltype(a)>>::value));

0 commit comments

Comments
 (0)