Viskores  1.0
ArrayRangeComputeTemplate.h
Go to the documentation of this file.
1 //============================================================================
2 // The contents of this file are covered by the Viskores license. See
3 // LICENSE.txt for details.
4 //
5 // By contributing to this file, all contributors agree to the Developer
6 // Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
7 //============================================================================
8 
9 //============================================================================
10 // Copyright (c) Kitware, Inc.
11 // All rights reserved.
12 // See LICENSE.txt for details.
13 //
14 // This software is distributed WITHOUT ANY WARRANTY; without even
15 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
16 // PURPOSE. See the above copyright notice for more information.
17 //============================================================================
18 #ifndef viskores_cont_ArrayRangeComputeTemplate_h
19 #define viskores_cont_ArrayRangeComputeTemplate_h
20 
21 #include <viskores/cont/Algorithm.h>
22 #include <viskores/cont/ArrayHandleCast.h>
23 #include <viskores/cont/ArrayHandleDecorator.h>
24 #include <viskores/cont/ArrayHandleTransform.h>
25 #include <viskores/cont/internal/ArrayRangeComputeUtils.h>
26 
27 #include <viskores/BinaryOperators.h>
28 #include <viskores/Deprecated.h>
29 #include <viskores/VecFlat.h>
30 #include <viskores/VecTraits.h>
31 #include <viskores/VectorAnalysis.h>
32 
33 #include <viskores/internal/Instantiations.h>
34 
35 namespace viskores
36 {
37 namespace cont
38 {
39 
40 namespace internal
41 {
42 
43 //-------------------------------------------------------------------------------------------------
44 struct ComputeRangeOptionsDecorator
45 {
46  bool IgnoreInf = false;
47 
48  template <typename SrcPortal, typename MaskPortal>
49  struct Functor
50  {
51  SrcPortal Src;
52  MaskPortal Mask;
53  bool IgnoreInf;
54 
55  using InValueType = typename SrcPortal::ValueType;
56  using InVecTraits = viskores::VecTraits<InValueType>;
57  using ResultType =
58  viskores::Vec<viskores::Vec<viskores::Float64, InVecTraits::NUM_COMPONENTS>, 2>;
59 
60  VISKORES_EXEC_CONT
61  ResultType operator()(viskores::Id idx) const
62  {
63  if ((this->Mask.GetNumberOfValues() != 0) && (this->Mask.Get(idx) == 0))
64  {
65  return { { viskores::Range{}.Min }, { viskores::Range{}.Max } };
66  }
67 
68  const auto& inVal = this->Src.Get(idx);
69  ResultType outVal;
70  for (viskores::IdComponent i = 0; i < InVecTraits::NUM_COMPONENTS; ++i)
71  {
72  auto val = static_cast<viskores::Float64>(InVecTraits::GetComponent(inVal, i));
73  if (viskores::IsNan(val) || (this->IgnoreInf && !viskores::IsFinite(val)))
74  {
75  outVal[0][i] = viskores::Range{}.Min;
76  outVal[1][i] = viskores::Range{}.Max;
77  }
78  else
79  {
80  outVal[0][i] = outVal[1][i] = val;
81  }
82  }
83 
84  return outVal;
85  }
86  };
87 
88  template <typename SrcPortal, typename GhostPortal>
89  Functor<SrcPortal, GhostPortal> CreateFunctor(const SrcPortal& sp, const GhostPortal& gp) const
90  {
91  return { sp, gp, this->IgnoreInf };
92  }
93 };
94 
95 template <typename ArrayHandleType>
96 struct ArrayValueIsNested
97 {
98  static constexpr bool Value =
99  !viskores::internal::IsFlatVec<typename ArrayHandleType::ValueType>::value;
100 };
101 
102 template <typename ArrayHandleType, bool IsNested = ArrayValueIsNested<ArrayHandleType>::Value>
103 struct NestedToFlat;
104 
105 template <typename ArrayHandleType>
106 struct NestedToFlat<ArrayHandleType, true>
107 {
108  static auto Transform(const ArrayHandleType& in)
109  {
110  return viskores::cont::ArrayHandleCast<viskores::VecFlat<typename ArrayHandleType::ValueType>,
111  ArrayHandleType>(in);
112  }
113 };
114 
115 template <typename ArrayHandleType>
116 struct NestedToFlat<ArrayHandleType, false>
117 {
118  static auto Transform(const ArrayHandleType& in) { return in; }
119 };
120 
121 template <typename ArrayHandleType>
122 inline auto NestedToFlatTransform(const ArrayHandleType& input)
123 {
124  return NestedToFlat<ArrayHandleType>::Transform(input);
125 }
126 
127 //-------------------------------------------------------------------------------------------------
131 template <typename T, typename S>
132 inline viskores::cont::ArrayHandle<viskores::Range> ArrayRangeComputeGeneric(
133  const viskores::cont::ArrayHandle<T, S>& input,
134  const viskores::cont::ArrayHandle<viskores::UInt8>& maskArray,
135  bool computeFiniteRange,
136  viskores::cont::DeviceAdapterId device)
137 {
138  VISKORES_LOG_SCOPE(viskores::cont::LogLevel::Perf, "ArrayRangeCompute");
139 
140  using VecTraits = viskores::VecTraits<T>;
141 
142  viskores::cont::ArrayHandle<viskores::Range> range;
143  range.Allocate(VecTraits::NUM_COMPONENTS);
144 
145  //We want to minimize the amount of code that we do in try execute as
146  //it is repeated for each
147  if (input.GetNumberOfValues() < 1)
148  {
149  range.Fill(viskores::Range{});
150  }
151  else
152  {
153  // if input is an array of nested vectors, transform them to `VecFlat` using ArrayHandleCast
154  auto flattened = NestedToFlatTransform(input);
155  ComputeRangeOptionsDecorator decorator{ computeFiniteRange };
156  auto decorated =
157  make_ArrayHandleDecorator(flattened.GetNumberOfValues(), decorator, flattened, maskArray);
158 
159  using ResultType =
160  viskores::Vec<viskores::Vec<viskores::Float64, VecTraits::NUM_COMPONENTS>, 2>;
161  using MinAndMaxFunctor = viskores::MinAndMax<typename ResultType::ComponentType>;
162  ResultType identity{ { viskores::Range{}.Min }, { viskores::Range{}.Max } };
163 
164  auto result =
165  viskores::cont::Algorithm::Reduce(device, decorated, identity, MinAndMaxFunctor{});
166 
167  auto portal = range.WritePortal();
168  for (viskores::IdComponent i = 0; i < VecTraits::NUM_COMPONENTS; ++i)
169  {
170  portal.Set(i, viskores::Range(result[0][i], result[1][i]));
171  }
172  }
173 
174  return range;
175 }
176 
177 //-------------------------------------------------------------------------------------------------
178 struct ScalarMagnitudeFunctor
179 {
180  template <typename T>
181  VISKORES_EXEC_CONT viskores::Float64 operator()(const T& val) const
182  {
183  // spcilization of `viskores::Magnitude` for scalars should avoid `sqrt` computation by using `abs`
184  // instead
185  return static_cast<viskores::Float64>(viskores::Magnitude(val));
186  }
187 };
188 
189 struct MagnitudeSquareFunctor
190 {
191  template <typename T>
192  VISKORES_EXEC_CONT viskores::Float64 operator()(const T& val) const
193  {
194  using VecTraits = viskores::VecTraits<T>;
195  viskores::Float64 result = 0;
196  for (viskores::IdComponent i = 0; i < VecTraits::GetNumberOfComponents(val); ++i)
197  {
198  auto comp = static_cast<viskores::Float64>(VecTraits::GetComponent(val, i));
199  result += comp * comp;
200  }
201  return result;
202  }
203 };
204 
205 template <typename ArrayHandleType>
206 viskores::Range ArrayRangeComputeMagnitudeGenericImpl(
207  viskores::VecTraitsTagSingleComponent,
208  const ArrayHandleType& input,
209  const viskores::cont::ArrayHandle<viskores::UInt8>& maskArray,
210  bool computeFiniteRange,
211  viskores::cont::DeviceAdapterId device)
212 {
213  auto mag = viskores::cont::make_ArrayHandleTransform(input, ScalarMagnitudeFunctor{});
214  auto rangeAH = ArrayRangeComputeGeneric(mag, maskArray, computeFiniteRange, device);
215  return rangeAH.ReadPortal().Get(0);
216 }
217 
218 template <typename ArrayHandleType>
219 viskores::Range ArrayRangeComputeMagnitudeGenericImpl(
220  viskores::VecTraitsTagMultipleComponents,
221  const ArrayHandleType& input,
222  const viskores::cont::ArrayHandle<viskores::UInt8>& maskArray,
223  bool computeFiniteRange,
224  viskores::cont::DeviceAdapterId device)
225 {
226  auto magsqr = viskores::cont::make_ArrayHandleTransform(input, MagnitudeSquareFunctor{});
227  auto rangeAH = ArrayRangeComputeGeneric(magsqr, maskArray, computeFiniteRange, device);
228  auto range = rangeAH.ReadPortal().Get(0);
229  if (range.IsNonEmpty())
230  {
231  range.Min = viskores::Sqrt(range.Min);
232  range.Max = viskores::Sqrt(range.Max);
233  }
234  return range;
235 }
236 
240 template <typename T, typename S>
241 inline viskores::Range ArrayRangeComputeMagnitudeGeneric(
242  const viskores::cont::ArrayHandle<T, S>& input,
243  const viskores::cont::ArrayHandle<viskores::UInt8>& maskArray,
244  bool computeFiniteRange,
245  viskores::cont::DeviceAdapterId device)
246 {
247  VISKORES_LOG_SCOPE(viskores::cont::LogLevel::Perf, "ArrayRangeComputeMagnitude");
248 
249  using VecTraits = viskores::VecTraits<T>;
250 
251  //We want to minimize the amount of code that we do in try execute as
252  //it is repeated for each
253  if (input.GetNumberOfValues() < 1)
254  {
255  return viskores::Range{};
256  }
257 
258  auto flattened = NestedToFlatTransform(input);
259  return ArrayRangeComputeMagnitudeGenericImpl(
260  typename VecTraits::HasMultipleComponents{}, flattened, maskArray, computeFiniteRange, device);
261 }
262 
263 //-------------------------------------------------------------------------------------------------
264 template <typename S>
265 struct ArrayRangeComputeImpl
266 {
267  template <typename T>
268  viskores::cont::ArrayHandle<viskores::Range> operator()(
269  const viskores::cont::ArrayHandle<T, S>& input,
270  const viskores::cont::ArrayHandle<viskores::UInt8>& maskArray,
271  bool computeFiniteRange,
272  viskores::cont::DeviceAdapterId device) const
273  {
274  return viskores::cont::internal::ArrayRangeComputeGeneric(
275  input, maskArray, computeFiniteRange, device);
276  }
277 };
278 
279 template <typename S>
280 struct ArrayRangeComputeMagnitudeImpl
281 {
282  template <typename T>
283  viskores::Range operator()(const viskores::cont::ArrayHandle<T, S>& input,
284  const viskores::cont::ArrayHandle<viskores::UInt8>& maskArray,
285  bool computeFiniteRange,
286  viskores::cont::DeviceAdapterId device) const
287  {
288  return viskores::cont::internal::ArrayRangeComputeMagnitudeGeneric(
289  input, maskArray, computeFiniteRange, device);
290  }
291 };
292 
293 } // namespace internal
294 
295 //-------------------------------------------------------------------------------------------------
300 template <typename T, typename S>
301 inline viskores::cont::ArrayHandle<viskores::Range> ArrayRangeComputeTemplate(
302  const viskores::cont::ArrayHandle<T, S>& input,
303  bool computeFiniteRange = false,
304  viskores::cont::DeviceAdapterId device = viskores::cont::DeviceAdapterTagAny{})
305 {
306  return ArrayRangeComputeTemplate(
307  input, viskores::cont::ArrayHandle<viskores::UInt8>{}, computeFiniteRange, device);
308 }
309 
310 template <typename T, typename S>
311 viskores::cont::ArrayHandle<viskores::Range> ArrayRangeComputeTemplate(
312  const viskores::cont::ArrayHandle<T, S>& input,
313  const viskores::cont::ArrayHandle<viskores::UInt8>& maskArray,
314  bool computeFiniteRange = false,
315  viskores::cont::DeviceAdapterId device = viskores::cont::DeviceAdapterTagAny{})
316 {
317  VISKORES_ASSERT(maskArray.GetNumberOfValues() == 0 ||
318  maskArray.GetNumberOfValues() == input.GetNumberOfValues());
319  return internal::ArrayRangeComputeImpl<S>{}(input, maskArray, computeFiniteRange, device);
320 }
321 
322 template <typename T, typename S>
323 inline viskores::cont::ArrayHandle<viskores::Range> ArrayRangeComputeTemplate(
324  const viskores::cont::ArrayHandle<T, S>& input,
325  viskores::cont::DeviceAdapterId device)
326 {
327  return ArrayRangeComputeTemplate(input, false, device);
328 }
329 
331 
336 template <typename T, typename S>
337 inline viskores::Range ArrayRangeComputeMagnitudeTemplate(
338  const viskores::cont::ArrayHandle<T, S>& input,
339  bool computeFiniteRange = false,
340  viskores::cont::DeviceAdapterId device = viskores::cont::DeviceAdapterTagAny{})
341 {
342  return ArrayRangeComputeMagnitudeTemplate(
343  input, viskores::cont::ArrayHandle<viskores::UInt8>{}, computeFiniteRange, device);
344 }
345 
346 template <typename T, typename S>
347 viskores::Range ArrayRangeComputeMagnitudeTemplate(
348  const viskores::cont::ArrayHandle<T, S>& input,
349  const viskores::cont::ArrayHandle<viskores::UInt8>& maskArray,
350  bool computeFiniteRange = false,
351  viskores::cont::DeviceAdapterId device = viskores::cont::DeviceAdapterTagAny{})
352 {
353  VISKORES_ASSERT(maskArray.GetNumberOfValues() == 0 ||
354  maskArray.GetNumberOfValues() == input.GetNumberOfValues());
355  return internal::ArrayRangeComputeMagnitudeImpl<S>{}(
356  input, maskArray, computeFiniteRange, device);
357 }
358 
359 template <typename T, typename S>
360 inline viskores::Range ArrayRangeComputeMagnitudeTemplate(
361  const viskores::cont::ArrayHandle<T, S>& input,
362  viskores::cont::DeviceAdapterId device)
363 {
364  return ArrayRangeComputeMagnitudeTemplate(input, false, device);
365 }
367 
368 //-----------------------------------------------------------------------------
369 template <typename ArrayHandleType>
370 VISKORES_DEPRECATED(2.1, "Use precompiled ArrayRangeCompute or ArrayRangeComputeTemplate.")
371 inline viskores::cont::ArrayHandle<viskores::Range> ArrayRangeCompute(
372  const ArrayHandleType& input,
373  viskores::cont::DeviceAdapterId device = viskores::cont::DeviceAdapterTagAny{})
374 {
375  return ArrayRangeComputeTemplate(input, false, device);
376 }
377 
378 }
379 } // namespace viskores::cont
380 
381 #define VISKORES_ARRAY_RANGE_COMPUTE_DCLR(...) \
382  viskores::cont::ArrayHandle<viskores::Range> viskores::cont::ArrayRangeComputeTemplate( \
383  const viskores::cont::ArrayHandle<__VA_ARGS__>&, \
384  const viskores::cont::ArrayHandle<viskores::UInt8>&, \
385  bool, \
386  viskores::cont::DeviceAdapterId)
387 
388 #define VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(...) \
389  viskores::Range viskores::cont::ArrayRangeComputeMagnitudeTemplate( \
390  const viskores::cont::ArrayHandle<__VA_ARGS__>&, \
391  const viskores::cont::ArrayHandle<viskores::UInt8>&, \
392  bool, \
393  viskores::cont::DeviceAdapterId)
394 
395 #define VISKORES_ARRAY_RANGE_COMPUTE_INT_SCALARS(modifiers, ...) \
396  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Int8, __VA_ARGS__); \
397  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Int8, __VA_ARGS__); \
398  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::UInt8, __VA_ARGS__); \
399  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::UInt8, __VA_ARGS__); \
400  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Int16, __VA_ARGS__); \
401  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Int16, __VA_ARGS__); \
402  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::UInt16, __VA_ARGS__); \
403  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::UInt16, __VA_ARGS__); \
404  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Int32, __VA_ARGS__); \
405  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Int32, __VA_ARGS__); \
406  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::UInt32, __VA_ARGS__); \
407  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::UInt32, __VA_ARGS__); \
408  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Int64, __VA_ARGS__); \
409  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Int64, __VA_ARGS__); \
410  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::UInt64, __VA_ARGS__); \
411  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::UInt64, __VA_ARGS__)
412 
413 #define VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_SCALARS(modifiers, ...) \
414  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Float32, __VA_ARGS__); \
415  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Float32, __VA_ARGS__); \
416  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Float64, __VA_ARGS__); \
417  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Float64, __VA_ARGS__)
418 
419 #define VISKORES_ARRAY_RANGE_COMPUTE_BOOL_SCALARS(modifiers, ...) \
420  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(bool, __VA_ARGS__); \
421  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(bool, __VA_ARGS__)
422 
423 #define VISKORES_ARRAY_RANGE_COMPUTE_OTHER_SCALARS(modifiers, ...) \
424  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(char, __VA_ARGS__); \
425  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(char, __VA_ARGS__); \
426  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(signed VISKORES_UNUSED_INT_TYPE, __VA_ARGS__); \
427  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(signed VISKORES_UNUSED_INT_TYPE, __VA_ARGS__); \
428  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(unsigned VISKORES_UNUSED_INT_TYPE, __VA_ARGS__); \
429  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(unsigned VISKORES_UNUSED_INT_TYPE, __VA_ARGS__)
430 
431 #define VISKORES_ARRAY_RANGE_COMPUTE_ALL_SCALARS(modifiers, ...) \
432  VISKORES_ARRAY_RANGE_COMPUTE_INT_SCALARS(modifiers, __VA_ARGS__); \
433  VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_SCALARS(modifiers, __VA_ARGS__); \
434  VISKORES_ARRAY_RANGE_COMPUTE_BOOL_SCALARS(modifiers, __VA_ARGS__); \
435  VISKORES_ARRAY_RANGE_COMPUTE_OTHER_SCALARS(modifiers, __VA_ARGS__)
436 
437 #define VISKORES_ARRAY_RANGE_COMPUTE_INT_VECN(modifiers, N, ...) \
438  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<viskores::Int8, N>, __VA_ARGS__); \
439  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<viskores::Int8, N>, __VA_ARGS__); \
440  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<viskores::UInt8, N>, __VA_ARGS__); \
441  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<viskores::UInt8, N>, __VA_ARGS__); \
442  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<viskores::Int16, N>, __VA_ARGS__); \
443  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<viskores::Int16, N>, __VA_ARGS__); \
444  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<viskores::UInt16, N>, __VA_ARGS__); \
445  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<viskores::UInt16, N>, \
446  __VA_ARGS__); \
447  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<viskores::Int32, N>, __VA_ARGS__); \
448  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<viskores::Int32, N>, __VA_ARGS__); \
449  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<viskores::UInt32, N>, __VA_ARGS__); \
450  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<viskores::UInt32, N>, \
451  __VA_ARGS__); \
452  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<viskores::Int64, N>, __VA_ARGS__); \
453  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<viskores::Int64, N>, __VA_ARGS__); \
454  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<viskores::UInt64, N>, __VA_ARGS__); \
455  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<viskores::UInt64, N>, __VA_ARGS__)
456 
457 #define VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_VECN(modifiers, N, ...) \
458  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<viskores::Float32, N>, __VA_ARGS__); \
459  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<viskores::Float32, N>, \
460  __VA_ARGS__); \
461  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<viskores::Float64, N>, __VA_ARGS__); \
462  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<viskores::Float64, N>, __VA_ARGS__)
463 
464 #define VISKORES_ARRAY_RANGE_COMPUTE_BOOL_VECN(modifiers, N, ...) \
465  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<bool, N>, __VA_ARGS__); \
466  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<bool, N>, __VA_ARGS__)
467 
468 #define VISKORES_ARRAY_RANGE_COMPUTE_OTHER_VECN(modifiers, N, ...) \
469  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<char, N>, __VA_ARGS__); \
470  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR(viskores::Vec<char, N>, __VA_ARGS__); \
471  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<signed VISKORES_UNUSED_INT_TYPE, N>, \
472  __VA_ARGS__); \
473  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR( \
474  viskores::Vec<signed VISKORES_UNUSED_INT_TYPE, N>, __VA_ARGS__); \
475  modifiers VISKORES_ARRAY_RANGE_COMPUTE_DCLR(viskores::Vec<unsigned VISKORES_UNUSED_INT_TYPE, N>, \
476  __VA_ARGS__); \
477  modifiers VISKORES_ARRAY_RANGE_COMPUTE_MAG_DCLR( \
478  viskores::Vec<unsigned VISKORES_UNUSED_INT_TYPE, N>, __VA_ARGS__)
479 
480 #define VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(modifiers, N, ...) \
481  VISKORES_ARRAY_RANGE_COMPUTE_INT_VECN(modifiers, N, __VA_ARGS__); \
482  VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_VECN(modifiers, N, __VA_ARGS__); \
483  VISKORES_ARRAY_RANGE_COMPUTE_BOOL_VECN(modifiers, N, __VA_ARGS__); \
484  VISKORES_ARRAY_RANGE_COMPUTE_OTHER_VECN(modifiers, N, __VA_ARGS__)
485 
486 namespace viskores
487 {
488 namespace cont
489 {
490 
491 struct StorageTagSOA;
492 
493 template <typename ST1, typename ST2, typename ST3>
494 struct StorageTagCartesianProduct;
495 
496 struct StorageTagConstant;
497 
498 struct StorageTagCounting;
499 
500 struct StorageTagXGCCoordinates;
501 
502 struct StorageTagStride;
503 
504 }
505 } // viskores::cont
506 
507 //-------------------------------------------------------------------------------------------------
509 VISKORES_INSTANTIATION_BEGIN
510 VISKORES_ARRAY_RANGE_COMPUTE_ALL_SCALARS(extern template VISKORES_CONT_TEMPLATE_EXPORT,
511  viskores::cont::StorageTagBasic);
512 VISKORES_INSTANTIATION_END
513 
514 VISKORES_INSTANTIATION_BEGIN
515 VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
516  2,
517  viskores::cont::StorageTagBasic);
518 VISKORES_INSTANTIATION_END
519 
520 VISKORES_INSTANTIATION_BEGIN
521 VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
522  3,
523  viskores::cont::StorageTagBasic);
524 VISKORES_INSTANTIATION_END
525 
526 VISKORES_INSTANTIATION_BEGIN
527 VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
528  4,
529  viskores::cont::StorageTagBasic);
530 VISKORES_INSTANTIATION_END
531 
532 //-------------------------------------------------------------------------------------------------
533 VISKORES_INSTANTIATION_BEGIN
534 VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
535  2,
536  viskores::cont::StorageTagSOA);
537 VISKORES_INSTANTIATION_END
538 
539 VISKORES_INSTANTIATION_BEGIN
540 VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
541  3,
542  viskores::cont::StorageTagSOA);
543 VISKORES_INSTANTIATION_END
544 
545 VISKORES_INSTANTIATION_BEGIN
546 VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
547  4,
548  viskores::cont::StorageTagSOA);
549 VISKORES_INSTANTIATION_END
550 
551 //-------------------------------------------------------------------------------------------------
552 VISKORES_INSTANTIATION_BEGIN
553 VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_VECN(
554  extern template VISKORES_CONT_TEMPLATE_EXPORT,
555  3,
556  viskores::cont::StorageTagCartesianProduct<viskores::cont::StorageTagBasic,
557  viskores::cont::StorageTagBasic,
558  viskores::cont::StorageTagBasic>);
559 VISKORES_INSTANTIATION_END
560 
561 //-------------------------------------------------------------------------------------------------
562 VISKORES_INSTANTIATION_BEGIN
563 VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
564  3,
565  StorageTagXGCCoordinates);
566 VISKORES_INSTANTIATION_END
567 
568 //-------------------------------------------------------------------------------------------------
569 VISKORES_INSTANTIATION_BEGIN
570 VISKORES_ARRAY_RANGE_COMPUTE_ALL_SCALARS(extern template VISKORES_CONT_TEMPLATE_EXPORT,
571  viskores::cont::StorageTagConstant);
572 VISKORES_INSTANTIATION_END
573 
574 VISKORES_INSTANTIATION_BEGIN
575 VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
576  2,
577  viskores::cont::StorageTagConstant);
578 VISKORES_INSTANTIATION_END
579 
580 VISKORES_INSTANTIATION_BEGIN
581 VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
582  3,
583  viskores::cont::StorageTagConstant);
584 VISKORES_INSTANTIATION_END
585 
586 VISKORES_INSTANTIATION_BEGIN
587 VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
588  4,
589  viskores::cont::StorageTagConstant);
590 VISKORES_INSTANTIATION_END
591 
592 //-------------------------------------------------------------------------------------------------
593 VISKORES_INSTANTIATION_BEGIN
594 VISKORES_ARRAY_RANGE_COMPUTE_INT_SCALARS(extern template VISKORES_CONT_TEMPLATE_EXPORT,
595  viskores::cont::StorageTagCounting);
596 VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_SCALARS(extern template VISKORES_CONT_TEMPLATE_EXPORT,
597  viskores::cont::StorageTagCounting);
598 VISKORES_ARRAY_RANGE_COMPUTE_OTHER_SCALARS(extern template VISKORES_CONT_TEMPLATE_EXPORT,
599  viskores::cont::StorageTagCounting);
600 VISKORES_INSTANTIATION_END
601 
602 VISKORES_INSTANTIATION_BEGIN
603 VISKORES_ARRAY_RANGE_COMPUTE_INT_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
604  2,
605  viskores::cont::StorageTagCounting);
606 VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
607  2,
608  viskores::cont::StorageTagCounting);
609 VISKORES_ARRAY_RANGE_COMPUTE_OTHER_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
610  2,
611  viskores::cont::StorageTagCounting);
612 VISKORES_INSTANTIATION_END
613 
614 VISKORES_INSTANTIATION_BEGIN
615 VISKORES_ARRAY_RANGE_COMPUTE_INT_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
616  3,
617  viskores::cont::StorageTagCounting);
618 VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
619  3,
620  viskores::cont::StorageTagCounting);
621 VISKORES_ARRAY_RANGE_COMPUTE_OTHER_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
622  3,
623  viskores::cont::StorageTagCounting);
624 VISKORES_INSTANTIATION_END
625 
626 VISKORES_INSTANTIATION_BEGIN
627 VISKORES_ARRAY_RANGE_COMPUTE_INT_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
628  4,
629  viskores::cont::StorageTagCounting);
630 VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
631  4,
632  viskores::cont::StorageTagCounting);
633 VISKORES_ARRAY_RANGE_COMPUTE_OTHER_VECN(extern template VISKORES_CONT_TEMPLATE_EXPORT,
634  4,
635  viskores::cont::StorageTagCounting);
636 VISKORES_INSTANTIATION_END
637 
638 //-------------------------------------------------------------------------------------------------
639 VISKORES_INSTANTIATION_BEGIN
640 VISKORES_ARRAY_RANGE_COMPUTE_ALL_SCALARS(extern template VISKORES_CONT_TEMPLATE_EXPORT,
641  viskores::cont::StorageTagStride);
642 VISKORES_INSTANTIATION_END
644 
645 #endif //viskores_cont_ArrayRangeComputeTemplate_h
VecFlat.h
viskores::cont::ArrayRangeComputeMagnitudeTemplate
viskores::Range ArrayRangeComputeMagnitudeTemplate(const viskores::cont::ArrayHandle< T, S > &input, bool computeFiniteRange=false, viskores::cont::DeviceAdapterId device=viskores::cont::DeviceAdapterTagAny{})
Templated version of ArrayRangeComputeMagnitude.
Definition: ArrayRangeComputeTemplate.h:337
viskores::cont::ArrayHandle::ReadPortal
ReadPortalType ReadPortal() const
Get an array portal that can be used in the control environment.
Definition: ArrayHandle.h:447
VISKORES_LOG_SCOPE
#define VISKORES_LOG_SCOPE(level,...)
Definition: Logging.h:219
ArrayHandleCast.h
viskores::Transform
auto Transform(const TupleType &&tuple, Function &&f) -> decltype(Apply(tuple, detail::TupleTransformFunctor(), std::forward< Function >(f)))
Construct a new viskores::Tuple by applying a function to each value.
Definition: Tuple.h:221
Instantiations.h
viskores::Range::Min
viskores::Float64 Min
The minumum value of the range (inclusive).
Definition: Range.h:42
viskores::cont::ArrayHandleCast
Cast the values of an array to the specified type, on demand.
Definition: ArrayHandleCast.h:151
viskores::cont::StorageTagConstant
Definition: ArrayHandleConstant.h:35
viskores::VecTraits::HasMultipleComponents
viskores::VecTraitsTagSingleComponent HasMultipleComponents
A tag specifying whether this vector has multiple components (i.e.
Definition: VecTraits.h:113
viskores::cont::Algorithm::Reduce
static U Reduce(viskores::cont::DeviceAdapterId devId, const viskores::cont::ArrayHandle< T, CIn > &input, U initialValue)
Definition: Algorithm.h:672
ArrayHandleTransform.h
VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_SCALARS
#define VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_SCALARS(modifiers,...)
Definition: ArrayRangeComputeTemplate.h:413
viskores::cont::ArrayHandle< viskores::Range >
viskores::VecTraitsTagMultipleComponents
A tag for vectors that are "true" vectors (i.e.
Definition: VecTraits.h:31
viskores::VecTraitsTagSingleComponent
A tag for vectors that are really just scalars (i.e.
Definition: VecTraits.h:38
viskores::cont::DeviceAdapterTagAny
Tag for a device adapter used to specify that any device may be used for an operation.
Definition: DeviceAdapterTag.h:194
VISKORES_ARRAY_RANGE_COMPUTE_INT_SCALARS
#define VISKORES_ARRAY_RANGE_COMPUTE_INT_SCALARS(modifiers,...)
Definition: ArrayRangeComputeTemplate.h:395
viskores::IdComponent
viskores::Int32 IdComponent
Base type to use to index small lists.
Definition: Types.h:202
viskores::cont::StorageTagBasic
A tag for the basic implementation of a Storage object.
Definition: ArrayHandle.h:53
VISKORES_EXEC_CONT
#define VISKORES_EXEC_CONT
Definition: ExportMacros.h:60
ArrayHandleDecorator.h
viskores::Sqrt
viskores::Float32 Sqrt(viskores::Float32 x)
Definition: Math.h:951
viskores::Range::Max
viskores::Float64 Max
Tha maximum value of the range (inclusive).
Definition: Range.h:44
viskores::VecTraits::GetComponent
static const ComponentType & GetComponent(const T &vector, viskores::IdComponent)
Returns the value in a given component of the vector.
Definition: VecTraits.h:125
VectorAnalysis.h
viskores::Id
viskores::Int64 Id
Base type to use to index arrays.
Definition: Types.h:235
viskores::VecTraits::GetNumberOfComponents
static constexpr viskores::IdComponent GetNumberOfComponents(const T &)
Returns the number of components in the given vector.
Definition: VecTraits.h:102
viskores
Groups connected points that have the same field value.
Definition: Atomic.h:27
Algorithm.h
viskores::VecTraits::NUM_COMPONENTS
static constexpr viskores::IdComponent NUM_COMPONENTS
Number of components in the vector.
Definition: VecTraits.h:93
viskores::VecTraits
Traits that can be queried to treat any type as a Vec.
Definition: VecTraits.h:69
VISKORES_DEPRECATED
#define VISKORES_DEPRECATED(...)
Definition: Deprecated.h:156
viskores::cont::ArrayHandle::Allocate
void Allocate(viskores::Id numberOfValues, viskores::CopyFlag preserve, viskores::cont::Token &token) const
Allocates an array large enough to hold the given number of values.
Definition: ArrayHandle.h:504
viskores::cont::ArrayHandle::GetNumberOfValues
viskores::Id GetNumberOfValues() const
Returns the number of entries in the array.
Definition: ArrayHandle.h:482
VISKORES_ASSERT
#define VISKORES_ASSERT(condition)
Definition: Assert.h:51
viskores::cont::StorageTagSOA
Definition: ArrayHandleSOA.h:131
viskores::cont::ArrayHandle::WritePortal
WritePortalType WritePortal() const
Get an array portal that can be used in the control environment.
Definition: ArrayHandle.h:468
viskores::cont::StorageTagStride
Definition: ArrayHandleStride.h:157
VISKORES_ARRAY_RANGE_COMPUTE_OTHER_SCALARS
#define VISKORES_ARRAY_RANGE_COMPUTE_OTHER_SCALARS(modifiers,...)
Definition: ArrayRangeComputeTemplate.h:423
BinaryOperators.h
viskores::cont::DeviceAdapterId
An object used to specify a device.
Definition: DeviceAdapterTag.h:66
viskores::Range
Represent a continuous scalar range of values.
Definition: Range.h:39
viskores::cont::make_ArrayHandleDecorator
ArrayHandleDecorator< typename std::decay< DecoratorImplT >::type, typename std::decay< ArrayTs >::type... > make_ArrayHandleDecorator(viskores::Id numValues, DecoratorImplT &&f, ArrayTs &&... arrays)
Create an ArrayHandleDecorator with the specified number of values that uses the provided DecoratorIm...
Definition: ArrayHandleDecorator.h:713
VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN
#define VISKORES_ARRAY_RANGE_COMPUTE_ALL_VECN(modifiers, N,...)
Definition: ArrayRangeComputeTemplate.h:480
VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_VECN
#define VISKORES_ARRAY_RANGE_COMPUTE_FLOAT_VECN(modifiers, N,...)
Definition: ArrayRangeComputeTemplate.h:457
VISKORES_INSTANTIATION_BEGIN
#define VISKORES_INSTANTIATION_BEGIN
The following empty macros are instantiation delimiters used by vtk_add_instantiations at CMake/Visko...
Definition: Instantiations.h:55
Deprecated.h
viskores::cont::ArrayHandle::Fill
void Fill(const ValueType &fillValue, viskores::Id startIndex, viskores::Id endIndex, viskores::cont::Token &token) const
Fills the array with a given value.
Definition: ArrayHandle.h:568
viskores::Magnitude
detail::FloatingPointReturnType< T >::Type Magnitude(const T &x)
Returns the magnitude of a vector.
Definition: VectorAnalysis.h:108
viskores::cont::LogLevel::Perf
@ Perf
General timing data and algorithm flow information, such as filter execution, worklet dispatches,...
viskores::cont::StorageTagCartesianProduct
Definition: ArrayHandleCartesianProduct.h:169
VISKORES_ARRAY_RANGE_COMPUTE_INT_VECN
#define VISKORES_ARRAY_RANGE_COMPUTE_INT_VECN(modifiers, N,...)
Definition: ArrayRangeComputeTemplate.h:437
viskores::cont::ArrayRangeComputeTemplate
viskores::cont::ArrayHandle< viskores::Range > ArrayRangeComputeTemplate(const viskores::cont::ArrayHandle< T, S > &input, bool computeFiniteRange=false, viskores::cont::DeviceAdapterId device=viskores::cont::DeviceAdapterTagAny{})
Templated version of ArrayRangeCompute.
Definition: ArrayRangeComputeTemplate.h:301
VISKORES_INSTANTIATION_END
#define VISKORES_INSTANTIATION_END
Definition: Instantiations.h:56
viskores::cont::make_ArrayHandleTransform
viskores::cont::ArrayHandleTransform< HandleType, FunctorType > make_ArrayHandleTransform(HandleType handle, FunctorType functor)
make_ArrayHandleTransform is convenience function to generate an ArrayHandleTransform.
Definition: ArrayHandleTransform.h:495
VISKORES_ARRAY_RANGE_COMPUTE_OTHER_VECN
#define VISKORES_ARRAY_RANGE_COMPUTE_OTHER_VECN(modifiers, N,...)
Definition: ArrayRangeComputeTemplate.h:468
VISKORES_ARRAY_RANGE_COMPUTE_ALL_SCALARS
#define VISKORES_ARRAY_RANGE_COMPUTE_ALL_SCALARS(modifiers,...)
Definition: ArrayRangeComputeTemplate.h:431
viskores::Float64
double Float64
Base type to use for 64-bit floating-point numbers.
Definition: Types.h:169
ArrayRangeComputeUtils.h
viskores::cont::StorageTagCounting
Definition: ArrayHandleCounting.h:35
viskores::cont::ArrayRangeCompute
viskores::cont::ArrayHandle< viskores::Range > ArrayRangeCompute(const viskores::cont::UnknownArrayHandle &array, bool computeFiniteRange=false, viskores::cont::DeviceAdapterId device=viskores::cont::DeviceAdapterTagAny{})
Compute the range of the data in an array handle.
viskores::Vec
A short fixed-length array.
Definition: Types.h:365
viskores::MinAndMax
Binary Predicate that takes two arguments argument x, and y and returns a viskores::Vec<T,...
Definition: BinaryOperators.h:120
VecTraits.h
Generated by   doxygen 1.8.17