Skip to content

Commit bddb94c

Browse files
IdclipIdclip
committed
Added component wise operators to Tuple, including comparison operators that return Tuples of bools
Signed-off-by: Nick Avramoussis <4256455+Idclip@users.noreply.github.com>
1 parent 30535e5 commit bddb94c

2 files changed

Lines changed: 56 additions & 45 deletions

File tree

‎openvdb/openvdb/math/Tuple.h‎

Lines changed: 49 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -110,6 +110,55 @@ class Tuple
110110
}
111111
//@} Compatibility
112112

113+
///////////////////////////////////////////////////////////////////////////
114+
115+
Tuple operator+(Tuple in) const {
116+
Tuple r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] + in[i]; return r;
117+
}
118+
Tuple operator-(Tuple in) const {
119+
Tuple r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] - in[i]; return r;
120+
}
121+
Tuple operator*(Tuple in) const {
122+
Tuple r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] * in[i]; return r;
123+
}
124+
Tuple operator/(Tuple in) const {
125+
Tuple r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] / in[i]; return r;
126+
}
127+
Tuple operator&(Tuple in) const {
128+
Tuple r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] & in[i]; return r;
129+
}
130+
Tuple operator|(Tuple in) const {
131+
Tuple r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] | in[i]; return r;
132+
}
133+
134+
Tuple& operator+=(Tuple in) { for (int i = 0; i < SIZE; ++i) mm[i] += in[i]; return *this; }
135+
Tuple& operator-=(Tuple in) { for (int i = 0; i < SIZE; ++i) mm[i] -= in[i]; return *this; }
136+
Tuple& operator*=(Tuple in) { for (int i = 0; i < SIZE; ++i) mm[i] *= in[i]; return *this; }
137+
Tuple& operator/=(Tuple in) { for (int i = 0; i < SIZE; ++i) mm[i] /= in[i]; return *this; }
138+
Tuple& operator&=(Tuple in) { for (int i = 0; i < SIZE; ++i) mm[i] &= in[i]; return *this; }
139+
Tuple& operator|=(Tuple in) { for (int i = 0; i < SIZE; ++i) mm[i] &= in[i]; return *this; }
140+
141+
Tuple<SIZE, bool> operator>=(Tuple in) const {
142+
Tuple<SIZE, bool> r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] >= in[i]; return r;
143+
}
144+
Tuple<SIZE, bool> operator<=(Tuple in) const {
145+
Tuple<SIZE, bool> r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] <= in[i]; return r;
146+
}
147+
Tuple<SIZE, bool> operator>(Tuple in) const {
148+
Tuple<SIZE, bool> r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] > in[i]; return r;
149+
}
150+
Tuple<SIZE, bool> operator<(Tuple in) const {
151+
Tuple<SIZE, bool> r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] < in[i]; return r;
152+
}
153+
Tuple<SIZE, bool> operator==(Tuple in) const {
154+
Tuple<SIZE, bool> r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] == in[i]; return r;
155+
}
156+
Tuple<SIZE, bool> operator!=(Tuple in) const {
157+
Tuple<SIZE, bool> r; for (int i = 0; i < SIZE; ++i) r[i] = mm[i] != in[i]; return r;
158+
}
159+
160+
///////////////////////////////////////////////////////////////////////////
161+
113162
/// @return string representation of Classname
114163
std::string str() const {
115164
std::ostringstream buffer;

‎openvdb/openvdb/simd/Simd.h‎

Lines changed: 7 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -359,7 +359,7 @@ template <typename T> struct SimdTraits; // fwd declare
359359
/// template <typename T>
360360
/// T Lerp(const T a, const T b, const T t) {
361361
/// using namespace openvdb::simd;
362-
/// return add(mul(sub(T(1), t), a), mul(t, b));
362+
/// return ((T(1) - t) * a) + (t * b));
363363
/// }
364364

365365
//// Vector API
@@ -377,10 +377,6 @@ template <size_t N, typename T> inline auto load_partial(int C, const T* a)
377377

378378
OPENVDB_ENABLE_IF_VCL inline auto compress(const T& a) { return openvdb_ext_vcl::compress(a); }
379379

380-
OPENVDB_ENABLE_IF_VCL inline T add(const T& a, const T& b) { return a + b; }
381-
OPENVDB_ENABLE_IF_VCL inline T sub(const T& a, const T& b) { return a - b; }
382-
OPENVDB_ENABLE_IF_VCL inline T mul(const T& a, const T& b) { return a * b; }
383-
OPENVDB_ENABLE_IF_VCL inline T div(const T& a, const T& b) { return a / b; }
384380
OPENVDB_ENABLE_IF_VCL inline T max(const T& a, const T& b) { return openvdb_ext_vcl::max(a, b); }
385381
OPENVDB_ENABLE_IF_VCL inline T min(const T& a, const T& b) { return openvdb_ext_vcl::min(a, b); }
386382
OPENVDB_ENABLE_IF_VCL inline T abs(const T& a) { return openvdb_ext_vcl::abs(a); }
@@ -392,14 +388,6 @@ OPENVDB_ENABLE_IF_VCL inline T pow3(const T& a) { return a*openvdb_ext_vcl::squa
392388
template <int N, typename T, typename std::enable_if<IsSimdT<T>::value>::type* = nullptr>
393389
inline auto pow(const T& a) { return openvdb_ext_vcl::pow_n<T, N>(a); }
394390

395-
OPENVDB_ENABLE_IF_VCL inline auto eq(const T& a, const T& b) { return a == b; }
396-
OPENVDB_ENABLE_IF_VCL inline auto neq(const T& a, const T& b) { return a != b; }
397-
OPENVDB_ENABLE_IF_VCL inline auto gt(const T& a, const T& b) { return a > b; }
398-
OPENVDB_ENABLE_IF_VCL inline auto gte(const T& a, const T& b) { return a >= b; }
399-
OPENVDB_ENABLE_IF_VCL inline auto lt(const T& a, const T& b) { return a < b; }
400-
OPENVDB_ENABLE_IF_VCL inline auto lte(const T& a, const T& b) { return a <= b; }
401-
OPENVDB_ENABLE_IF_VCL inline auto logical_and(const T& a, const T& b) { return a && b; }
402-
403391
OPENVDB_ENABLE_IF_VCL inline T select(const typename SimdTraits<T>::MaskT& m, const T& a, const T& b) {
404392
return openvdb_ext_vcl::select(m, a, b);
405393
}
@@ -470,29 +458,16 @@ inline typename SimdT<T, N>::Type load(const T* a)
470458

471459
OPENVDB_ENABLE_IF_TUPLE inline auto compress(const T& a) { return simd_internal::unaryop(a,simd_internal::compressop); }
472460

473-
OPENVDB_ENABLE_IF_TUPLE inline auto add(const T& a, const T& b) { return simd_internal::binop<std::plus>(a,b); }
474-
OPENVDB_ENABLE_IF_TUPLE inline auto sub(const T& a, const T& b) { return simd_internal::binop<std::minus>(a,b); }
475-
OPENVDB_ENABLE_IF_TUPLE inline auto mul(const T& a, const T& b) { return simd_internal::binop<std::multiplies>(a,b); }
476-
OPENVDB_ENABLE_IF_TUPLE inline auto div(const T& a, const T& b) { return simd_internal::binop<std::divides>(a,b); }
477-
478461
OPENVDB_ENABLE_IF_TUPLE inline auto abs(const T& a) { return simd_internal::unaryop(a,simd_internal::absop); }
479462
OPENVDB_ENABLE_IF_TUPLE inline auto sqrt(const T& a) { return simd_internal::unaryop(a,simd_internal::sqrtop); }
480-
OPENVDB_ENABLE_IF_TUPLE inline auto square(const T& a) { return mul(a,a); }
481-
OPENVDB_ENABLE_IF_TUPLE inline auto pow2(const T& a) { return mul(a,a); }
482-
OPENVDB_ENABLE_IF_TUPLE inline auto pow3(const T& a) { return mul(a, mul(a,a)); }
463+
OPENVDB_ENABLE_IF_TUPLE inline auto square(const T& a) { return a * a; }
464+
OPENVDB_ENABLE_IF_TUPLE inline auto pow2(const T& a) { return a * a; }
465+
OPENVDB_ENABLE_IF_TUPLE inline auto pow3(const T& a) { return a * a * a; }
483466
template <typename T, typename ExpT> inline auto pow(const T& a, const ExpT n)
484467
{
485468
T r; for (int i = 0; i < T::size; ++i) { r[i] = math::Pow(a[i],n); } return r;
486469
}
487470

488-
OPENVDB_ENABLE_IF_TUPLE inline auto eq(const T& a, const T& b) { return simd_internal::binop<std::equal_to>(a,b); }
489-
OPENVDB_ENABLE_IF_TUPLE inline auto neq(const T& a, const T& b) { return simd_internal::binop<std::not_equal_to>(a,b); }
490-
OPENVDB_ENABLE_IF_TUPLE inline auto gt(const T& a, const T& b) { return simd_internal::binop<std::greater>(a,b); }
491-
OPENVDB_ENABLE_IF_TUPLE inline auto gte(const T& a, const T& b) { return simd_internal::binop<std::greater_equal>(a,b); }
492-
OPENVDB_ENABLE_IF_TUPLE inline auto lt(const T& a, const T& b) { return simd_internal::binop<std::less>(a,b); }
493-
OPENVDB_ENABLE_IF_TUPLE inline auto lte(const T& a, const T& b) { return simd_internal::binop<std::less_equal>(a,b); }
494-
OPENVDB_ENABLE_IF_TUPLE inline auto logical_and(const T& a, const T& b) { return simd_internal::binop<std::logical_and>(a,b); }
495-
496471
OPENVDB_ENABLE_IF_TUPLE inline T select(const typename SimdTraits<T>::MaskT& m, const T& a, const T& b)
497472
{
498473
T r; for (int i = 0; i < T::size; ++i) { r[i] = m[i] ? a[i] : b[i]; } return r;
@@ -561,7 +536,7 @@ struct SimdTraits
561536
{
562537
static constexpr size_t size = T::size();
563538
using ElementT = typename simd_internal::elem<T::elementtype()>::Type;
564-
using MaskT = decltype(eq<T>(std::declval<T>(), std::declval<T>()));
539+
using MaskT = decltype(std::declval<T>() == std::declval<T>());
565540
template <typename S> using ConvertT = typename SimdT<S, size>::Type;
566541
};
567542

@@ -572,36 +547,23 @@ struct SimdTraits
572547
{
573548
static constexpr size_t size = T::size;
574549
using ElementT = typename T::ValueType;
575-
using MaskT = decltype(eq<T>(std::declval<T>(), std::declval<T>()));
550+
using MaskT = decltype(std::declval<T>() == std::declval<T>());
576551
template <typename S> using ConvertT = typename SimdT<S, size>::Type;
577552
};
578553

579554
#endif
580555

581556
//// Scalar API
582557

583-
OPENVDB_ENABLE_IF_ARITHMETIC inline T add(const T& a, const T& b) { return a + b; }
584-
OPENVDB_ENABLE_IF_ARITHMETIC inline T sub(const T& a, const T& b) { return a - b; }
585-
OPENVDB_ENABLE_IF_ARITHMETIC inline T mul(const T& a, const T& b) { return a * b; }
586-
OPENVDB_ENABLE_IF_ARITHMETIC inline T div(const T& a, const T& b) { return a / b; }
587-
588558
OPENVDB_ENABLE_IF_ARITHMETIC inline T max(const T& a, const T& b) { return std::max(a, b); }
589559
OPENVDB_ENABLE_IF_ARITHMETIC inline T min(const T& a, const T& b) { return std::min(a, b); }
590560
OPENVDB_ENABLE_IF_ARITHMETIC inline auto sqrt(const T& a) { return std::sqrt(a); }
591561
OPENVDB_ENABLE_IF_ARITHMETIC inline T pow2(const T& a) { return math::Pow2(a); }
592562
OPENVDB_ENABLE_IF_ARITHMETIC inline T pow3(const T& a) { return math::Pow3(a); }
593563

594-
OPENVDB_ENABLE_IF_ARITHMETIC inline auto square(const T& a) { return mul(a, a); }
564+
OPENVDB_ENABLE_IF_ARITHMETIC inline auto square(const T& a) { return a * a; }
595565
OPENVDB_ENABLE_IF_ARITHMETIC inline bool is_finite(const T& a) { return std::isfinite(a); }
596566

597-
OPENVDB_ENABLE_IF_ARITHMETIC inline bool eq(const T& a, const T& b) { return a == b; }
598-
OPENVDB_ENABLE_IF_ARITHMETIC inline bool neq(const T& a, const T& b) { return a != b; }
599-
OPENVDB_ENABLE_IF_ARITHMETIC inline bool gt(const T& a, const T& b) { return a > b; }
600-
OPENVDB_ENABLE_IF_ARITHMETIC inline bool gte(const T& a, const T& b) { return a >= b; }
601-
OPENVDB_ENABLE_IF_ARITHMETIC inline bool lt(const T& a, const T& b) { return a < b; }
602-
OPENVDB_ENABLE_IF_ARITHMETIC inline bool lte(const T& a, const T& b) { return a <= b; }
603-
OPENVDB_ENABLE_IF_ARITHMETIC inline auto logical_and(const T& a, const T& b) { return a && b; }
604-
605567
OPENVDB_ENABLE_IF_ARITHMETIC inline T select(const bool m, const T& a, const T& b) { return m ? a : b; }
606568

607569
OPENVDB_ENABLE_IF_ARITHMETIC inline T horizontal_max(const T& a) { return a; }

0 commit comments

Comments
 (0)