OWL
OptiX7 Wrapper Library
compare.h
Go to the documentation of this file.
1 // ======================================================================== //
2 // Copyright 2018-2019 Ingo Wald //
3 // //
4 // Licensed under the Apache License, Version 2.0 (the "License"); //
5 // you may not use this file except in compliance with the License. //
6 // You may obtain a copy of the License at //
7 // //
8 // http://www.apache.org/licenses/LICENSE-2.0 //
9 // //
10 // Unless required by applicable law or agreed to in writing, software //
11 // distributed under the License is distributed on an "AS IS" BASIS, //
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. //
13 // See the License for the specific language governing permissions and //
14 // limitations under the License. //
15 // ======================================================================== //
16 
17 #pragma once
18 
19 namespace owl {
20  namespace common {
21 
22  // ------------------------------------------------------------------
23  // ==
24  // ------------------------------------------------------------------
25 
26 #if __CUDACC__
27  template<typename T>
28  inline __both__ bool operator==(const vec_t<T,2> &a, const vec_t<T,2> &b)
29  { return (a.x==b.x) & (a.y==b.y); }
30 
31  template<typename T>
32  inline __both__ bool operator==(const vec_t<T,3> &a, const vec_t<T,3> &b)
33  { return (a.x==b.x) & (a.y==b.y) & (a.z==b.z); }
34 
35  template<typename T>
36  inline __both__ bool operator==(const vec_t<T,4> &a, const vec_t<T,4> &b)
37  { return (a.x==b.x) & (a.y==b.y) & (a.z==b.z) & (a.w==b.w); }
38 #else
39  template<typename T>
40  inline __both__ bool operator==(const vec_t<T,2> &a, const vec_t<T,2> &b)
41  { return a.x==b.x && a.y==b.y; }
42 
43  template<typename T>
44  inline __both__ bool operator==(const vec_t<T,3> &a, const vec_t<T,3> &b)
45  { return a.x==b.x && a.y==b.y && a.z==b.z; }
46 
47  template<typename T>
48  inline __both__ bool operator==(const vec_t<T,4> &a, const vec_t<T,4> &b)
49  { return a.x==b.x && a.y==b.y && a.z==b.z && a.w==b.w; }
50 #endif
51 
52  // ------------------------------------------------------------------
53  // !=
54  // ------------------------------------------------------------------
55 
56  template<typename T, int N>
57  inline __both__ bool operator!=(const vec_t<T,N> &a, const vec_t<T,N> &b)
58  { return !(a==b); }
59 
60 
61  // ------------------------------------------------------------------
62  // comparison operators returning result _vector_
63  // ------------------------------------------------------------------
64 
65  // ------------------------------------------------------------------
66  // not (!)
67  // ------------------------------------------------------------------
68 
69  template<typename T>
70  inline __both__ auto nt(const vec_t<T,2> &a)
71  -> vec_t<decltype(!a.x),2>
72  { return { !a.x, !a.y }; }
73 
74  template<typename T>
75  inline __both__ auto nt(const vec_t<T,3> &a)
76  -> vec_t<decltype(!a.x),3>
77  { return { !a.x, !a.y, !a.z }; }
78 
79  template<typename T>
80  inline __both__ auto nt(const vec_t<T,4> &a)
81  -> vec_t<decltype(!a.x),4>
82  { return { !a.x, !a.y, !a.z, !a.w }; }
83 
84  // ------------------------------------------------------------------
85  // eq (==)
86  // ------------------------------------------------------------------
87 
88  template<typename T>
89  inline __both__ auto eq(const vec_t<T,2> &a, const vec_t<T,2> &b)
90  -> vec_t<decltype(a.x==b.x),2>
91  { return { a.x==b.x, a.y==b.y }; }
92 
93  template<typename T>
94  inline __both__ auto eq(const vec_t<T,3> &a, const vec_t<T,3> &b)
95  -> vec_t<decltype(a.x==b.x),3>
96  { return { a.x==b.x, a.y==b.y, a.z==b.z }; }
97 
98  template<typename T>
99  inline __both__ auto eq(const vec_t<T,4> &a, const vec_t<T,4> &b)
100  -> vec_t<decltype(a.x==b.x),4>
101  { return { a.x==b.x, a.y==b.y, a.z==b.z, a.w==b.w }; }
102 
103  // ------------------------------------------------------------------
104  // neq (!=)
105  // ------------------------------------------------------------------
106 
107  template<typename T, int N>
108  inline __both__ auto neq(const vec_t<T,N> &a, const vec_t<T,N> &b)
109  -> decltype(nt(eq(a,b)))
110  { return nt(eq(a,b)); }
111 
112  // ------------------------------------------------------------------
113  // lt (<)
114  // ------------------------------------------------------------------
115 
116  template<typename T>
117  inline __both__ auto lt(const vec_t<T,2> &a, const vec_t<T,2> &b)
118  -> vec_t<decltype(a.x<b.x),2>
119  { return { a.x<b.x, a.y<b.y }; }
120 
121  template<typename T>
122  inline __both__ auto lt(const vec_t<T,3> &a, const vec_t<T,3> &b)
123  -> vec_t<decltype(a.x<b.x),3>
124  { return { a.x<b.x, a.y<b.y, a.z<b.z }; }
125 
126  template<typename T>
127  inline __both__ auto lt(const vec_t<T,4> &a, const vec_t<T,4> &b)
128  -> vec_t<decltype(a.x<b.x),4>
129  { return { a.x<b.x, a.y<b.y, a.z<b.z, a.w<b.w }; }
130 
131  // ------------------------------------------------------------------
132  // le (<=)
133  // ------------------------------------------------------------------
134 
135  template<typename T, int N>
136  inline __both__ auto le(const vec_t<T,N> &a, const vec_t<T,N> &b)
137  -> decltype(nt(lt(b,a)))
138  { return nt(lt(b,a)); }
139 
140  // ------------------------------------------------------------------
141  // gt (>)
142  // ------------------------------------------------------------------
143 
144  template<typename T, int N>
145  inline __both__ auto gt(const vec_t<T,N> &a, const vec_t<T,N> &b)
146  -> decltype(lt(b,a))
147  { return lt(b,a); }
148 
149  // ------------------------------------------------------------------
150  // ge (>=)
151  // ------------------------------------------------------------------
152 
153  template<typename T, int N>
154  inline __both__ auto ge(const vec_t<T,N> &a, const vec_t<T,N> &b)
155  -> decltype(nt(lt(a,b)))
156  { return nt(lt(a,b)); }
157 
158  // ------------------------------------------------------------------
159  // reduce
160  // ------------------------------------------------------------------
161 
162  template<typename T, int N>
163  inline __both__ bool any(const vec_t<T,N> &a)
164  { for (int i=0;i<N;++i) if (a[i]) return true; return false; }
165 
166  template<typename T, int N>
167  inline __both__ bool all(const vec_t<T,N> &a)
168  { for (int i=0;i<N;++i) if (!a[i]) return false; return true; }
169 
170  // template<typename T>
171  // inline __both__ bool any(const vec_t<T,3> &a)
172  // { return a[i] | b[i] | c[i]; }
173 
174  // ------------------------------------------------------------------
175  // select
176  // ------------------------------------------------------------------
177 
178  template<typename T>
179  inline __both__ vec_t<T,2> select(const vec_t<bool,2> &mask,
180  const vec_t<T,2> &a,
181  const vec_t<T,2> &b)
182  { return { mask.x?a.x:b.x, mask.y?a.y:b.y }; }
183 
184  template<typename T>
185  inline __both__ vec_t<T,3> select(const vec_t<bool,3> &mask,
186  const vec_t<T,3> &a,
187  const vec_t<T,3> &b)
188  { return { mask.x?a.x:b.x, mask.y?a.y:b.y, mask.z?a.z:b.z }; }
189 
190  template<typename T>
191  inline __both__ vec_t<T,4> select(const vec_t<bool,4> &mask,
192  const vec_t<T,4> &a,
193  const vec_t<T,4> &b)
194  { return { mask.x?a.x:b.x, mask.y?a.y:b.y, mask.z?a.z:b.z }; }
195 
196  template<typename T, int N>
197  inline __both__ vec_t<T,N> select(const vec_t<bool,N> &mask,
198  const vec_t<T,N> &a,
199  const vec_t<T,N> &b)
200  {
201  vec_t<T,N> res;
202  for (int i=0; i<N; ++i)
203  res[i] = mask[i]?a[i]:b[i];
204  return res;
205  }
206 
207  } // ::owl::common
208 } // ::owl
owl::common::vec_t< T, 4 >::z
T z
Definition: vec.h:282
owl::common::eq
__both__ auto eq(const vec_t< T, 2 > &a, const vec_t< T, 2 > &b) -> vec_t< decltype(a.x==b.x), 2 >
Definition: compare.h:89
owl::common::vec_t< T, 3 >::z
T z
Definition: vec.h:194
owl::common::neq
__both__ auto neq(const vec_t< T, N > &a, const vec_t< T, N > &b) -> decltype(nt(eq(a, b)))
Definition: compare.h:108
owl::common::vec_t< T, 3 >::y
T y
Definition: vec.h:194
owl::common::vec_t< T, 2 >::y
T y
Definition: vec.h:133
owl::common::vec_t< T, 2 >
Definition: vec.h:96
owl::common::lt
__both__ auto lt(const vec_t< T, 2 > &a, const vec_t< T, 2 > &b) -> vec_t< decltype(a.x< b.x), 2 >
Definition: compare.h:117
owl::common::all
__both__ bool all(const vec_t< T, N > &a)
Definition: compare.h:167
owl::common::ge
__both__ auto ge(const vec_t< T, N > &a, const vec_t< T, N > &b) -> decltype(nt(lt(a, b)))
Definition: compare.h:154
owl::common::select
__both__ vec_t< T, 2 > select(const vec_t< bool, 2 > &mask, const vec_t< T, 2 > &a, const vec_t< T, 2 > &b)
Definition: compare.h:179
owl::common::vec_t< T, 4 >::w
T w
Definition: vec.h:282
owl::common::operator!=
bool operator!=(const AffineSpaceT< L > &a, const AffineSpaceT< L > &b)
Definition: AffineSpace.h:147
owl::common::vec_t< T, 4 >::x
T x
Definition: vec.h:282
owl::common::vec_t
Definition: vec.h:33
owl::common::vec_t< T, 3 >
Definition: vec.h:143
owl::common::vec_t< T, 4 >::y
T y
Definition: vec.h:282
owl::common::operator==
bool operator==(const AffineSpaceT< L > &a, const AffineSpaceT< L > &b)
Comparison Operators.
Definition: AffineSpace.h:146
owl::common::gt
__both__ auto gt(const vec_t< T, N > &a, const vec_t< T, N > &b) -> decltype(lt(b, a))
Definition: compare.h:145
owl
Definition: APIContext.cpp:36
owl::common::vec_t< T, 3 >::x
T x
Definition: vec.h:194
owl::common::le
__both__ auto le(const vec_t< T, N > &a, const vec_t< T, N > &b) -> decltype(nt(lt(b, a)))
Definition: compare.h:136
owl::common::nt
__both__ auto nt(const vec_t< T, 2 > &a) -> vec_t< decltype(!a.x), 2 >
Definition: compare.h:70
owl::common::vec_t< T, 2 >::x
T x
Definition: vec.h:133
__both__
#define __both__
Definition: owl-common.h:102
owl::common::vec_t< T, 4 >
Definition: vec.h:228
owl::common::any
__both__ bool any(const vec_t< T, N > &a)
Definition: compare.h:163