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_STD_SATURATEDCASTPACK_H__
16 #define __IPSDKUTIL_INSTRUCTIONSET_DETAIL_STD_SATURATEDCASTPACK_H__
17 
18 #include <IPSDKUtil/IPSDKUtilExports.h>
19 #include <IPSDKUtil/InstructionSet/detail/CastPack.h>
20 #include <IPSDKUtil/InstructionSet/detail/SaturatedCastPack.h>
21 #include <IPSDKUtil/InstructionSet/BasePack.h>
22 #include <IPSDKUtil/Tools/ForceInline.h>
23 #include <IPSDKUtil/Tools/NumericLimits.h>
24 
25 #include <boost/type_traits/is_same.hpp>
26 #include <boost/type_traits/is_signed.hpp>
27 
28 namespace ipsdk {
29 namespace simd {
30 namespace detail {
31 
34 
35 template <typename TIn, typename TOut>
36 struct SaturatedCastPack<eInstructionSet::eIS_Standard, TIn, TOut,
37  typename boost::enable_if_c<
38  boost::is_same<TIn, TOut>::value
39  >::type
40 >
41 {
42  static IPSDK_FORCEINLINE
43  BasePack<ePackType::ePT_Scalar, TOut>
44  act(const BasePack<ePackType::ePT_Scalar, TIn>& in)
45  {
46  BasePack<ePackType::ePT_Scalar, TOut> out;
47  out._val = static_cast<TOut>(in._val);
48  return out;
49  }
50 
51  static IPSDK_FORCEINLINE
52  void
53  act(const BasePack<ePackType::ePT_Scalar, TIn>& in,
54  BasePack<ePackType::ePT_Scalar, TOut>& out)
55  {
56  out._val = static_cast<TOut>(in._val);
57  }
58 };
59 
60 template <typename TIn, typename TOut>
61 struct SaturatedCastPack<eInstructionSet::eIS_Standard, TIn, TOut,
62  typename boost::enable_if_c<
63  boost::is_integral<TIn>::value &&
64  boost::is_integral<TOut>::value &&
65  boost::is_signed<TIn>::value==boost::is_signed<TOut>::value &&
66  sizeof(TIn)<sizeof(TOut)
67  >::type
68 >
69 {
70  static IPSDK_FORCEINLINE
71  BasePack<ePackType::ePT_Scalar, TOut>
72  act(const BasePack<ePackType::ePT_Scalar, TIn>& in)
73  {
74  BasePack<ePackType::ePT_Scalar, TOut> out;
75  out._val = static_cast<TOut>(in._val);
76  return out;
77  }
78 
79  static IPSDK_FORCEINLINE
80  void
81  act(const BasePack<ePackType::ePT_Scalar, TIn>& in,
82  BasePack<ePackType::ePT_Scalar, TOut>& out)
83  {
84  out._val = static_cast<TOut>(in._val);
85  }
86 };
87 
88 template <typename TIn, typename TOut>
89 struct SaturatedCastPack<eInstructionSet::eIS_Standard, TIn, TOut,
90  typename boost::enable_if_c<
91  boost::is_integral<TIn>::value &&
92  boost::is_integral<TOut>::value &&
93  boost::is_signed<TIn>::value &&
94  !boost::is_signed<TOut>::value &&
95  sizeof(TOut)>=sizeof(TIn)
96  >::type
97 >
98 {
99  static IPSDK_FORCEINLINE
100  BasePack<ePackType::ePT_Scalar, TOut>
101  act(const BasePack<ePackType::ePT_Scalar, TIn>& in)
102  {
103  const TIn clampedIn = in._val >= 0 ? in._val : 0;
104  BasePack<ePackType::ePT_Scalar, TOut> out;
105  out._val = static_cast<TOut>(clampedIn);
106  return out;
107  }
108 
109  static IPSDK_FORCEINLINE
110  void
111  act(const BasePack<ePackType::ePT_Scalar, TIn>& in,
112  BasePack<ePackType::ePT_Scalar, TOut>& out)
113  {
114  const TIn clampedIn = in._val >= 0 ? in._val : 0;
115  out._val = static_cast<TOut>(clampedIn);
116  }
117 };
118 
119 template <typename TIn, typename TOut>
120 struct SaturatedCastPack<eInstructionSet::eIS_Standard, TIn, TOut,
121  typename boost::enable_if_c<
122  boost::is_integral<TIn>::value &&
123  boost::is_integral<TOut>::value &&
124  !boost::is_signed<TIn>::value &&
125  boost::is_signed<TOut>::value &&
126  sizeof(TOut)<=sizeof(TIn)
127  >::type
128 >
129 {
130  static IPSDK_FORCEINLINE
131  BasePack<ePackType::ePT_Scalar, TOut>
132  act(const BasePack<ePackType::ePT_Scalar, TIn>& in)
133  {
134  static TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
135  const TIn clampedIn = (in._val >= nMax ? nMax : in._val);
136  BasePack<ePackType::ePT_Scalar, TOut> out;
137  out._val = static_cast<TOut>(clampedIn);
138  return out;
139  }
140 
141  static IPSDK_FORCEINLINE
142  void
143  act(const BasePack<ePackType::ePT_Scalar, TIn>& in,
144  BasePack<ePackType::ePT_Scalar, TOut>& out)
145  {
146  const TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
147  const TIn clampedIn = (in._val >= nMax ? nMax : in._val);
148  out._val = static_cast<TOut>(clampedIn);
149  }
150 };
151 
152 template <typename TIn, typename TOut>
153 struct SaturatedCastPack<eInstructionSet::eIS_Standard, TIn, TOut,
154  typename boost::enable_if_c<
155  boost::is_integral<TIn>::value &&
156  boost::is_integral<TOut>::value &&
157  !boost::is_signed<TIn>::value &&
158  boost::is_signed<TOut>::value &&
159  (sizeof(TOut) > sizeof(TIn))
160  >::type
161 >
162 {
163  static IPSDK_FORCEINLINE
164  BasePack<ePackType::ePT_Scalar, TOut>
165  act(const BasePack<ePackType::ePT_Scalar, TIn>& in)
166  {
167  BasePack<ePackType::ePT_Scalar, TOut> out;
168  out._val = static_cast<TOut>(in._val);
169  return out;
170  }
171 
172  static IPSDK_FORCEINLINE
173  void
174  act(const BasePack<ePackType::ePT_Scalar, TIn>& in,
175  BasePack<ePackType::ePT_Scalar, TOut>& out)
176  {
177  out._val = static_cast<TOut>(in._val);
178  }
179 };
180 
181 template <typename TIn, typename TOut>
182 struct SaturatedCastPack<eInstructionSet::eIS_Standard, TIn, TOut,
183  typename boost::enable_if_c<
184  boost::is_integral<TIn>::value &&
185  boost::is_integral<TOut>::value &&
186  !boost::is_signed<TIn>::value &&
187  !boost::is_signed<TOut>::value &&
188  sizeof(TOut)<sizeof(TIn)
189  >::type
190 >
191 {
192  static IPSDK_FORCEINLINE
193  BasePack<ePackType::ePT_Scalar, TOut>
194  act(const BasePack<ePackType::ePT_Scalar, TIn>& in)
195  {
196  static TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
197  const TIn clampedIn = (in._val >= nMax ? nMax : in._val);
198  BasePack<ePackType::ePT_Scalar, TOut> out;
199  out._val = static_cast<TOut>(clampedIn);
200  return out;
201  }
202 
203  static IPSDK_FORCEINLINE
204  void
205  act(const BasePack<ePackType::ePT_Scalar, TIn>& in,
206  BasePack<ePackType::ePT_Scalar, TOut>& out)
207  {
208  const TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
209  const TIn clampedIn = (in._val >= nMax ? nMax : in._val);
210  out._val = static_cast<TOut>(clampedIn);
211  }
212 };
213 
214 template <typename TIn, typename TOut>
215 struct SaturatedCastPack<eInstructionSet::eIS_Standard, TIn, TOut,
216  typename boost::enable_if_c<
217  boost::is_integral<TIn>::value &&
218  boost::is_integral<TOut>::value &&
219  boost::is_signed<TIn>::value &&
220  sizeof(TOut)<sizeof(TIn)
221  >::type
222 >
223 {
224  static IPSDK_FORCEINLINE
225  BasePack<ePackType::ePT_Scalar, TOut>
226  act(const BasePack<ePackType::ePT_Scalar, TIn>& in)
227  {
228  BasePack<ePackType::ePT_Scalar, TOut> out;
229  const TIn nMin = static_cast<TIn>(NumericLimits<TOut>::min());
230  const TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
231  TIn clampedIn = (in._val > nMax ? nMax : in._val);
232  clampedIn = (clampedIn < nMin ? nMin : clampedIn);
233  out._val = static_cast<TOut>(clampedIn);
234  return out;
235  }
236 
237  static IPSDK_FORCEINLINE
238  void
239  act(const BasePack<ePackType::ePT_Scalar, TIn>& in,
240  BasePack<ePackType::ePT_Scalar, TOut>& out)
241  {
242  const TIn nMin = static_cast<TIn>(NumericLimits<TOut>::min());
243  const TIn nMax = static_cast<TIn>(NumericLimits<TOut>::max());
244  TIn clampedIn = (in._val > nMax ? nMax : in._val);
245  clampedIn = (clampedIn < nMin ? nMin : clampedIn);
246  out._val = static_cast<TOut>(clampedIn);
247  }
248 };
249 
250 template <typename TIn>
251 struct SaturatedCastPack<eInstructionSet::eIS_Standard, TIn, ipReal32,
252  typename boost::enable_if_c<boost::is_integral<TIn>::value>::type>
253 {
254  static IPSDK_FORCEINLINE
255  BasePack<ePackType::ePT_Scalar, ipReal32>
256  act(const BasePack<ePackType::ePT_Scalar, TIn>& in)
257  {
258  BasePack<ePackType::ePT_Scalar, ipReal32> out;
259  out._val = static_cast<ipReal32>(in._val);
260  return out;
261  }
262 
263  static IPSDK_FORCEINLINE
264  void
265  act(const BasePack<ePackType::ePT_Scalar, TIn>& in,
266  BasePack<ePackType::ePT_Scalar, ipReal32>& out)
267  {
268  out._val = static_cast<ipReal32>(in._val);
269  }
270 };
271 
272 template <typename TOut>
273 struct SaturatedCastPack<eInstructionSet::eIS_Standard, ipReal32, TOut,
274  typename boost::enable_if_c<boost::is_integral<TOut>::value>::type>
275 {
276  static IPSDK_FORCEINLINE
277  BasePack<ePackType::ePT_Scalar, TOut>
278  act(const BasePack<ePackType::ePT_Scalar, ipReal32>& in)
279  {
280  BasePack<ePackType::ePT_Scalar, TOut> out;
281  const ipReal64 fMin = static_cast<ipReal64>(NumericLimits<TOut>::min());
282  const ipReal64 fMax = static_cast<ipReal64>(NumericLimits<TOut>::max());
283  const TOut tMin = NumericLimits<TOut>::min();
284  const TOut tMax = NumericLimits<TOut>::max();
285  TOut clampedIn = static_cast<TOut>(in._val);
286  clampedIn = (in._val > fMax ? tMax : clampedIn);
287  clampedIn = (in._val < fMin ? tMin : clampedIn);
288  out._val = static_cast<TOut>(clampedIn);
289  return out;
290  }
291 
292  static IPSDK_FORCEINLINE
293  void
294  act(const BasePack<ePackType::ePT_Scalar, ipReal32>& in,
295  BasePack<ePackType::ePT_Scalar, TOut>& out)
296  {
297  const TOut tMin = NumericLimits<TOut>::min();
298  const TOut tMax = NumericLimits<TOut>::max();
299  const ipReal64 fMin = static_cast<ipReal64>(tMin);
300  const ipReal64 fMax = static_cast<ipReal64>(tMax);
301  TOut clampedIn = static_cast<TOut>(in._val);
302  clampedIn = (in._val > fMax ? tMax : clampedIn);
303  clampedIn = (in._val < fMin ? tMin : clampedIn);
304  out._val = clampedIn;
305  }
306 };
307 
308 template <typename TIn>
309 struct SaturatedCastPack<eInstructionSet::eIS_Standard, TIn, ipReal64,
310  typename boost::enable_if_c<
311  !boost::is_same<TIn, ipReal64>::value
312  >::type
313 >
314 {
315  static IPSDK_FORCEINLINE
316  BasePack<ePackType::ePT_Scalar, ipReal64>
317  act(const BasePack<ePackType::ePT_Scalar, TIn>& in)
318  {
319  BasePack<ePackType::ePT_Scalar, ipReal32> out;
320  out._val = static_cast<ipReal64>(in._val);
321  return out;
322  }
323 
324  static IPSDK_FORCEINLINE
325  void
326  act(const BasePack<ePackType::ePT_Scalar, TIn>& in,
327  BasePack<ePackType::ePT_Scalar, ipReal64>& out)
328  {
329  out._val = static_cast<ipReal64>(in._val);
330  }
331 };
332 
333 template <typename TOut>
334 struct SaturatedCastPack<eInstructionSet::eIS_Standard, ipReal64, TOut,
335  typename boost::enable_if_c<
336  !boost::is_same<ipReal64, TOut>::value
337  >::type
338 >
339 {
340  static IPSDK_FORCEINLINE
341  BasePack<ePackType::ePT_Scalar, TOut>
342  act(const BasePack<ePackType::ePT_Scalar, ipReal64>& in)
343  {
344  BasePack<ePackType::ePT_Scalar, TOut> out;
345  const TOut tMin = NumericLimits<TOut>::min();
346  const TOut tMax = NumericLimits<TOut>::max();
347  const ipReal64 fMin = static_cast<ipReal64>(tMin);
348  const ipReal64 fMax = static_cast<ipReal64>(tMax);
349  TOut clampedIn = (in._val > fMax ? tMax : static_cast<TOut>(in._val));
350  clampedIn = (in._val < fMin ? tMin : clampedIn);
351  out._val = clampedIn;
352  return out;
353  }
354 
355  static IPSDK_FORCEINLINE
356  void
357  act(const BasePack<ePackType::ePT_Scalar, ipReal64>& in,
358  BasePack<ePackType::ePT_Scalar, TOut>& out)
359  {
360  const TOut tMin = NumericLimits<TOut>::min();
361  const TOut tMax = NumericLimits<TOut>::max();
362  const ipReal64 fMin = static_cast<ipReal64>(tMin);
363  const ipReal64 fMax = static_cast<ipReal64>(tMax);
364  TOut clampedIn = (in._val > fMax ? tMax : static_cast<TOut>(in._val));
365  clampedIn = (in._val < fMin ? tMin : clampedIn);
366  out._val = clampedIn;
367  }
368 };
369 
372 
373 } // end of namespace detail
374 } // end of namespace simd
375 } // end of namespace ipsdk
376 
377 #endif // __IPSDKUTIL_INSTRUCTIONSET_DETAIL_STD_SATURATEDCASTPACK_H__
ForceInline.h
Defines the IPSDK_FORCEINLINE.
ipsdk
Main namespace for IPSDK library.
Definition: AlgorithmFunctionEfficiency.h:22
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::eInstructionSet
eInstructionSet
Enumerate for processor instruction set description.
Definition: InstructionSetTypes.h:31
IPSDKUtilExports.h
Definition of import/export macro for library.
ipsdk::eIS_Standard
compiler optimisations only
Definition: InstructionSetTypes.h:34
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