5#ifndef GKO_PUBLIC_CORE_BASE_TYPES_HPP_
6#define GKO_PUBLIC_CORE_BASE_TYPES_HPP_
20#include <ginkgo/config.hpp>
21#include <ginkgo/core/base/half.hpp>
25#include <hip/hip_runtime.h>
30#if defined(__CUDACC__) || defined(__HIPCC__)
31#define GKO_ATTRIBUTES __host__ __device__
32#define GKO_INLINE __forceinline__
33#define GKO_RESTRICT __restrict__
36#define GKO_INLINE inline
42#if defined(__CUDACC__)
43#define GKO_DEVICE_ERROR_TYPE cudaError_t
44#define GKO_DEVICE_ERROR_INVALID cudaErrorInvalidValue
45#define GKO_DEVICE_NO_ERROR cudaSuccess
46#elif defined(__HIPCC__)
47#define GKO_DEVICE_ERROR_TYPE hipError_t
48#define GKO_DEVICE_ERROR_INVALID hipErrorInvalidValue
49#define GKO_DEVICE_NO_ERROR hipSuccess
51#define GKO_DEVICE_ERROR_TYPE int
52#define GKO_DEVICE_ERROR_INVALID 1
53#define GKO_DEVICE_NO_ERROR 0
57#define GKO_ASSERT(condition) assert(condition)
62#define GKO_DEPRECATED(_msg) [[deprecated(_msg)]]
64#define GKO_BEGIN_DISABLE_DEPRECATION_WARNINGS _Pragma("diag_suppress 1445")
65#define GKO_END_DISABLE_DEPRECATION_WARNINGS _Pragma("diag_warning 1445")
66#elif defined(__GNUC__) || defined(__clang__)
67#define GKO_BEGIN_DISABLE_DEPRECATION_WARNINGS \
68 _Pragma("GCC diagnostic push") \
69 _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
70#define GKO_END_DISABLE_DEPRECATION_WARNINGS _Pragma("GCC diagnostic pop")
71#elif defined(_MSC_VER)
72#define GKO_BEGIN_DISABLE_DEPRECATION_WARNINGS \
73 _Pragma("warning(push)") \
74 _Pragma("warning(disable : 5211 4973 4974 4996)")
75#define GKO_END_DISABLE_DEPRECATION_WARNINGS _Pragma("warning(pop)")
77#define GKO_BEGIN_DISABLE_DEPRECATION_WARNINGS
78#define GKO_END_DISABLE_DEPRECATION_WARNINGS
188template <
typename... Args>
191template <
typename First,
typename... Args>
193 :
public std::conditional<std::is_integral<std::decay_t<First>>::value,
194 are_all_integral<Args...>,
195 std::false_type>::type {};
246 static constexpr auto nonpreserving_bits = 4u;
247 static constexpr auto preserving_bits =
249 static constexpr auto nonpreserving_mask =
251 static constexpr auto preserving_mask =
252 storage_type{(0x1 << preserving_bits) - 1} << nonpreserving_bits;
271 : data_((GKO_ASSERT(preserving < (0x1 << preserving_bits) - 1),
272 GKO_ASSERT(nonpreserving < (0x1 << nonpreserving_bits) - 1),
273 (preserving << nonpreserving_bits) | nonpreserving))
293 return (data_ & preserving_mask) >> nonpreserving_bits;
303 return data_ & nonpreserving_mask;
333 min(x.data_ & preserving_mask, y.data_ & preserving_mask) |
334 min(x.data_ & nonpreserving_mask, y.data_ & nonpreserving_mask));
345 return x < y ? x : y;
364 return static_cast<st
>(x) ==
static_cast<st
>(y);
380 return static_cast<st
>(x) !=
static_cast<st
>(y);
396#define GKO_ENABLE_FOR_ALL_EXECUTORS(_enable_macro) \
397 _enable_macro(OmpExecutor, omp); \
398 _enable_macro(HipExecutor, hip); \
399 _enable_macro(DpcppExecutor, dpcpp); \
400 _enable_macro(CudaExecutor, cuda)
404#if GINKGO_ENABLE_HALF && (!defined(__CUDA_ARCH__) || __CUDA_ARCH__ >= 530)
405#define GKO_ADAPT_HF(_macro) _macro
407#define GKO_ADAPT_HF(_macro) \
408 static_assert(true, \
409 "This assert is used to counter the false positive extra " \
410 "semi-colon warnings")
422#if GINKGO_DPCPP_SINGLE_MODE
423#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_BASE(_macro) \
424 template _macro(float); \
426 _macro(double) GKO_NOT_IMPLEMENTED
428#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_BASE(_macro) \
429 template _macro(float); \
430 template _macro(double)
433#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE(_macro) \
434 GKO_ADAPT_HF(template _macro(half)); \
435 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_BASE(_macro)
446#if GINKGO_DPCPP_SINGLE_MODE
447#define GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_BASE(_macro) \
448 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_BASE(_macro); \
449 template _macro(std::complex<float>); \
451 _macro(std::complex<double>) GKO_NOT_IMPLEMENTED
453#define GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_BASE(_macro) \
454 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_BASE(_macro); \
455 template _macro(std::complex<float>); \
456 template _macro(std::complex<double>)
459#define GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(_macro) \
460 GKO_ADAPT_HF(template _macro(half)); \
461 GKO_ADAPT_HF(template _macro(std::complex<half>)); \
462 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_BASE(_macro)
468#define GKO_INDIRECT(...) __VA_ARGS__
481#if GINKGO_DPCPP_SINGLE_MODE
482#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_VARGS_BASE(_macro, \
484 template GKO_INDIRECT(_macro(float, __VA_ARGS__)); \
486 GKO_INDIRECT(_macro(double, __VA_ARGS__)) \
489#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_VARGS_BASE(_macro, \
491 template GKO_INDIRECT(_macro(float, __VA_ARGS__)); \
492 template GKO_INDIRECT(_macro(double, __VA_ARGS__))
495#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_VARGS(_macro, ...) \
496 GKO_INDIRECT(GKO_ADAPT_HF(template _macro(half, __VA_ARGS__))); \
497 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_VARGS_BASE(_macro, \
511#if GINKGO_DPCPP_SINGLE_MODE
512#define GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_VARGS_BASE(_macro, ...) \
513 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_VARGS_BASE(_macro, \
515 template GKO_INDIRECT(_macro(std::complex<float>, __VA_ARGS__)); \
517 GKO_INDIRECT(_macro(std::complex<double>, __VA_ARGS__)) \
520#define GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_VARGS_BASE(_macro, ...) \
521 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_TYPE_VARGS_BASE(_macro, \
523 template GKO_INDIRECT(_macro(std::complex<float>, __VA_ARGS__)); \
524 template GKO_INDIRECT(_macro(std::complex<double>, __VA_ARGS__))
527#define GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_VARGS(_macro, ...) \
528 GKO_INDIRECT(GKO_ADAPT_HF(template _macro(half, __VA_ARGS__))); \
530 GKO_ADAPT_HF(template _macro(std::complex<half>, __VA_ARGS__))); \
531 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_VARGS_BASE(_macro, __VA_ARGS__)
544#if GINKGO_DPCPP_SINGLE_MODE
545#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_SCALAR_TYPE_BASE(_macro) \
546 template _macro(float, float); \
548 _macro(double, double) GKO_NOT_IMPLEMENTED; \
549 template _macro(std::complex<float>, std::complex<float>); \
551 _macro(std::complex<double>, std::complex<double>) GKO_NOT_IMPLEMENTED; \
552 template _macro(std::complex<float>, float); \
554 _macro(std::complex<double>, double) GKO_NOT_IMPLEMENTED;
556#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_SCALAR_TYPE_BASE(_macro) \
557 template _macro(float, float); \
558 template _macro(double, double); \
559 template _macro(std::complex<float>, std::complex<float>); \
560 template _macro(std::complex<double>, std::complex<double>); \
561 template _macro(std::complex<float>, float); \
562 template _macro(std::complex<double>, double)
565#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_SCALAR_TYPE(_macro) \
566 GKO_INSTANTIATE_FOR_EACH_VALUE_AND_SCALAR_TYPE_BASE(_macro); \
567 GKO_ADAPT_HF(template _macro(half, half)); \
568 GKO_ADAPT_HF(template _macro(std::complex<half>, std::complex<half>)); \
569 GKO_ADAPT_HF(template _macro(std::complex<half>, half))
580#define GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(_macro) \
581 template _macro(int32); \
582 template _macro(int64)
594#if GINKGO_DPCPP_SINGLE_MODE
595#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_INDEX_TYPE_BASE(_macro) \
596 template _macro(float, int32); \
598 _macro(double, int32) GKO_NOT_IMPLEMENTED; \
599 template _macro(float, int64); \
601 _macro(double, int64) GKO_NOT_IMPLEMENTED
603#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_INDEX_TYPE_BASE(_macro) \
604 template _macro(float, int32); \
605 template _macro(double, int32); \
606 template _macro(float, int64); \
607 template _macro(double, int64)
609#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_INDEX_TYPE(_macro) \
610 GKO_ADAPT_HF(template _macro(half, int32)); \
611 GKO_ADAPT_HF(template _macro(half, int64)); \
612 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_INDEX_TYPE_BASE(_macro)
614#if GINKGO_DPCPP_SINGLE_MODE
615#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INT32_TYPE_BASE(_macro) \
616 template _macro(float, int32); \
618 _macro(double, int32) GKO_NOT_IMPLEMENTED; \
619 template _macro(std::complex<float>, int32); \
621 _macro(std::complex<double>, int32) GKO_NOT_IMPLEMENTED
623#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INT32_TYPE_BASE(_macro) \
624 template _macro(float, int32); \
625 template _macro(double, int32); \
626 template _macro(std::complex<float>, int32); \
627 template _macro(std::complex<double>, int32)
630#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INT32_TYPE(_macro) \
631 GKO_ADAPT_HF(template _macro(half, int32)); \
632 GKO_ADAPT_HF(template _macro(std::complex<half>, int32)); \
633 GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INT32_TYPE_BASE(_macro)
644#if GINKGO_DPCPP_SINGLE_MODE
645#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE_BASE(_macro) \
646 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_INDEX_TYPE_BASE(_macro); \
647 template _macro(std::complex<float>, int32); \
649 _macro(std::complex<double>, int32) GKO_NOT_IMPLEMENTED; \
650 template _macro(std::complex<float>, int64); \
652 _macro(std::complex<double>, int64) GKO_NOT_IMPLEMENTED
654#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE_BASE(_macro) \
655 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_INDEX_TYPE_BASE(_macro); \
656 template _macro(std::complex<float>, int32); \
657 template _macro(std::complex<double>, int32); \
658 template _macro(std::complex<float>, int64); \
659 template _macro(std::complex<double>, int64)
662#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(_macro) \
663 GKO_ADAPT_HF(template _macro(half, int32)); \
664 GKO_ADAPT_HF(template _macro(half, int64)); \
665 GKO_ADAPT_HF(template _macro(std::complex<half>, int32)); \
666 GKO_ADAPT_HF(template _macro(std::complex<half>, int64)); \
667 GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE_BASE(_macro)
679#if GINKGO_DPCPP_SINGLE_MODE
680#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_LOCAL_GLOBAL_INDEX_TYPE_BASE( \
682 template _macro(float, int32, int32); \
683 template _macro(float, int32, int64); \
684 template _macro(float, int64, int64); \
686 _macro(double, int32, int32) GKO_NOT_IMPLEMENTED; \
688 _macro(double, int32, int64) GKO_NOT_IMPLEMENTED; \
690 _macro(double, int64, int64) GKO_NOT_IMPLEMENTED
692#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_LOCAL_GLOBAL_INDEX_TYPE_BASE( \
694 template _macro(float, int32, int32); \
695 template _macro(float, int32, int64); \
696 template _macro(float, int64, int64); \
697 template _macro(double, int32, int32); \
698 template _macro(double, int32, int64); \
699 template _macro(double, int64, int64)
702#define GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_LOCAL_GLOBAL_INDEX_TYPE( \
704 GKO_ADAPT_HF(template _macro(half, int32, int32)); \
705 GKO_ADAPT_HF(template _macro(half, int32, int64)); \
706 GKO_ADAPT_HF(template _macro(half, int64, int64)); \
707 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_LOCAL_GLOBAL_INDEX_TYPE_BASE( \
719#if GINKGO_DPCPP_SINGLE_MODE
720#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_LOCAL_GLOBAL_INDEX_TYPE_BASE( \
722 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_LOCAL_GLOBAL_INDEX_TYPE_BASE( \
724 template _macro(std::complex<float>, int32, int32); \
725 template _macro(std::complex<float>, int32, int64); \
726 template _macro(std::complex<float>, int64, int64); \
728 _macro(std::complex<double>, int32, int32) GKO_NOT_IMPLEMENTED; \
730 _macro(std::complex<double>, int32, int64) GKO_NOT_IMPLEMENTED; \
732 _macro(std::complex<double>, int64, int64) GKO_NOT_IMPLEMENTED
734#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_LOCAL_GLOBAL_INDEX_TYPE_BASE( \
736 GKO_INSTANTIATE_FOR_EACH_NON_COMPLEX_VALUE_AND_LOCAL_GLOBAL_INDEX_TYPE_BASE( \
738 template _macro(std::complex<float>, int32, int32); \
739 template _macro(std::complex<float>, int32, int64); \
740 template _macro(std::complex<float>, int64, int64); \
741 template _macro(std::complex<double>, int32, int32); \
742 template _macro(std::complex<double>, int32, int64); \
743 template _macro(std::complex<double>, int64, int64)
746#define GKO_INSTANTIATE_FOR_EACH_VALUE_AND_LOCAL_GLOBAL_INDEX_TYPE(_macro) \
747 GKO_INSTANTIATE_FOR_EACH_VALUE_AND_LOCAL_GLOBAL_INDEX_TYPE_BASE(_macro); \
748 GKO_ADAPT_HF(template _macro(half, int32, int32)); \
749 GKO_ADAPT_HF(template _macro(half, int32, int64)); \
750 GKO_ADAPT_HF(template _macro(half, int64, int64)); \
751 GKO_ADAPT_HF(template _macro(std::complex<half>, int32, int32)); \
752 GKO_ADAPT_HF(template _macro(std::complex<half>, int32, int64)); \
753 GKO_ADAPT_HF(template _macro(std::complex<half>, int64, int64))
756#if GINKGO_DPCPP_SINGLE_MODE
757#define GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION_BASE(_macro) \
759 _macro(float, double) GKO_NOT_IMPLEMENTED; \
761 _macro(double, float) GKO_NOT_IMPLEMENTED; \
763 _macro(std::complex<float>, std::complex<double>) GKO_NOT_IMPLEMENTED; \
765 _macro(std::complex<double>, std::complex<float>) GKO_NOT_IMPLEMENTED
768#define GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION_OR_COPY_BASE(_macro) \
769 GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION_BASE(_macro); \
770 template _macro(float, float); \
772 _macro(double, double) GKO_NOT_IMPLEMENTED; \
773 template _macro(std::complex<float>, std::complex<float>); \
775 _macro(std::complex<double>, std::complex<double>) GKO_NOT_IMPLEMENTED
786#define GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION_BASE(_macro) \
787 template _macro(float, double); \
788 template _macro(double, float); \
789 template _macro(std::complex<float>, std::complex<double>); \
790 template _macro(std::complex<double>, std::complex<float>)
802#define GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION_OR_COPY_BASE(_macro) \
803 GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION_BASE(_macro); \
804 template _macro(float, float); \
805 template _macro(double, double); \
806 template _macro(std::complex<float>, std::complex<float>); \
807 template _macro(std::complex<double>, std::complex<double>)
810#if GINKGO_DPCPP_SINGLE_MODE
811#define GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION(_macro) \
812 GKO_ADAPT_HF(template <> _macro(half, double) GKO_NOT_IMPLEMENTED); \
813 GKO_ADAPT_HF(template <> _macro(double, half) GKO_NOT_IMPLEMENTED); \
814 GKO_ADAPT_HF(template _macro(float, half)); \
815 GKO_ADAPT_HF(template _macro(half, float)); \
816 GKO_ADAPT_HF(template _macro(std::complex<half>, std::complex<float>)); \
817 GKO_ADAPT_HF(template <> _macro(std::complex<half>, std::complex<double>) \
818 GKO_NOT_IMPLEMENTED); \
819 GKO_ADAPT_HF(template _macro(std::complex<float>, std::complex<half>)); \
820 GKO_ADAPT_HF(template <> _macro(std::complex<double>, std::complex<half>) \
821 GKO_NOT_IMPLEMENTED); \
822 GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION_BASE(_macro)
824#define GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION(_macro) \
825 GKO_ADAPT_HF(template _macro(half, double)); \
826 GKO_ADAPT_HF(template _macro(double, half)); \
827 GKO_ADAPT_HF(template _macro(float, half)); \
828 GKO_ADAPT_HF(template _macro(half, float)); \
829 GKO_ADAPT_HF(template _macro(std::complex<half>, std::complex<float>)); \
830 GKO_ADAPT_HF(template _macro(std::complex<half>, std::complex<double>)); \
831 GKO_ADAPT_HF(template _macro(std::complex<float>, std::complex<half>)); \
832 GKO_ADAPT_HF(template _macro(std::complex<double>, std::complex<half>)); \
833 GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION_BASE(_macro)
836#define GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION_OR_COPY(_macro) \
837 GKO_INSTANTIATE_FOR_EACH_VALUE_CONVERSION(_macro); \
838 GKO_ADAPT_HF(template _macro(half, half)); \
839 GKO_ADAPT_HF(template _macro(std::complex<half>, std::complex<half>)); \
840 template _macro(float, float); \
841 template _macro(double, double); \
842 template _macro(std::complex<float>, std::complex<float>); \
843 template _macro(std::complex<double>, std::complex<double>)
853#define GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_PAIR_BASE(_macro) \
854 template _macro(float, float); \
855 template _macro(double, double); \
856 template _macro(std::complex<float>, float); \
857 template _macro(std::complex<double>, double); \
858 template _macro(std::complex<float>, std::complex<float>); \
859 template _macro(std::complex<double>, std::complex<double>)
861#define GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_PAIR(_macro) \
862 GKO_ADAPT_HF(template _macro(half, half)); \
863 GKO_ADAPT_HF(template _macro(std::complex<half>, half)); \
864 GKO_ADAPT_HF(template _macro(std::complex<half>, std::complex<half>)); \
865 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_PAIR_BASE(_macro)
876#define GKO_INSTANTIATE_FOR_EACH_COMBINED_VALUE_AND_INDEX_TYPE_BASE(_macro) \
877 template _macro(char, char); \
878 template _macro(int32, int32); \
879 template _macro(int64, int64); \
880 template _macro(unsigned int, unsigned int); \
881 template _macro(unsigned long, unsigned long); \
882 template _macro(float, float); \
883 template _macro(double, double); \
884 template _macro(long double, long double); \
885 template _macro(std::complex<float>, std::complex<float>); \
886 template _macro(std::complex<double>, std::complex<double>)
888#define GKO_INSTANTIATE_FOR_EACH_COMBINED_VALUE_AND_INDEX_TYPE(_macro) \
889 GKO_ADAPT_HF(template _macro(half, half)); \
890 GKO_ADAPT_HF(template _macro(std::complex<half>, std::complex<half>)); \
891 GKO_INSTANTIATE_FOR_EACH_COMBINED_VALUE_AND_INDEX_TYPE_BASE(_macro)
901#define GKO_INSTANTIATE_FOR_EACH_POD_TYPE_BASE(_macro) \
902 template _macro(float); \
903 template _macro(double); \
904 template _macro(std::complex<float>); \
905 template _macro(std::complex<double>); \
906 template _macro(size_type); \
907 template _macro(bool); \
908 template _macro(int32); \
909 template _macro(int64)
911#define GKO_INSTANTIATE_FOR_EACH_POD_TYPE(_macro) \
912 GKO_ADAPT_HF(template _macro(half)); \
913 GKO_ADAPT_HF(template _macro(std::complex<half>)); \
914 GKO_INSTANTIATE_FOR_EACH_POD_TYPE_BASE(_macro)
924#define GKO_INSTANTIATE_FOR_EACH_TEMPLATE_TYPE_BASE(_macro) \
925 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE_BASE(_macro); \
926 GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(_macro); \
927 template _macro(gko::size_type)
929#define GKO_INSTANTIATE_FOR_EACH_TEMPLATE_TYPE(_macro) \
930 GKO_INSTANTIATE_FOR_EACH_VALUE_TYPE(_macro); \
931 GKO_INSTANTIATE_FOR_EACH_INDEX_TYPE(_macro); \
932 template _macro(gko::size_type)
943#define GKO_INSTANTIATE_FOR_INT32_TYPE(_macro) template _macro(int32)
949template <
typename IndexType>
952 static_assert(std::is_signed<IndexType>::value,
953 "IndexType needs to be signed");
954 return static_cast<IndexType
>(-1);
958namespace experimental {
959namespace distributed {
979#define GKO_INSTANTIATE_FOR_EACH_LOCAL_GLOBAL_INDEX_TYPE(_macro) \
980 template _macro(int32, int32); \
981 template _macro(int32, int64); \
982 template _macro(int64, int64)
A class providing basic support for half precision floating point types.
Definition half.hpp:286
This class is used to encode storage precisions of low precision algorithms.
Definition types.hpp:238
uint8 storage_type
The underlying datatype used to store the encoding.
Definition types.hpp:243
constexpr precision_reduction() noexcept
Creates a default precision_reduction encoding.
Definition types.hpp:260
constexpr storage_type get_nonpreserving() const noexcept
Returns the number of non-preserving conversions in the encoding.
Definition types.hpp:301
static constexpr precision_reduction common(precision_reduction x, precision_reduction y) noexcept
Returns the common encoding of input encodings.
Definition types.hpp:329
static constexpr precision_reduction autodetect() noexcept
Returns a special encoding which instructs the algorithm to automatically detect the best precision.
Definition types.hpp:313
constexpr storage_type get_preserving() const noexcept
Returns the number of preserving conversions in the encoding.
Definition types.hpp:291
constexpr precision_reduction(storage_type preserving, storage_type nonpreserving) noexcept
Creates a precision_reduction encoding with the specified number of conversions.
Definition types.hpp:269
int comm_index_type
Index type for enumerating processes in a distributed application.
Definition types.hpp:967
The Ginkgo namespace.
Definition abstract_factory.hpp:20
std::uint8_t uint8
8-bit unsigned integral type.
Definition types.hpp:118
std::uint64_t uint64
64-bit unsigned integral type.
Definition types.hpp:135
std::int32_t int32
32-bit signed integral type.
Definition types.hpp:106
double full_precision
The most precise floating-point type.
Definition types.hpp:165
std::int16_t int16
16-bit signed integral type.
Definition types.hpp:100
std::uintptr_t uintptr
Unsigned integer type capable of holding a pointer to void.
Definition types.hpp:141
std::uint32_t uint32
32-bit unsigned integral type.
Definition types.hpp:129
std::int8_t int8
8-bit signed integral type.
Definition types.hpp:95
double float64
Double precision floating point type.
Definition types.hpp:159
double default_precision
Precision used if no precision is explicitly specified.
Definition types.hpp:171
std::int64_t int64
64-bit signed integral type.
Definition types.hpp:112
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:89
constexpr size_type byte_size
Number of bits in a byte.
Definition types.hpp:177
std::uint16_t uint16
16-bit unsigned integral type.
Definition types.hpp:123
float float32
Single precision floating point type.
Definition types.hpp:153
constexpr IndexType invalid_index()
Value for an invalid signed index type.
Definition types.hpp:950
Evaluates if all template arguments Args fulfill std::is_integral.
Definition types.hpp:189