IPSDK  4_1_0_2
IPSDK : Image Processing Software Development Kit
SaturatedCastPack.h
Go to the documentation of this file.
1 // SaturatedCastPack.h:
3 // ------------
4 //
14 
15 #ifndef __IPSDKUTIL_INSTRUCTIONSET_DETAIL_AVX2_SATURATEDCASTPACK_H__
16 #define __IPSDKUTIL_INSTRUCTIONSET_DETAIL_AVX2_SATURATEDCASTPACK_H__
17 
18 #include <IPSDKUtil/IPSDKUtilExports.h>
19 #include <IPSDKUtil/InstructionSet/BasePack.h>
20 #include <IPSDKUtil/InstructionSet/detail/CastPack.h>
21 #include <IPSDKUtil/InstructionSet/detail/SaturatedCastPack.h>
22 #include <IPSDKUtil/Tools/ForceInline.h>
23 
24 namespace ipsdk {
25 namespace simd {
26 namespace detail {
27 
30 
31 template <typename TIn, typename TOut>
32 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, TIn, TOut,
33  typename boost::enable_if_c<
34  boost::is_same<TIn, TOut>::value
35  >::type
36 >
37 {
38  static IPSDK_FORCEINLINE
39  BasePack<ePackType::ePT_Avx, TOut>
40  act(const BasePack<ePackType::ePT_Avx, TIn>& in)
41  {
42  return CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(in);
43  }
44 
45  static IPSDK_FORCEINLINE
46  void
47  act(const BasePack<ePackType::ePT_Avx, TIn>& in,
48  BasePack<ePackType::ePT_Avx, TOut>& out)
49  {
50  CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(in, out);
51  }
52 };
53 
54 template <typename TIn, typename TOut>
55 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, TIn, TOut,
56  typename boost::enable_if_c<
57  boost::is_integral<TIn>::value &&
58  boost::is_integral<TOut>::value &&
59  boost::is_signed<TIn>::value==boost::is_signed<TOut>::value &&
60  sizeof(TIn)<sizeof(TOut)
61  >::type
62 >
63 {
64  static IPSDK_FORCEINLINE
65  BasePack<ePackType::ePT_Avx, TOut>
66  act(const BasePack<ePackType::ePT_Avx, TIn>& in)
67  {
68  BasePack<ePackType::ePT_Avx, TOut> out;
69  return CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(in);
70  }
71 
72  static IPSDK_FORCEINLINE
73  void
74  act(const BasePack<ePackType::ePT_Avx, TIn>& in,
75  BasePack<ePackType::ePT_Avx, TOut>& out)
76  {
77  CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(in, out);
78  }
79 };
80 
81 template <typename TIn, typename TOut>
82 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, TIn, TOut,
83  typename boost::enable_if_c<
84  boost::is_integral<TIn>::value &&
85  boost::is_integral<TOut>::value &&
86  boost::is_signed<TIn>::value &&
87  !boost::is_signed<TOut>::value &&
88  sizeof(TOut)>=sizeof(TIn)
89  >::type
90 >
91 {
92  static IPSDK_FORCEINLINE
93  BasePack<ePackType::ePT_Avx, TOut>
94  act(const BasePack<ePackType::ePT_Avx, TIn>& in)
95  {
96  /*const TIn clampedIn = in._val >= 0 ? in._val : 0;
97  BasePack<ePackType::ePT_Avx, TOut> out;
98  out._val = static_cast<TOut>(clampedIn);
99  return out;*/
100  BasePack<ePackType::ePT_Avx, TIn> zero;
101  simd::assign<eInstructionSet::eIS_Avx2>(zero, 0);
102  BasePack<ePackType::ePT_Avx, TIn> clampedIn;
103  simd::max(zero, in, clampedIn);
104  BasePack<ePackType::ePT_Avx, TOut> out;
105  return CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(clampedIn);
106  }
107 
108  static IPSDK_FORCEINLINE
109  void
110  act(const BasePack<ePackType::ePT_Avx, TIn>& in,
111  BasePack<ePackType::ePT_Avx, TOut>& out)
112  {
113  /*const TIn clampedIn = in._val >= 0 ? in._val : 0;
114  out._val = static_cast<TOut>(clampedIn);*/
115  BasePack<ePackType::ePT_Avx, TIn> zero;
116  simd::assign<eInstructionSet::eIS_Avx2>(zero, 0);
117  BasePack<ePackType::ePT_Avx, TIn> clampedIn;
118  simd::max<eInstructionSet::eIS_Avx2>(zero, in, clampedIn);
119  CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(clampedIn, out);
120  }
121 };
122 
123 template <typename TIn, typename TOut>
124 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, TIn, TOut,
125  typename boost::enable_if_c<
126  boost::is_integral<TIn>::value &&
127  boost::is_integral<TOut>::value &&
128  !boost::is_signed<TIn>::value &&
129  boost::is_signed<TOut>::value &&
130  sizeof(TOut)<=sizeof(TIn)
131  >::type
132 >
133 {
134  static IPSDK_FORCEINLINE
135  BasePack<ePackType::ePT_Avx, TOut>
136  act(const BasePack<ePackType::ePT_Avx, TIn>& in)
137  {
138  /*static TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
139  const TIn clampedIn = (in._val >= nMax ? nMax : in._val);
140  BasePack<ePackType::ePT_Avx, TOut> out;
141  out._val = static_cast<TOut>(clampedIn);
142  return out;*/
143  BasePack<ePackType::ePT_Avx, TIn> packMax;
144  simd::assign<eInstructionSet::eIS_Avx2>(packMax, NumericLimits<TOut>::max());
145  BasePack<ePackType::ePT_Avx, TIn> clampedIn;
146  simd::min<eInstructionSet::eIS_Avx2>(packMax, in, clampedIn);
147  BasePack<ePackType::ePT_Avx, TOut> out;
148  return CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(clampedIn);
149  }
150 
151  static IPSDK_FORCEINLINE
152  void
153  act(const BasePack<ePackType::ePT_Avx, TIn>& in,
154  BasePack<ePackType::ePT_Avx, TOut>& out)
155  {
156  /*static TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
157  const TIn clampedIn = (in._val >= nMax ? nMax : in._val);
158  out._val = static_cast<TOut>(clampedIn);*/
159 
160  BasePack<ePackType::ePT_Avx, TIn> packMax;
161  simd::assign<eInstructionSet::eIS_Avx2>(packMax, NumericLimits<TOut>::max());
162  BasePack<ePackType::ePT_Avx, TIn> clampedIn;
163  simd::min<eInstructionSet::eIS_Avx2>(packMax, in, clampedIn);
164  CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(clampedIn, out);
165  }
166 };
167 
168 template <typename TIn, typename TOut>
169 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, TIn, TOut,
170  typename boost::enable_if_c<
171  boost::is_integral<TIn>::value &&
172  boost::is_integral<TOut>::value &&
173  !boost::is_signed<TIn>::value &&
174  boost::is_signed<TOut>::value &&
175  (sizeof(TOut) > sizeof(TIn))
176  >::type
177 >
178 {
179  static IPSDK_FORCEINLINE
180  BasePack<ePackType::ePT_Avx, TOut>
181  act(const BasePack<ePackType::ePT_Avx, TIn>& in)
182  {
183  BasePack<ePackType::ePT_Avx, TOut> out;
184  return CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(in);
185  }
186 
187  static IPSDK_FORCEINLINE
188  void
189  act(const BasePack<ePackType::ePT_Avx, TIn>& in,
190  BasePack<ePackType::ePT_Avx, TOut>& out)
191  {
192  return CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(in, out);
193  }
194 };
195 
196 template <typename TIn, typename TOut>
197 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, TIn, TOut,
198  typename boost::enable_if_c<
199  boost::is_integral<TIn>::value &&
200  boost::is_integral<TOut>::value &&
201  !boost::is_signed<TIn>::value &&
202  !boost::is_signed<TOut>::value &&
203  sizeof(TOut)<sizeof(TIn)
204  >::type
205 >
206 {
207  static IPSDK_FORCEINLINE
208  BasePack<ePackType::ePT_Avx, TOut>
209  act(const BasePack<ePackType::ePT_Avx, TIn>& in)
210  {
211  /*static TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
212  const TIn clampedIn = (in._val >= nMax ? nMax : in._val);
213  BasePack<ePackType::ePT_Avx, TOut> out;
214  out._val = static_cast<TOut>(clampedIn);
215  return out;*/
216  BasePack<ePackType::ePT_Avx, TIn> packMax;
217  simd::assign<eInstructionSet::eIS_Avx2>(packMax, NumericLimits<TOut>::max());
218  BasePack<ePackType::ePT_Avx, TIn> clampedIn;
219  simd::min<eInstructionSet::eIS_Avx2>(packMax, in, clampedIn);
220  BasePack<ePackType::ePT_Avx, TOut> out;
221  return CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(clampedIn);
222  }
223 
224  static IPSDK_FORCEINLINE
225  void
226  act(const BasePack<ePackType::ePT_Avx, TIn>& in,
227  BasePack<ePackType::ePT_Avx, TOut>& out)
228  {
229  /*static TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
230  const TIn clampedIn = (in._val >= nMax ? nMax : in._val);
231  out._val = static_cast<TOut>(clampedIn);*/
232  BasePack<ePackType::ePT_Avx, TIn> packMax;
233  simd::assign<eInstructionSet::eIS_Avx2>(packMax, NumericLimits<TOut>::max());
234  BasePack<ePackType::ePT_Avx, TIn> clampedIn;
235  simd::min<eInstructionSet::eIS_Avx2>(packMax, in, clampedIn);
236  CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(clampedIn, out);
237  }
238 };
239 
240 template <typename TIn, typename TOut>
241 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, TIn, TOut,
242  typename boost::enable_if_c<
243  boost::is_integral<TIn>::value &&
244  boost::is_integral<TOut>::value &&
245  boost::is_signed<TIn>::value &&
246  sizeof(TOut)<sizeof(TIn)
247  >::type
248 >
249 {
250  static IPSDK_FORCEINLINE
251  BasePack<ePackType::ePT_Avx, TOut>
252  act(const BasePack<ePackType::ePT_Avx, TIn>& in)
253  {
254  /*BasePack<ePackType::ePT_Avx, TOut> out;
255  static TIn nMin = static_cast<TIn>(NumericLimits<TOut>::min());
256  static TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
257  TIn clampedIn = (in._val > nMax ? nMax : in._val);
258  clampedIn = (clampedIn < nMin ? nMin : clampedIn);
259  out._val = static_cast<TOut>(clampedIn);
260  return out;*/
261  BasePack<ePackType::ePT_Avx, TIn> packZero, packMax;
262  simd::assign<eInstructionSet::eIS_Avx2>(packZero, 0);
263  simd::assign<eInstructionSet::eIS_Avx2>(packMax, NumericLimits<TOut>::max());
264  BasePack<ePackType::ePT_Avx, TIn> clampedIn;
265  simd::min<eInstructionSet::eIS_Avx2>(packMax, in, clampedIn);
266  simd::max<eInstructionSet::eIS_Avx2>(packZero, clampedIn, clampedIn);
267  BasePack<ePackType::ePT_Avx, TOut> out;
268  return CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(clampedIn);
269  }
270 
271  static IPSDK_FORCEINLINE
272  void
273  act(const BasePack<ePackType::ePT_Avx, TIn>& in,
274  BasePack<ePackType::ePT_Avx, TOut>& out)
275  {
276  /*static TIn nMin = static_cast<TIn>(NumericLimits<TOut>::min());
277  static TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
278  TIn clampedIn = (in._val > nMax ? nMax : in._val);
279  clampedIn = (clampedIn < nMin ? nMin : clampedIn);
280  out._val = static_cast<TOut>(clampedIn);
281  */
282  BasePack<ePackType::ePT_Avx, TIn> packMin, packMax;
283  simd::assign<eInstructionSet::eIS_Avx2>(packMin, NumericLimits<TOut>::min());
284  simd::assign<eInstructionSet::eIS_Avx2>(packMax, NumericLimits<TOut>::max());
285  BasePack<ePackType::ePT_Avx, TIn> clampedIn;
286  simd::min<eInstructionSet::eIS_Avx2>(packMax, in, clampedIn);
287  simd::max<eInstructionSet::eIS_Avx2>(packMin, clampedIn, clampedIn);
288  CastPack<eInstructionSet::eIS_Avx2, TIn, TOut>::act(clampedIn, out);
289  }
290 };
291 
292 template <typename TIn>
293 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, TIn, ipReal32,
294  typename boost::enable_if_c<boost::is_integral<TIn>::value>::type>
295 {
296  static IPSDK_FORCEINLINE
297  BasePack<ePackType::ePT_Avx, ipReal32>
298  act(const BasePack<ePackType::ePT_Avx, TIn>& in)
299  {
300  BasePack<ePackType::ePT_Avx, ipReal32> out;
301  return CastPack<eInstructionSet::eIS_Avx2, TIn, ipReal32>::act(in);
302  }
303 
304  static IPSDK_FORCEINLINE
305  void
306  act(const BasePack<ePackType::ePT_Avx, TIn>& in,
307  BasePack<ePackType::ePT_Avx, ipReal32>& out)
308  {
309  return CastPack<eInstructionSet::eIS_Avx2, TIn, ipReal32>::act(in, out);
310  }
311 };
312 
313 template <typename TOut>
314 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, ipReal32, TOut,
315  typename boost::enable_if_c<boost::is_integral<TOut>::value>::type>
316 {
317  static IPSDK_FORCEINLINE
318  BasePack<ePackType::ePT_Avx, TOut>
319  act(const BasePack<ePackType::ePT_Avx, ipReal32>& in)
320  {
321  /*BasePack<ePackType::ePT_Avx, TOut> out;
322  static ipReal64 fMin = static_cast<ipReal64>(NumericLimits<TOut>::min());
323  static ipReal64 fMax = static_cast<ipReal64>(NumericLimits<TOut>::max());
324  ipReal64 clampedIn = in._val;
325  clampedIn = (clampedIn > fMax ? fMax : clampedIn);
326  clampedIn = (clampedIn < fMin ? fMin : clampedIn);
327  out._val = static_cast<TOut>(clampedIn);
328  return out;*/
329  BasePack<ePackType::ePT_Avx, ipReal64> clampedIn;
330  CastPack<eInstructionSet::eIS_Avx2, ipReal32, ipReal64>::act(in, clampedIn);
331 
332  BasePack<ePackType::ePT_Avx, ipReal64> packMin, packMax;
333  simd::assign<eInstructionSet::eIS_Avx2>(packMin, NumericLimits<TOut>::min());
334  simd::assign<eInstructionSet::eIS_Avx2>(packMax, NumericLimits<TOut>::max());
335  simd::min<eInstructionSet::eIS_Avx2>(packMax, clampedIn, clampedIn);
336  simd::max<eInstructionSet::eIS_Avx2>(packMin, clampedIn, clampedIn);
337 
338  return CastPack<eInstructionSet::eIS_Avx2, ipReal64, TOut>::act(clampedIn);
339  }
340 
341  static IPSDK_FORCEINLINE
342  void
343  act(const BasePack<ePackType::ePT_Avx, ipReal32>& in,
344  BasePack<ePackType::ePT_Avx, TOut>& out)
345  {
346  /*static ipReal64 fMin = static_cast<ipReal64>(NumericLimits<TOut>::min());
347  static ipReal64 fMax = static_cast<ipReal64>(NumericLimits<TOut>::max());
348  ipReal64 clampedIn = in._val;
349  clampedIn = (clampedIn > fMax ? fMax : clampedIn);
350  clampedIn = (clampedIn < fMin ? fMin : clampedIn);
351  out._val = static_cast<TOut>(clampedIn);*/
352  BasePack<ePackType::ePT_Avx, ipReal64> clampedIn;
353  CastPack<eInstructionSet::eIS_Avx2, ipReal32, ipReal64>::act(in, clampedIn);
354 
355  BasePack<ePackType::ePT_Avx, ipReal64> packMin, packMax;
356  simd::assign<eInstructionSet::eIS_Avx2>(packMin, NumericLimits<TOut>::min());
357  simd::assign<eInstructionSet::eIS_Avx2>(packMax, NumericLimits<TOut>::max());
358  simd::min<eInstructionSet::eIS_Avx2>(packMax, clampedIn, clampedIn);
359  simd::max<eInstructionSet::eIS_Avx2>(packMin, clampedIn, clampedIn);
360 
361  CastPack<eInstructionSet::eIS_Avx2, ipReal64, TOut>::act(clampedIn, out);
362  }
363 };
364 
365 template <typename TIn>
366 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, TIn, ipReal64,
367  typename boost::enable_if_c<
368  !boost::is_same<TIn, ipReal64>::value
369  >::type
370 >
371 {
372  static IPSDK_FORCEINLINE
373  BasePack<ePackType::ePT_Avx, ipReal64>
374  act(const BasePack<ePackType::ePT_Avx, TIn>& in)
375  {
376  BasePack<ePackType::ePT_Avx, ipReal64> out;
377  return CastPack<eInstructionSet::eIS_Avx2, TIn, ipReal64>::act(in);
378  }
379 
380  static IPSDK_FORCEINLINE
381  void
382  act(const BasePack<ePackType::ePT_Avx, TIn>& in,
383  BasePack<ePackType::ePT_Avx, ipReal64>& out)
384  {
385  return CastPack<eInstructionSet::eIS_Avx2, TIn, ipReal64>::act(in, out);
386  }
387 };
388 
389 template <typename TOut>
390 struct SaturatedCastPack<eInstructionSet::eIS_Avx2, ipReal64, TOut,
391  typename boost::enable_if_c<
392  !boost::is_same<ipReal64, TOut>::value
393  >::type
394 >
395 {
396  static IPSDK_FORCEINLINE
397  BasePack<ePackType::ePT_Avx, TOut>
398  act(const BasePack<ePackType::ePT_Avx, ipReal64>& in)
399  {
400  BasePack<ePackType::ePT_Avx, ipReal64> clampedIn, packMin, packMax;
401  simd::assign<eInstructionSet::eIS_Avx2>(packMin, NumericLimits<TOut>::min());
402  simd::assign<eInstructionSet::eIS_Avx2>(packMax, NumericLimits<TOut>::max());
403  simd::min<eInstructionSet::eIS_Avx2>(packMax, in, clampedIn);
404  simd::max<eInstructionSet::eIS_Avx2>(packMin, clampedIn, clampedIn);
405 
406  BasePack<ePackType::ePT_Avx, TOut> out;
407  return CastPack<eInstructionSet::eIS_Avx2, ipReal64, TOut>::act(clampedIn);
408  }
409 
410  static IPSDK_FORCEINLINE
411  void
412  act(const BasePack<ePackType::ePT_Avx, ipReal64>& in,
413  BasePack<ePackType::ePT_Avx, TOut>& out)
414  {
415  BasePack<ePackType::ePT_Avx, ipReal64> clampedIn, packMin, packMax;
416  simd::assign<eInstructionSet::eIS_Avx2>(packMin, NumericLimits<TOut>::min());
417  simd::assign<eInstructionSet::eIS_Avx2>(packMax, NumericLimits<TOut>::max());
418  simd::min<eInstructionSet::eIS_Avx2>(packMax, in, clampedIn);
419  simd::max<eInstructionSet::eIS_Avx2>(packMin, clampedIn, clampedIn);
420 
421  CastPack<eInstructionSet::eIS_Avx2, ipReal64, TOut>::act(clampedIn, out);
422  }
423 };
424 
427 
428 } // end of namespace detail
429 } // end of namespace simd
430 } // end of namespace ipsdk
431 
432 #endif // __IPSDKUTIL_INSTRUCTIONSET_DETAIL_AVX2_SATURATEDCASTPACK_H__
ForceInline.h
Defines the IPSDK_FORCEINLINE.
ipsdk
Main namespace for IPSDK library.
Definition: AlgorithmFunctionEfficiency.h:22
ipsdk::simd::detail::CastPack
Definition: CastPack.h:33
ipsdk::simd::detail::SaturatedCastPack
Definition: SaturatedCastPack.h:33
ipsdk::ipReal64
double ipReal64
Base types definition.
Definition: BaseTypes.h:57
BasePack.h
BasePack class; defines a set of scalars (for instruction set "standard") or registers (for all other...
ipsdk::simd::max
IPSDK_FORCEINLINE PackT max(const PackT &in1, const PackT &in2)
returns the maximum of 2 packs
Definition: max.h:40
ipsdk::eInstructionSet
eInstructionSet
Enumerate for processor instruction set description.
Definition: InstructionSetTypes.h:31
ipsdk::eIS_Avx2
Advanced Vector Extensions 2.
Definition: InstructionSetTypes.h:48
IPSDKUtilExports.h
Definition of import/export macro for library.
ipsdk::ipReal32
float ipReal32
Base types definition.
Definition: BaseTypes.h:56
ipsdk::simd::BasePack
structure containing intrinsic registers used to store vectorized data
Definition: BasePackDecl.h:29
Generated on Tue Apr 15 2025 16:20:43 for IPSDK by   doxygen 1.8.14