Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
CoordRangeTransform.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
17#include "shambase/exception.hpp"
18#include "shambackends/fmt_bindings/fmt_defs.hpp"
19#include "shamcomm/logs.hpp"
20#include "shammath/CoordRangeTransform.hpp"
21#include <stdexcept>
22
23namespace shammath {
24
25 void check_divisor_throw(u64_3 val, u64_3 divisor) {
26 bool cmp_x = val.x() % divisor.x() == 0;
27 bool cmp_y = val.y() % divisor.y() == 0;
28 bool cmp_z = val.z() % divisor.z() == 0;
29
30 if (!cmp_x) {
31 throw shambase::make_except_with_loc<std::invalid_argument>(
32 "the divisor does not divide the value on component x\n"
33 " val = ("
34 + std::to_string(val.x()) + ", " + std::to_string(val.y()) + ", "
35 + std::to_string(val.z()) + ")\n" + " divisor = (" + std::to_string(divisor.x())
36 + ", " + std::to_string(divisor.y()) + ", " + std::to_string(divisor.z()) + ")\n");
37 }
38
39 if (!cmp_y) {
40 throw shambase::make_except_with_loc<std::invalid_argument>(
41 "the divisor does not divide the value on component y\n"
42 " val = ("
43 + std::to_string(val.x()) + ", " + std::to_string(val.y()) + ", "
44 + std::to_string(val.z()) + ")\n" + " divisor = (" + std::to_string(divisor.x())
45 + ", " + std::to_string(divisor.y()) + ", " + std::to_string(divisor.z()) + ")\n");
46 }
47
48 if (!cmp_z) {
49 throw shambase::make_except_with_loc<std::invalid_argument>(
50 "the divisor does not divide the value on component z\n"
51 " val = ("
52 + std::to_string(val.x()) + ", " + std::to_string(val.y()) + ", "
53 + std::to_string(val.z()) + ")\n" + " divisor = (" + std::to_string(divisor.x())
54 + ", " + std::to_string(divisor.y()) + ", " + std::to_string(divisor.z()) + ")\n");
55 }
56 }
57
58 template<class Ta, class Tb>
59 void check_divisor_throw(Ta val, Tb divisor) {
60 check_divisor_throw(val.template convert<u64>(), divisor.template convert<u64>());
61 }
62
63 template<class Tsource, class Tdest>
64 void CoordRangeTransform<Tsource, Tdest>::print_transform() const {
65 if (mode == multiply) {
66 shamlog_debug_ln(
67 "CoordRangeTransform", "multiply:", fact, source_coord_min, dest_coord_min);
68 } else {
69 shamlog_debug_ln(
70 "CoordRangeTransform", "divide :", fact, source_coord_min, dest_coord_min);
71 }
72 }
73
75 // constructor implementation
77
78 template<>
79 CoordRangeTransform<u64_3, f32_3>::CoordRangeTransform(
80 CoordRange<u64_3> source_range, CoordRange<f32_3> dest_range)
81 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
82
83 source_range.check_throw_ranges();
84 dest_range.check_throw_ranges();
85
86 mode = multiply;
87
88 u64_3 source_delt = source_range.delt();
89 f32_3 dest_delt = dest_range.delt();
90
91 f32_3 source_sz_conv = source_delt.convert<f32>();
92
93 fact = dest_delt / source_sz_conv;
94 }
95
96 template<>
97 CoordRangeTransform<u64_3, f64_3>::CoordRangeTransform(
98 CoordRange<u64_3> source_range, CoordRange<f64_3> dest_range)
99 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
100
101 source_range.check_throw_ranges();
102 dest_range.check_throw_ranges();
103
104 mode = multiply;
105
106 u64_3 source_delt = source_range.delt();
107 f64_3 dest_delt = dest_range.delt();
108
109 f64_3 source_sz_conv = source_delt.convert<f64>();
110
111 fact = dest_delt / source_sz_conv;
112 }
113
114 template<>
115 CoordRangeTransform<u32_3, f32_3>::CoordRangeTransform(
116 CoordRange<u32_3> source_range, CoordRange<f32_3> dest_range)
117 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
118
119 source_range.check_throw_ranges();
120 dest_range.check_throw_ranges();
121
122 mode = multiply;
123
124 u32_3 source_delt = source_range.delt();
125 f32_3 dest_delt = dest_range.delt();
126
127 f32_3 source_sz_conv = source_delt.convert<f32>();
128
129 fact = dest_delt / source_sz_conv;
130 }
131
132 template<>
133 CoordRangeTransform<u32_3, f64_3>::CoordRangeTransform(
134 CoordRange<u32_3> source_range, CoordRange<f64_3> dest_range)
135 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
136
137 source_range.check_throw_ranges();
138 dest_range.check_throw_ranges();
139
140 mode = multiply;
141
142 u32_3 source_delt = source_range.delt();
143 f64_3 dest_delt = dest_range.delt();
144
145 f64_3 source_sz_conv = source_delt.convert<f64>();
146
147 fact = dest_delt / source_sz_conv;
148 }
149
150 template<>
151 CoordRangeTransform<u16_3, f32_3>::CoordRangeTransform(
152 CoordRange<u16_3> source_range, CoordRange<f32_3> dest_range)
153 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
154
155 source_range.check_throw_ranges();
156 dest_range.check_throw_ranges();
157
158 mode = multiply;
159
160 u16_3 source_delt = source_range.delt();
161 f32_3 dest_delt = dest_range.delt();
162
163 f32_3 source_sz_conv = source_delt.convert<f32>();
164
165 fact = dest_delt / source_sz_conv;
166 }
167
168 template<>
169 CoordRangeTransform<u16_3, f64_3>::CoordRangeTransform(
170 CoordRange<u16_3> source_range, CoordRange<f64_3> dest_range)
171 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
172
173 source_range.check_throw_ranges();
174 dest_range.check_throw_ranges();
175
176 mode = multiply;
177
178 u16_3 source_delt = source_range.delt();
179 f64_3 dest_delt = dest_range.delt();
180
181 f64_3 source_sz_conv = source_delt.convert<f64>();
182
183 fact = dest_delt / source_sz_conv;
184 }
185
186 template<>
187 CoordRangeTransform<u64_3, u64_3>::CoordRangeTransform(
188 CoordRange<u64_3> source_range, CoordRange<u64_3> dest_range)
189 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
190
191 source_range.check_throw_ranges();
192 dest_range.check_throw_ranges();
193
194 u64_3 source_delt = source_range.delt();
195 u64_3 dest_delt = dest_range.delt();
196
197 bool cmp_x = dest_delt.x() >= source_delt.x();
198 bool cmp_y = dest_delt.y() >= source_delt.y();
199 bool cmp_z = dest_delt.z() >= source_delt.z();
200
201 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
202
203 bool obj_greater_than_patch = cmp_x;
204
205 if (obj_greater_than_patch) {
206 check_divisor_throw(dest_delt, source_delt);
207 mode = multiply;
208 fact = dest_delt / source_delt;
209 } else {
210 check_divisor_throw(source_delt, dest_delt);
211 mode = divide;
212 fact = source_delt / dest_delt;
213 }
214
215 } else {
216 throw shambase::make_except_with_loc<std::invalid_argument>(
217 "the range comparison are not the same");
218 }
219 }
220
221 template<>
222 CoordRangeTransform<i64_3, u64_3>::CoordRangeTransform(
223 CoordRange<i64_3> source_range, CoordRange<u64_3> dest_range)
224 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
225
226 source_range.check_throw_ranges();
227 dest_range.check_throw_ranges();
228
229 u64_3 source_delt = source_range.delt().convert<u64>();
230 u64_3 dest_delt = dest_range.delt();
231
232 bool cmp_x = dest_delt.x() >= source_delt.x();
233 bool cmp_y = dest_delt.y() >= source_delt.y();
234 bool cmp_z = dest_delt.z() >= source_delt.z();
235
236 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
237
238 bool obj_greater_than_patch = cmp_x;
239
240 if (obj_greater_than_patch) {
241 check_divisor_throw(dest_delt, source_delt);
242 mode = multiply;
243 fact = dest_delt / source_delt;
244 } else {
245 check_divisor_throw(source_delt, dest_delt);
246 mode = divide;
247 fact = source_delt / dest_delt;
248 }
249
250 } else {
251 throw shambase::make_except_with_loc<std::invalid_argument>(
252 "the range comparison are not the same");
253 }
254 }
255
256 template<>
257 CoordRangeTransform<u64_3, i64_3>::CoordRangeTransform(
258 CoordRange<u64_3> source_range, CoordRange<i64_3> dest_range)
259 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
260
261 source_range.check_throw_ranges();
262 dest_range.check_throw_ranges();
263
264 i64_3 source_delt = source_range.delt().convert<i64>();
265 i64_3 dest_delt = dest_range.delt();
266
267 bool cmp_x = dest_delt.x() >= source_delt.x();
268 bool cmp_y = dest_delt.y() >= source_delt.y();
269 bool cmp_z = dest_delt.z() >= source_delt.z();
270
271 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
272
273 bool obj_greater_than_patch = cmp_x;
274
275 if (obj_greater_than_patch) {
276 check_divisor_throw(dest_delt, source_delt);
277 mode = multiply;
278 fact = dest_delt / source_delt;
279 } else {
280 check_divisor_throw(source_delt, dest_delt);
281 mode = divide;
282 fact = source_delt / dest_delt;
283 }
284
285 } else {
286 throw shambase::make_except_with_loc<std::invalid_argument>(
287 "the range comparison are not the same");
288 }
289 }
290
291 template<>
292 CoordRangeTransform<u64_3, u32_3>::CoordRangeTransform(
293 CoordRange<u64_3> source_range, CoordRange<u32_3> dest_range)
294 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
295
296 source_range.check_throw_ranges();
297 dest_range.check_throw_ranges();
298
299 u64_3 source_delt = source_range.delt();
300 u32_3 dest_delt = dest_range.delt();
301
302 bool cmp_x = dest_delt.x() >= source_delt.x();
303 bool cmp_y = dest_delt.y() >= source_delt.y();
304 bool cmp_z = dest_delt.z() >= source_delt.z();
305
306 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
307
308 bool obj_greater_than_patch = cmp_x;
309
310 if (obj_greater_than_patch) {
311 check_divisor_throw(dest_delt, source_delt);
312 mode = multiply;
313 fact = (dest_delt.convert<u64>() / source_delt).convert<u32>();
314 } else {
315 check_divisor_throw(source_delt, dest_delt);
316 mode = divide;
317 fact = (source_delt / dest_delt.convert<u64>()).convert<u32>();
318 }
319
320 } else {
321 throw shambase::make_except_with_loc<std::invalid_argument>(
322 "the range comparison are not the same");
323 }
324 }
325
326 template<>
327 CoordRangeTransform<u64_3, i32_3>::CoordRangeTransform(
328 CoordRange<u64_3> source_range, CoordRange<i32_3> dest_range)
329 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
330
331 source_range.check_throw_ranges();
332 dest_range.check_throw_ranges();
333
334 u64_3 source_delt = source_range.delt();
335 i32_3 dest_delt = dest_range.delt();
336
337 bool cmp_x = dest_delt.x() >= source_delt.x();
338 bool cmp_y = dest_delt.y() >= source_delt.y();
339 bool cmp_z = dest_delt.z() >= source_delt.z();
340
341 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
342
343 bool obj_greater_than_patch = cmp_x;
344
345 if (obj_greater_than_patch) {
346 check_divisor_throw(dest_delt, source_delt);
347 mode = multiply;
348 fact = (dest_delt.convert<u64>() / source_delt).convert<i32>();
349 } else {
350 check_divisor_throw(source_delt, dest_delt);
351 mode = divide;
352 fact = (source_delt / dest_delt.convert<u64>()).convert<i32>();
353 }
354
355 } else {
356 throw shambase::make_except_with_loc<std::invalid_argument>(
357 "the range comparison are not the same");
358 }
359 }
360
361 template<>
362 CoordRangeTransform<u32_3, u16_3>::CoordRangeTransform(
363 CoordRange<u32_3> source_range, CoordRange<u16_3> dest_range)
364 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
365
366 source_range.check_throw_ranges();
367 dest_range.check_throw_ranges();
368
369 u32_3 source_delt = source_range.delt();
370 u16_3 dest_delt = dest_range.delt();
371
372 bool cmp_x = dest_delt.x() >= source_delt.x();
373 bool cmp_y = dest_delt.y() >= source_delt.y();
374 bool cmp_z = dest_delt.z() >= source_delt.z();
375
376 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
377
378 bool obj_greater_than_patch = cmp_x;
379
380 if (obj_greater_than_patch) {
381 check_divisor_throw(dest_delt, source_delt);
382 mode = multiply;
383 fact = (dest_delt.convert<u32>() / source_delt).convert<u16>();
384 } else {
385 check_divisor_throw(source_delt, dest_delt);
386 mode = divide;
387 fact = (source_delt / dest_delt.convert<u32>()).convert<u16>();
388 }
389
390 } else {
391 throw shambase::make_except_with_loc<std::invalid_argument>(
392 "the range comparison are not the same");
393 }
394 }
395
396 template<>
397 CoordRangeTransform<u32_3, u64_3>::CoordRangeTransform(
398 CoordRange<u32_3> source_range, CoordRange<u64_3> dest_range)
399 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
400
401 source_range.check_throw_ranges();
402 dest_range.check_throw_ranges();
403
404 u32_3 source_delt = source_range.delt();
405 u64_3 dest_delt = dest_range.delt();
406
407 bool cmp_x = dest_delt.x() >= source_delt.x();
408 bool cmp_y = dest_delt.y() >= source_delt.y();
409 bool cmp_z = dest_delt.z() >= source_delt.z();
410
411 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
412
413 bool obj_greater_than_patch = cmp_x;
414
415 if (obj_greater_than_patch) {
416 check_divisor_throw(dest_delt, source_delt);
417 mode = multiply;
418 fact = (dest_delt / source_delt.convert<u64>());
419 } else {
420 check_divisor_throw(source_delt, dest_delt);
421 mode = divide;
422 fact = (source_delt.convert<u64>() / dest_delt);
423 }
424
425 } else {
426 throw shambase::make_except_with_loc<std::invalid_argument>(
427 "the range comparison are not the same");
428 }
429 }
430
431 template<>
432 CoordRangeTransform<u32_3, i64_3>::CoordRangeTransform(
433 CoordRange<u32_3> source_range, CoordRange<i64_3> dest_range)
434 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
435
436 source_range.check_throw_ranges();
437 dest_range.check_throw_ranges();
438
439 u32_3 source_delt = source_range.delt();
440 i64_3 dest_delt = dest_range.delt();
441
442 bool cmp_x = dest_delt.x() >= source_delt.x();
443 bool cmp_y = dest_delt.y() >= source_delt.y();
444 bool cmp_z = dest_delt.z() >= source_delt.z();
445
446 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
447
448 bool obj_greater_than_patch = cmp_x;
449
450 if (obj_greater_than_patch) {
451 check_divisor_throw(dest_delt, source_delt);
452 mode = multiply;
453 fact = (dest_delt / source_delt.convert<i64>());
454 } else {
455 check_divisor_throw(source_delt, dest_delt);
456 mode = divide;
457 fact = (source_delt.convert<i64>() / dest_delt);
458 }
459
460 } else {
461 throw shambase::make_except_with_loc<std::invalid_argument>(
462 "the range comparison are not the same");
463 }
464 }
465
466 template<>
467 CoordRangeTransform<u32_3, i32_3>::CoordRangeTransform(
468 CoordRange<u32_3> source_range, CoordRange<i32_3> dest_range)
469 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
470
471 source_range.check_throw_ranges();
472 dest_range.check_throw_ranges();
473
474 u32_3 source_delt = source_range.delt();
475 i32_3 dest_delt = dest_range.delt();
476
477 bool cmp_x = dest_delt.x() >= source_delt.x();
478 bool cmp_y = dest_delt.y() >= source_delt.y();
479 bool cmp_z = dest_delt.z() >= source_delt.z();
480
481 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
482
483 bool obj_greater_than_patch = cmp_x;
484
485 if (obj_greater_than_patch) {
486 check_divisor_throw(dest_delt, source_delt);
487 mode = multiply;
488 fact = (dest_delt / source_delt.convert<i32>());
489 } else {
490 check_divisor_throw(source_delt, dest_delt);
491 mode = divide;
492 fact = (source_delt.convert<i32>() / dest_delt);
493 }
494
495 } else {
496 throw shambase::make_except_with_loc<std::invalid_argument>(
497 "the range comparison are not the same");
498 }
499 }
500
501 template<>
502 CoordRangeTransform<u16_3, u64_3>::CoordRangeTransform(
503 CoordRange<u16_3> source_range, CoordRange<u64_3> dest_range)
504 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
505
506 source_range.check_throw_ranges();
507 dest_range.check_throw_ranges();
508
509 u16_3 source_delt = source_range.delt();
510 u64_3 dest_delt = dest_range.delt();
511
512 bool cmp_x = dest_delt.x() >= source_delt.x();
513 bool cmp_y = dest_delt.y() >= source_delt.y();
514 bool cmp_z = dest_delt.z() >= source_delt.z();
515
516 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
517
518 bool obj_greater_than_patch = cmp_x;
519
520 if (obj_greater_than_patch) {
521 check_divisor_throw(dest_delt, source_delt);
522 mode = multiply;
523 fact = (dest_delt / source_delt.convert<u64>());
524 } else {
525 check_divisor_throw(source_delt, dest_delt);
526 mode = divide;
527 fact = (source_delt.convert<u64>() / dest_delt);
528 }
529
530 } else {
531 throw shambase::make_except_with_loc<std::invalid_argument>(
532 "the range comparison are not the same");
533 }
534 }
535
536 template<>
537 CoordRangeTransform<u16_3, u32_3>::CoordRangeTransform(
538 CoordRange<u16_3> source_range, CoordRange<u32_3> dest_range)
539 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
540
541 source_range.check_throw_ranges();
542 dest_range.check_throw_ranges();
543
544 u16_3 source_delt = source_range.delt();
545 u32_3 dest_delt = dest_range.delt();
546
547 bool cmp_x = dest_delt.x() >= source_delt.x();
548 bool cmp_y = dest_delt.y() >= source_delt.y();
549 bool cmp_z = dest_delt.z() >= source_delt.z();
550
551 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
552
553 bool obj_greater_than_patch = cmp_x;
554
555 if (obj_greater_than_patch) {
556 check_divisor_throw(dest_delt, source_delt);
557 mode = multiply;
558 fact = (dest_delt / source_delt.convert<u32>());
559 } else {
560 check_divisor_throw(source_delt, dest_delt);
561 mode = divide;
562 fact = (source_delt.convert<u32>() / dest_delt);
563 }
564
565 } else {
566 throw shambase::make_except_with_loc<std::invalid_argument>(
567 "the range comparison are not the same");
568 }
569 }
570
571 template<>
572 CoordRangeTransform<u16_3, i32_3>::CoordRangeTransform(
573 CoordRange<u16_3> source_range, CoordRange<i32_3> dest_range)
574 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
575
576 source_range.check_throw_ranges();
577 dest_range.check_throw_ranges();
578
579 u16_3 source_delt = source_range.delt();
580 i32_3 dest_delt = dest_range.delt();
581
582 bool cmp_x = dest_delt.x() >= source_delt.x();
583 bool cmp_y = dest_delt.y() >= source_delt.y();
584 bool cmp_z = dest_delt.z() >= source_delt.z();
585
586 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
587
588 bool obj_greater_than_patch = cmp_x;
589
590 if (obj_greater_than_patch) {
591 check_divisor_throw(dest_delt, source_delt);
592 mode = multiply;
593 fact = (dest_delt / source_delt.convert<i32>());
594 } else {
595 check_divisor_throw(source_delt, dest_delt);
596 mode = divide;
597 fact = (source_delt.convert<i32>() / dest_delt);
598 }
599
600 } else {
601 throw shambase::make_except_with_loc<std::invalid_argument>(
602 "the range comparison are not the same");
603 }
604 }
605
606 template<>
607 CoordRangeTransform<u16_3, i64_3>::CoordRangeTransform(
608 CoordRange<u16_3> source_range, CoordRange<i64_3> dest_range)
609 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
610
611 source_range.check_throw_ranges();
612 dest_range.check_throw_ranges();
613
614 u16_3 source_delt = source_range.delt();
615 i64_3 dest_delt = dest_range.delt();
616
617 bool cmp_x = dest_delt.x() >= source_delt.x();
618 bool cmp_y = dest_delt.y() >= source_delt.y();
619 bool cmp_z = dest_delt.z() >= source_delt.z();
620
621 if ((cmp_x == cmp_y) && (cmp_z == cmp_y)) {
622
623 bool obj_greater_than_patch = cmp_x;
624
625 if (obj_greater_than_patch) {
626 check_divisor_throw(dest_delt, source_delt);
627 mode = multiply;
628 fact = (dest_delt / source_delt.convert<i64>());
629 } else {
630 check_divisor_throw(source_delt, dest_delt);
631 mode = divide;
632 fact = (source_delt.convert<i64>() / dest_delt);
633 }
634
635 } else {
636 throw shambase::make_except_with_loc<std::invalid_argument>(
637 "the range comparison are not the same");
638 }
639 }
640
641 template<>
642 CoordRangeTransform<u64_3, u16_3>::CoordRangeTransform(
643 CoordRange<u64_3> source_range, CoordRange<u16_3> dest_range)
644 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
645
646 throw shambase::make_except_with_loc<std::invalid_argument>(
647 "this coordinate conversion mode is not implemented");
648 }
649
650 template<>
651 CoordRangeTransform<u32_3, u32_3>::CoordRangeTransform(
652 CoordRange<u32_3> source_range, CoordRange<u32_3> dest_range)
653 : source_coord_min(source_range.lower), dest_coord_min(dest_range.lower) {
654
655 throw shambase::make_except_with_loc<std::invalid_argument>(
656 "this coordinate conversion mode is not implemented");
657 }
658
659 template class CoordRangeTransform<u64_3, f32_3>;
660 template class CoordRangeTransform<u64_3, f64_3>;
661 template class CoordRangeTransform<u64_3, u64_3>;
662 template class CoordRangeTransform<u64_3, u32_3>;
663 template class CoordRangeTransform<u64_3, i64_3>;
664 template class CoordRangeTransform<u64_3, i32_3>;
665 template class CoordRangeTransform<u64_3, u16_3>;
666
667 template class CoordRangeTransform<u32_3, f32_3>;
668 template class CoordRangeTransform<u32_3, f64_3>;
669 template class CoordRangeTransform<u32_3, u64_3>;
670 template class CoordRangeTransform<u32_3, u32_3>;
671 template class CoordRangeTransform<u32_3, i64_3>;
672 template class CoordRangeTransform<u32_3, i32_3>;
673 template class CoordRangeTransform<u32_3, u16_3>;
674
675 template class CoordRangeTransform<u16_3, f32_3>;
676 template class CoordRangeTransform<u16_3, f64_3>;
677 template class CoordRangeTransform<u16_3, u64_3>;
678 template class CoordRangeTransform<u16_3, u32_3>;
679 template class CoordRangeTransform<u16_3, i64_3>;
680 template class CoordRangeTransform<u16_3, i32_3>;
681 template class CoordRangeTransform<u16_3, u16_3>;
682
683} // namespace shammath
f64
double f64
Alias for double.
Definition aliases_float.hpp:20
f32
float f32
Alias for float.
Definition aliases_float.hpp:19
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
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
exception.hpp
This header file contains utility functions related to exception handling in the code.
fmt_defs.hpp
Define the fmt formatters for sycl::vec.
shambase::throw_with_loc
void throw_with_loc(std::string message, SourceLocation loc=SourceLocation{})
Throw an exception and append the source location to it.
Definition exception.hpp:132
shammath
namespace for math utility
Definition AABB.hpp:26
Generated on Wed May 13 2026 13:21:49 for Shamrock by doxygen 1.9.8