Blaze 3.9
Hypot.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_FUNCTORS_HYPOT_H_
36#define _BLAZE_MATH_FUNCTORS_HYPOT_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <utility>
63#include <blaze/system/Inline.h>
65
66
67namespace blaze {
68
69//=================================================================================================
70//
71// CLASS DEFINITION
72//
73//=================================================================================================
74
75//*************************************************************************************************
79struct Hypot
80{
81 //**********************************************************************************************
88 template< typename T1, typename T2 >
89 BLAZE_ALWAYS_INLINE BLAZE_DEVICE_CALLABLE decltype(auto) operator()( T1&& a, T2&& b ) const
90 {
91 return hypot( std::forward<T1>( a ), std::forward<T2>( b ) );
92 }
93 //**********************************************************************************************
94
95 //**********************************************************************************************
100 template< typename T1, typename T2 >
101 static constexpr bool simdEnabled() { return HasSIMDHypot_v<T1,T2>; }
102 //**********************************************************************************************
103
104 //**********************************************************************************************
109 static constexpr bool paddingEnabled() { return true; }
110 //**********************************************************************************************
111
112 //**********************************************************************************************
119 template< typename T1, typename T2 >
120 BLAZE_ALWAYS_INLINE decltype(auto) load( const T1& a, const T2& b ) const
121 {
124 return hypot( a, b );
125 }
126 //**********************************************************************************************
127};
128//*************************************************************************************************
129
130
131
132
133//=================================================================================================
134//
135// YIELDSUNIFORM SPECIALIZATIONS
136//
137//=================================================================================================
138
139//*************************************************************************************************
141template< typename T1, typename T2 >
142struct YieldsUniform<Hypot,T1,T2>
143 : public BoolConstant< IsUniform_v<T1> && IsUniform_v<T2> >
144{};
146//*************************************************************************************************
147
148
149
150
151//=================================================================================================
152//
153// YIELDSSYMMETRIC SPECIALIZATIONS
154//
155//=================================================================================================
156
157//*************************************************************************************************
159template< typename MT1, typename MT2 >
160struct YieldsSymmetric<Hypot,MT1,MT2>
161 : public BoolConstant< IsSymmetric_v<MT1> && IsSymmetric_v<MT2> >
162{};
164//*************************************************************************************************
165
166
167
168
169//=================================================================================================
170//
171// YIELDSLOWER SPECIALIZATIONS
172//
173//=================================================================================================
174
175//*************************************************************************************************
177template< typename MT1, typename MT2 >
178struct YieldsLower<Hypot,MT1,MT2>
179 : public BoolConstant< IsLower_v<MT1> && IsLower_v<MT2> >
180{};
182//*************************************************************************************************
183
184
185
186
187//=================================================================================================
188//
189// YIELDSSTRICTLYLOWER SPECIALIZATIONS
190//
191//=================================================================================================
192
193//*************************************************************************************************
195template< typename MT1, typename MT2 >
196struct YieldsStrictlyLower<Hypot,MT1,MT2>
197 : public BoolConstant< IsStrictlyLower_v<MT1> && IsStrictlyLower_v<MT2> >
198{};
200//*************************************************************************************************
201
202
203
204
205//=================================================================================================
206//
207// YIELDSUPPER SPECIALIZATIONS
208//
209//=================================================================================================
210
211//*************************************************************************************************
213template< typename MT1, typename MT2 >
214struct YieldsUpper<Hypot,MT1,MT2>
215 : public BoolConstant< IsUpper_v<MT1> && IsUpper_v<MT2> >
216{};
218//*************************************************************************************************
219
220
221
222
223//=================================================================================================
224//
225// YIELDSSTRICTLYUPPER SPECIALIZATIONS
226//
227//=================================================================================================
228
229//*************************************************************************************************
231template< typename MT1, typename MT2 >
232struct YieldsStrictlyUpper<Hypot,MT1,MT2>
233 : public BoolConstant< IsStrictlyUpper_v<MT1> && IsStrictlyUpper_v<MT2> >
234{};
236//*************************************************************************************************
237
238
239
240
241//=================================================================================================
242//
243// YIELDSZERO SPECIALIZATIONS
244//
245//=================================================================================================
246
247//*************************************************************************************************
249template< typename T1, typename T2 >
250struct YieldsZero<Hypot,T1,T2>
251 : public BoolConstant< IsZero_v<T1> && IsZero_v<T2> >
252{};
254//*************************************************************************************************
255
256} // namespace blaze
257
258#endif
Header file for the HasSIMDHypot type trait.
Macro for CUDA compatibility.
Header file for the IntegralConstant class template.
Header file for the IsLower type trait.
Header file for the IsStrictlyLower type trait.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Header file for the IsUniform type trait.
Header file for the IsUpper type trait.
Header file for the YieldsLower type trait.
Header file for the YieldsStrictlyLower type trait.
Header file for the YieldsStrictlyUpper type trait.
Header file for the YieldsSymmetric type trait.
Header file for the YieldsUniform type trait.
Header file for the YieldsUpper type trait.
Header file for the YieldsZero type trait.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SIMD_PACK(T)
Constraint on the data type.
Definition: SIMDPack.h:60
BLAZE_ALWAYS_INLINE const SIMDdouble hypot(const SIMDf64< T > &a, const SIMDf64< T > &b) noexcept=delete
Computes the length of the hypotenous of a right triangle of a vector of double precision floating po...
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
#define BLAZE_DEVICE_CALLABLE
Conditional macro that sets host and device attributes when compiled with CUDA.
Definition: HostDevice.h:94
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.
Definition: IntegralConstant.h:110
Header file for the hypot shim.
Header file for the SIMD hypothenous functionality.
Generic wrapper for the hypot() function.
Definition: Hypot.h:80
static constexpr bool simdEnabled()
Returns whether SIMD is enabled for the specified data types T1 and T2.
Definition: Hypot.h:101
static constexpr bool paddingEnabled()
Returns whether the operation supports padding, i.e. whether it can deal with zeros.
Definition: Hypot.h:109
BLAZE_ALWAYS_INLINE decltype(auto) load(const T1 &a, const T2 &b) const
Returns the result of the hypot() function for the given SIMD vectors.
Definition: Hypot.h:120
System settings for the inline keywords.
Header file for the IsZero type trait.