Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
mock_value.cpp
Go to the documentation of this file.
1// -------------------------------------------------------//
2//
3// SHAMROCK code for hydrodynamics
4// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
5// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
6// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
7//
8// -------------------------------------------------------//
9
16#include "shamalgs/primitives/mock_value.hpp"
17#include <random>
18
19namespace shamalgs::primitives {
20
21 template<>
22 u8 mock_value(std::mt19937 &eng, u8 min_bound, u8 max_bound) {
23 std::uniform_int_distribution<u8> dist{min_bound, max_bound};
24 return dist(eng);
25 }
26
27 template<>
28 u16 mock_value(std::mt19937 &eng, u16 min_bound, u16 max_bound) {
29 std::uniform_int_distribution<u16> dist{min_bound, max_bound};
30 return dist(eng);
31 }
32
33 template<>
34 u32 mock_value(std::mt19937 &eng, u32 min_bound, u32 max_bound) {
35 std::uniform_int_distribution<u32> dist{min_bound, max_bound};
36 return dist(eng);
37 }
38
39 template<>
40 u64 mock_value(std::mt19937 &eng, u64 min_bound, u64 max_bound) {
41 std::uniform_int_distribution<u64> dist{min_bound, max_bound};
42 return dist(eng);
43 }
44
45 template<>
46 i8 mock_value(std::mt19937 &eng, i8 min_bound, i8 max_bound) {
47 std::uniform_int_distribution<i8> dist{min_bound, max_bound};
48 return dist(eng);
49 }
50
51 template<>
52 i16 mock_value(std::mt19937 &eng, i16 min_bound, i16 max_bound) {
53 std::uniform_int_distribution<i16> dist{min_bound, max_bound};
54 return dist(eng);
55 }
56
57 template<>
58 i32 mock_value(std::mt19937 &eng, i32 min_bound, i32 max_bound) {
59 std::uniform_int_distribution<i32> dist{min_bound, max_bound};
60 return dist(eng);
61 }
62
63 template<>
64 i64 mock_value(std::mt19937 &eng, i64 min_bound, i64 max_bound) {
65 std::uniform_int_distribution<i64> dist{min_bound, max_bound};
66 return dist(eng);
67 }
68
69 template<>
70 f32 mock_value(std::mt19937 &eng, f32 min_bound, f32 max_bound) {
71 std::uniform_real_distribution<f32> dist{min_bound, max_bound};
72 return dist(eng);
73 }
74
75 template<>
76 f64 mock_value(std::mt19937 &eng, f64 min_bound, f64 max_bound) {
77 std::uniform_real_distribution<f64> dist{min_bound, max_bound};
78 return dist(eng);
79 }
80
81#define X2(_arg_) \
82 template<> \
83 sycl::vec<_arg_, 2> mock_value( \
84 std::mt19937 &eng, sycl::vec<_arg_, 2> min_bound, sycl::vec<_arg_, 2> max_bound) { \
85 return { \
86 mock_value(eng, min_bound.x(), max_bound.x()), \
87 mock_value(eng, min_bound.y(), max_bound.y())}; \
88 }
89
90#define X3(_arg_) \
91 template<> \
92 sycl::vec<_arg_, 3> mock_value( \
93 std::mt19937 &eng, sycl::vec<_arg_, 3> min_bound, sycl::vec<_arg_, 3> max_bound) { \
94 return { \
95 mock_value(eng, min_bound.x(), max_bound.x()), \
96 mock_value(eng, min_bound.y(), max_bound.y()), \
97 mock_value(eng, min_bound.z(), max_bound.z())}; \
98 }
99
100#define X4(_arg_) \
101 template<> \
102 sycl::vec<_arg_, 4> mock_value( \
103 std::mt19937 &eng, sycl::vec<_arg_, 4> min_bound, sycl::vec<_arg_, 4> max_bound) { \
104 return { \
105 mock_value(eng, min_bound.x(), max_bound.x()), \
106 mock_value(eng, min_bound.y(), max_bound.y()), \
107 mock_value(eng, min_bound.z(), max_bound.z()), \
108 mock_value(eng, min_bound.w(), max_bound.w())}; \
109 }
110
111#define X8(_arg_) \
112 template<> \
113 sycl::vec<_arg_, 8> mock_value( \
114 std::mt19937 &eng, sycl::vec<_arg_, 8> min_bound, sycl::vec<_arg_, 8> max_bound) { \
115 return { \
116 mock_value(eng, min_bound.s0(), max_bound.s0()), \
117 mock_value(eng, min_bound.s1(), max_bound.s1()), \
118 mock_value(eng, min_bound.s2(), max_bound.s2()), \
119 mock_value(eng, min_bound.s3(), max_bound.s3()), \
120 mock_value(eng, min_bound.s4(), max_bound.s4()), \
121 mock_value(eng, min_bound.s5(), max_bound.s5()), \
122 mock_value(eng, min_bound.s6(), max_bound.s6()), \
123 mock_value(eng, min_bound.s7(), max_bound.s7())}; \
124 }
125
126#define X16(_arg_) \
127 template<> \
128 sycl::vec<_arg_, 16> mock_value( \
129 std::mt19937 &eng, sycl::vec<_arg_, 16> min_bound, sycl::vec<_arg_, 16> max_bound) { \
130 return { \
131 mock_value(eng, min_bound.s0(), max_bound.s0()), \
132 mock_value(eng, min_bound.s1(), max_bound.s1()), \
133 mock_value(eng, min_bound.s2(), max_bound.s2()), \
134 mock_value(eng, min_bound.s3(), max_bound.s3()), \
135 mock_value(eng, min_bound.s4(), max_bound.s4()), \
136 mock_value(eng, min_bound.s5(), max_bound.s5()), \
137 mock_value(eng, min_bound.s6(), max_bound.s6()), \
138 mock_value(eng, min_bound.s7(), max_bound.s7()), \
139 mock_value(eng, min_bound.s8(), max_bound.s8()), \
140 mock_value(eng, min_bound.s9(), max_bound.s9()), \
141 mock_value(eng, min_bound.sA(), max_bound.sA()), \
142 mock_value(eng, min_bound.sB(), max_bound.sB()), \
143 mock_value(eng, min_bound.sC(), max_bound.sC()), \
144 mock_value(eng, min_bound.sD(), max_bound.sD()), \
145 mock_value(eng, min_bound.sE(), max_bound.sE()), \
146 mock_value(eng, min_bound.sF(), max_bound.sF())}; \
147 }
148
149#define X(_arg_) X2(_arg_) X3(_arg_) X4(_arg_) X8(_arg_) X16(_arg_)
150
151 X(u64);
152 X(u32);
153 X(u16);
154 X(u8);
155
156 X(i64);
157 X(i32);
158 X(i16);
159 X(i8);
160
161 X(f64);
162 X(f32);
163 // X(f16);
164 // X(f8);
165
166#undef X
167#undef X2
168#undef X3
169#undef X4
170#undef X8
171#undef X16
172
173 template<>
174 u8 mock_value(std::mt19937_64 &eng, u8 min_bound, u8 max_bound) {
175 std::uniform_int_distribution<u8> dist{min_bound, max_bound};
176 return dist(eng);
177 }
178
179 template<>
180 u16 mock_value(std::mt19937_64 &eng, u16 min_bound, u16 max_bound) {
181 std::uniform_int_distribution<u16> dist{min_bound, max_bound};
182 return dist(eng);
183 }
184
185 template<>
186 u32 mock_value(std::mt19937_64 &eng, u32 min_bound, u32 max_bound) {
187 std::uniform_int_distribution<u32> dist{min_bound, max_bound};
188 return dist(eng);
189 }
190
191 template<>
192 u64 mock_value(std::mt19937_64 &eng, u64 min_bound, u64 max_bound) {
193 std::uniform_int_distribution<u64> dist{min_bound, max_bound};
194 return dist(eng);
195 }
196
197 template<>
198 i8 mock_value(std::mt19937_64 &eng, i8 min_bound, i8 max_bound) {
199 std::uniform_int_distribution<i8> dist{min_bound, max_bound};
200 return dist(eng);
201 }
202
203 template<>
204 i16 mock_value(std::mt19937_64 &eng, i16 min_bound, i16 max_bound) {
205 std::uniform_int_distribution<i16> dist{min_bound, max_bound};
206 return dist(eng);
207 }
208
209 template<>
210 i32 mock_value(std::mt19937_64 &eng, i32 min_bound, i32 max_bound) {
211 std::uniform_int_distribution<i32> dist{min_bound, max_bound};
212 return dist(eng);
213 }
214
215 template<>
216 i64 mock_value(std::mt19937_64 &eng, i64 min_bound, i64 max_bound) {
217 std::uniform_int_distribution<i64> dist{min_bound, max_bound};
218 return dist(eng);
219 }
220
221 template<>
222 f32 mock_value(std::mt19937_64 &eng, f32 min_bound, f32 max_bound) {
223 std::uniform_real_distribution<f32> dist{min_bound, max_bound};
224 return dist(eng);
225 }
226
227 template<>
228 f64 mock_value(std::mt19937_64 &eng, f64 min_bound, f64 max_bound) {
229 std::uniform_real_distribution<f64> dist{min_bound, max_bound};
230 return dist(eng);
231 }
232
233#define X2(_arg_) \
234 template<> \
235 sycl::vec<_arg_, 2> mock_value( \
236 std::mt19937_64 &eng, sycl::vec<_arg_, 2> min_bound, sycl::vec<_arg_, 2> max_bound) { \
237 return { \
238 mock_value(eng, min_bound.x(), max_bound.x()), \
239 mock_value(eng, min_bound.y(), max_bound.y())}; \
240 }
241
242#define X3(_arg_) \
243 template<> \
244 sycl::vec<_arg_, 3> mock_value( \
245 std::mt19937_64 &eng, sycl::vec<_arg_, 3> min_bound, sycl::vec<_arg_, 3> max_bound) { \
246 return { \
247 mock_value(eng, min_bound.x(), max_bound.x()), \
248 mock_value(eng, min_bound.y(), max_bound.y()), \
249 mock_value(eng, min_bound.z(), max_bound.z())}; \
250 }
251
252#define X4(_arg_) \
253 template<> \
254 sycl::vec<_arg_, 4> mock_value( \
255 std::mt19937_64 &eng, sycl::vec<_arg_, 4> min_bound, sycl::vec<_arg_, 4> max_bound) { \
256 return { \
257 mock_value(eng, min_bound.x(), max_bound.x()), \
258 mock_value(eng, min_bound.y(), max_bound.y()), \
259 mock_value(eng, min_bound.z(), max_bound.z()), \
260 mock_value(eng, min_bound.w(), max_bound.w())}; \
261 }
262
263#define X8(_arg_) \
264 template<> \
265 sycl::vec<_arg_, 8> mock_value( \
266 std::mt19937_64 &eng, sycl::vec<_arg_, 8> min_bound, sycl::vec<_arg_, 8> max_bound) { \
267 return { \
268 mock_value(eng, min_bound.s0(), max_bound.s0()), \
269 mock_value(eng, min_bound.s1(), max_bound.s1()), \
270 mock_value(eng, min_bound.s2(), max_bound.s2()), \
271 mock_value(eng, min_bound.s3(), max_bound.s3()), \
272 mock_value(eng, min_bound.s4(), max_bound.s4()), \
273 mock_value(eng, min_bound.s5(), max_bound.s5()), \
274 mock_value(eng, min_bound.s6(), max_bound.s6()), \
275 mock_value(eng, min_bound.s7(), max_bound.s7())}; \
276 }
277
278#define X16(_arg_) \
279 template<> \
280 sycl::vec<_arg_, 16> mock_value( \
281 std::mt19937_64 &eng, sycl::vec<_arg_, 16> min_bound, sycl::vec<_arg_, 16> max_bound) { \
282 return { \
283 mock_value(eng, min_bound.s0(), max_bound.s0()), \
284 mock_value(eng, min_bound.s1(), max_bound.s1()), \
285 mock_value(eng, min_bound.s2(), max_bound.s2()), \
286 mock_value(eng, min_bound.s3(), max_bound.s3()), \
287 mock_value(eng, min_bound.s4(), max_bound.s4()), \
288 mock_value(eng, min_bound.s5(), max_bound.s5()), \
289 mock_value(eng, min_bound.s6(), max_bound.s6()), \
290 mock_value(eng, min_bound.s7(), max_bound.s7()), \
291 mock_value(eng, min_bound.s8(), max_bound.s8()), \
292 mock_value(eng, min_bound.s9(), max_bound.s9()), \
293 mock_value(eng, min_bound.sA(), max_bound.sA()), \
294 mock_value(eng, min_bound.sB(), max_bound.sB()), \
295 mock_value(eng, min_bound.sC(), max_bound.sC()), \
296 mock_value(eng, min_bound.sD(), max_bound.sD()), \
297 mock_value(eng, min_bound.sE(), max_bound.sE()), \
298 mock_value(eng, min_bound.sF(), max_bound.sF())}; \
299 }
300
301#define X(_arg_) X2(_arg_) X3(_arg_) X4(_arg_) X8(_arg_) X16(_arg_)
302
303 X(u64);
304 X(u32);
305 X(u16);
306 X(u8);
307
308 X(i64);
309 X(i32);
310 X(i16);
311 X(i8);
312
313 X(f64);
314 X(f32);
315 // X(f16);
316 // X(f8);
317
318#undef X
319#undef X2
320#undef X3
321#undef X4
322#undef X8
323#undef X16
324
325} // namespace shamalgs::primitives
f64
double f64
Alias for double.
Definition aliases_float.hpp:20
f32
float f32
Alias for float.
Definition aliases_float.hpp:19
i8
std::int8_t i8
8 bit integer
Definition aliases_int.hpp:25
u8
std::uint8_t u8
8 bit unsigned integer
Definition aliases_int.hpp:29
u32
std::uint32_t u32
32 bit unsigned integer
Definition aliases_int.hpp:27
u64
std::uint64_t u64
64 bit unsigned integer
Definition aliases_int.hpp:26
u16
std::uint16_t u16
16 bit unsigned integer
Definition aliases_int.hpp:28
i16
std::int16_t i16
16 bit integer
Definition aliases_int.hpp:24
i64
std::int64_t i64
64 bit integer
Definition aliases_int.hpp:22
i32
std::int32_t i32
32 bit integer
Definition aliases_int.hpp:23
mock_value.hpp
Utility functions for generating random mock values.
shamalgs::primitives
namespace for primitive algorithm (e.g. sort, scan, reductions, ...)
Definition ImplControl.hpp:23
shamalgs::primitives::mock_value
T mock_value(Engine &eng, T min_bound, T max_bound)
Generates a random mock value within specified bounds.
Generated on Wed May 13 2026 13:21:48 for Shamrock by doxygen 1.9.8