codebase / stimlib

Commit d82f78583f0990449019f4b225b2c236f535f95a

Authored by David Mayerich
1 parent 9b563709

fixed excess files

Showing 9 changed files with 0 additions and 1298 deletions   Show diff stats
Inline Side-by-side
stim/math/.vec3.h.swp deleted
View file @9b56370
No preview for this file type
stim/math/.vec3_BASE_62876.h.swp deleted
View file @9b56370
No preview for this file type
stim/math/.vec3_LOCAL_62876.h.swp deleted
View file @9b56370
No preview for this file type
stim/math/.vec3_REMOTE_62876.h.swp deleted
View file @9b56370
No preview for this file type
stim/math/vec3.h.orig deleted
View file @9b56370
1 -#ifndef STIM_VEC3_H  
2 -#define STIM_VEC3_H  
3 -  
4 -  
5 -#include <stim/cuda/cudatools/callable.h>  
6 -#include <cmath>  
7 -  
8 -  
9 -namespace stim{  
10 -  
11 -  
12 -/// A class designed to act as a 3D vector with CUDA compatibility  
13 -template<typename T>  
14 -class vec3{  
15 -  
16 -protected:  
17 - T ptr[3];  
18 -  
19 -public:  
20 -  
21 - CUDA_CALLABLE vec3(){}  
22 -  
23 - CUDA_CALLABLE vec3(T v){  
24 - ptr[0] = ptr[1] = ptr[2] = v;  
25 - }  
26 -  
27 - CUDA_CALLABLE vec3(T x, T y, T z){  
28 - ptr[0] = x;  
29 - ptr[1] = y;  
30 - ptr[2] = z;  
31 - }  
32 -  
33 - //copy constructor  
34 - CUDA_CALLABLE vec3( const vec3<T>& other){  
35 - ptr[0] = other.ptr[0];  
36 - ptr[1] = other.ptr[1];  
37 - ptr[2] = other.ptr[2];  
38 - }  
39 -  
40 - //access an element using an index  
41 - CUDA_CALLABLE T& operator[](size_t idx){  
42 - return ptr[idx];  
43 - }  
44 -  
45 - CUDA_CALLABLE T* data(){  
46 - return ptr;  
47 - }  
48 -  
49 -/// Casting operator. Creates a new vector with a new type U.  
50 - template< typename U >  
51 - CUDA_CALLABLE operator vec3<U>(){  
52 - vec3<U> result;  
53 - result.ptr[0] = (U)ptr[0];  
54 - result.ptr[1] = (U)ptr[1];  
55 - result.ptr[2] = (U)ptr[2];  
56 -  
57 - return result;  
58 - }  
59 -  
60 - // computes the squared Euclidean length (useful for several operations where only >, =, or < matter)  
61 - CUDA_CALLABLE T len_sq() const{  
62 - return ptr[0] * ptr[0] + ptr[1] * ptr[1] + ptr[2] * ptr[2];  
63 - }  
64 -  
65 - /// computes the Euclidean length of the vector  
66 - CUDA_CALLABLE T len() const{  
67 - return sqrt(len_sq());  
68 - }  
69 -  
70 -  
71 - /// Convert the vector from cartesian to spherical coordinates (x, y, z -> r, theta, phi where theta = [0, 2*pi])  
72 - CUDA_CALLABLE vec3<T> cart2sph() const{  
73 - vec3<T> sph;  
74 - sph.ptr[0] = len();  
75 - sph.ptr[1] = std::atan2(ptr[1], ptr[0]);  
76 - if(sph.ptr[0] == 0)  
77 - sph.ptr[2] = 0;  
78 - else  
79 - sph.ptr[2] = std::acos(ptr[2] / sph.ptr[0]);  
80 - return sph;  
81 - }  
82 -  
83 - /// Convert the vector from cartesian to spherical coordinates (r, theta, phi -> x, y, z where theta = [0, 2*pi])  
84 - CUDA_CALLABLE vec3<T> sph2cart() const{  
85 - vec3<T> cart;  
86 - cart.ptr[0] = ptr[0] * std::cos(ptr[1]) * std::sin(ptr[2]);  
87 - cart.ptr[1] = ptr[0] * std::sin(ptr[1]) * std::sin(ptr[2]);  
88 - cart.ptr[2] = ptr[0] * std::cos(ptr[2]);  
89 -  
90 - return cart;  
91 - }  
92 -  
93 - /// Computes the normalized vector (where each coordinate is divided by the L2 norm)  
94 - CUDA_CALLABLE vec3<T> norm() const{  
95 - vec3<T> result;  
96 - T l = len(); //compute the vector length  
97 - return (*this) / l;  
98 - }  
99 -  
100 - /// Computes the cross product of a 3-dimensional vector  
101 - CUDA_CALLABLE vec3<T> cross(const vec3<T> rhs) const{  
102 -  
103 - vec3<T> result;  
104 -  
105 - result[0] = (ptr[1] * rhs.ptr[2] - ptr[2] * rhs.ptr[1]);  
106 - result[1] = (ptr[2] * rhs.ptr[0] - ptr[0] * rhs.ptr[2]);  
107 - result[2] = (ptr[0] * rhs.ptr[1] - ptr[1] * rhs.ptr[0]);  
108 -  
109 - return result;  
110 - }  
111 -  
112 - /// Compute the Euclidean inner (dot) product  
113 - CUDA_CALLABLE T dot(vec3<T> rhs) const{  
114 - return ptr[0] * rhs.ptr[0] + ptr[1] * rhs.ptr[1] + ptr[2] * rhs.ptr[2];  
115 - }  
116 -  
117 - /// Arithmetic addition operator  
118 -  
119 - /// @param rhs is the right-hand-side operator for the addition  
120 - CUDA_CALLABLE vec3<T> operator+(vec3<T> rhs) const{  
121 - vec3<T> result;  
122 - result.ptr[0] = ptr[0] + rhs[0];  
123 - result.ptr[1] = ptr[1] + rhs[1];  
124 - result.ptr[2] = ptr[2] + rhs[2];  
125 - return result;  
126 - }  
127 -  
128 - /// Arithmetic addition to a scalar  
129 -  
130 - /// @param rhs is the right-hand-side operator for the addition  
131 - CUDA_CALLABLE vec3<T> operator+(T rhs) const{  
132 - vec3<T> result;  
133 - result.ptr[0] = ptr[0] + rhs;  
134 - result.ptr[1] = ptr[1] + rhs;  
135 - result.ptr[2] = ptr[2] + rhs;  
136 - return result;  
137 - }  
138 -  
139 - /// Arithmetic subtraction operator  
140 -  
141 - /// @param rhs is the right-hand-side operator for the subtraction  
142 - CUDA_CALLABLE vec3<T> operator-(vec3<T> rhs) const{  
143 - vec3<T> result;  
144 - result.ptr[0] = ptr[0] - rhs[0];  
145 - result.ptr[1] = ptr[1] - rhs[1];  
146 - result.ptr[2] = ptr[2] - rhs[2];  
147 - return result;  
148 - }  
149 - /// Arithmetic subtraction to a scalar  
150 -  
151 - /// @param rhs is the right-hand-side operator for the addition  
152 - CUDA_CALLABLE vec3<T> operator-(T rhs) const{  
153 - vec3<T> result;  
154 - result.ptr[0] = ptr[0] - rhs;  
155 - result.ptr[1] = ptr[1] - rhs;  
156 - result.ptr[2] = ptr[2] - rhs;  
157 - return result;  
158 - }  
159 -  
160 - /// Arithmetic scalar multiplication operator  
161 -  
162 - /// @param rhs is the right-hand-side operator for the subtraction  
163 - CUDA_CALLABLE vec3<T> operator*(T rhs) const{  
164 - vec3<T> result;  
165 - result.ptr[0] = ptr[0] * rhs;  
166 - result.ptr[1] = ptr[1] * rhs;  
167 - result.ptr[2] = ptr[2] * rhs;  
168 - return result;  
169 - }  
170 -  
171 - /// Arithmetic scalar division operator  
172 -  
173 - /// @param rhs is the right-hand-side operator for the subtraction  
174 - CUDA_CALLABLE vec3<T> operator/(T rhs) const{  
175 - return (*this) * ((T)1.0/rhs);  
176 - }  
177 -  
178 - /// Multiplication by a scalar, followed by assignment  
179 - CUDA_CALLABLE vec3<T> operator*=(T rhs){  
180 - ptr[0] = ptr[0] * rhs;  
181 - ptr[1] = ptr[1] * rhs;  
182 - ptr[2] = ptr[2] * rhs;  
183 - return *this;  
184 - }  
185 -  
186 - /// Addition and assignment  
187 - CUDA_CALLABLE vec3<T> operator+=(vec3<T> rhs){  
188 - ptr[0] = ptr[0] + rhs;  
189 - ptr[1] = ptr[1] + rhs;  
190 - ptr[2] = ptr[2] + rhs;  
191 - return *this;  
192 - }  
193 -  
194 - /// Assign a scalar to all values  
195 - CUDA_CALLABLE vec3<T> & operator=(T rhs){  
196 - ptr[0] = ptr[0] = rhs;  
197 - ptr[1] = ptr[1] = rhs;  
198 - ptr[2] = ptr[2] = rhs;  
199 - return *this;  
200 - }  
201 -  
202 - /// Casting and assignment  
203 - template<typename Y>  
204 - CUDA_CALLABLE vec3<T> & operator=(vec3<Y> rhs){  
205 - ptr[0] = (T)rhs.ptr[0];  
206 - ptr[1] = (T)rhs.ptr[1];  
207 - ptr[2] = (T)rhs.ptr[2];  
208 - return *this;  
209 - }  
210 -  
211 - /// Unary minus (returns the negative of the vector)  
212 - CUDA_CALLABLE vec3<T> operator-() const{  
213 - vec3<T> result;  
214 - result.ptr[0] = -ptr[0];  
215 - result.ptr[1] = -ptr[1];  
216 - result.ptr[2] = -ptr[2];  
217 - return result;  
218 - }  
219 -  
220 -<<<<<<< HEAD  
221 -//#ifndef __NVCC__  
222 -=======  
223 ->>>>>>> 9f5c0d4a055a2a19e69a97db1441aa617f96180c  
224 - /// Outputs the vector as a string  
225 - std::string str() const{  
226 - std::stringstream ss;  
227 -  
228 - const size_t N = 3;  
229 -  
230 - ss<<"[";  
231 - for(size_t i=0; i<N; i++)  
232 - {  
233 - ss<<ptr[i];  
234 - if(i != N-1)  
235 - ss<<", ";  
236 - }  
237 - ss<<"]";  
238 -  
239 - return ss.str();  
240 - }  
241 -<<<<<<< HEAD  
242 -//#endif  
243 -=======  
244 ->>>>>>> 9f5c0d4a055a2a19e69a97db1441aa617f96180c  
245 -  
246 - size_t size(){ return 3; }  
247 -  
248 - }; //end class vec3  
249 -} //end namespace stim  
250 -  
251 -/// Multiply a vector by a constant when the vector is on the right hand side  
252 -template <typename T>  
253 -stim::vec3<T> operator*(T lhs, stim::vec3<T> rhs){  
254 - return rhs * lhs;  
255 -}  
256 -  
257 -//stream operator  
258 -template<typename T>  
259 -std::ostream& operator<<(std::ostream& os, stim::vec3<T> const& rhs){  
260 - os<<rhs.str();  
261 - return os;  
262 -}  
263 -  
264 -#endif  
stim/math/vec3_BACKUP_62876.h deleted
View file @9b56370
1 -#ifndef STIM_VEC3_H  
2 -#define STIM_VEC3_H  
3 -  
4 -  
5 -#include <stim/cuda/cudatools/callable.h>  
6 -#include <cmath>  
7 -  
8 -  
9 -namespace stim{  
10 -  
11 -  
12 -/// A class designed to act as a 3D vector with CUDA compatibility  
13 -template<typename T>  
14 -class vec3{  
15 -  
16 -protected:  
17 - T ptr[3];  
18 -  
19 -public:  
20 -  
21 - CUDA_CALLABLE vec3(){}  
22 -  
23 - CUDA_CALLABLE vec3(T v){  
24 - ptr[0] = ptr[1] = ptr[2] = v;  
25 - }  
26 -  
27 - CUDA_CALLABLE vec3(T x, T y, T z){  
28 - ptr[0] = x;  
29 - ptr[1] = y;  
30 - ptr[2] = z;  
31 - }  
32 -  
33 - //copy constructor  
34 - CUDA_CALLABLE vec3( const vec3<T>& other){  
35 - ptr[0] = other.ptr[0];  
36 - ptr[1] = other.ptr[1];  
37 - ptr[2] = other.ptr[2];  
38 - }  
39 -  
40 - //access an element using an index  
41 - CUDA_CALLABLE T& operator[](size_t idx){  
42 - return ptr[idx];  
43 - }  
44 -  
45 - CUDA_CALLABLE T* data(){  
46 - return ptr;  
47 - }  
48 -  
49 -/// Casting operator. Creates a new vector with a new type U.  
50 - template< typename U >  
51 - CUDA_CALLABLE operator vec3<U>(){  
52 - vec3<U> result;  
53 - result.ptr[0] = (U)ptr[0];  
54 - result.ptr[1] = (U)ptr[1];  
55 - result.ptr[2] = (U)ptr[2];  
56 -  
57 - return result;  
58 - }  
59 -  
60 - // computes the squared Euclidean length (useful for several operations where only >, =, or < matter)  
61 - CUDA_CALLABLE T len_sq() const{  
62 - return ptr[0] * ptr[0] + ptr[1] * ptr[1] + ptr[2] * ptr[2];  
63 - }  
64 -  
65 - /// computes the Euclidean length of the vector  
66 - CUDA_CALLABLE T len() const{  
67 - return sqrt(len_sq());  
68 - }  
69 -  
70 -  
71 - /// Convert the vector from cartesian to spherical coordinates (x, y, z -> r, theta, phi where theta = [0, 2*pi])  
72 - CUDA_CALLABLE vec3<T> cart2sph() const{  
73 - vec3<T> sph;  
74 - sph.ptr[0] = len();  
75 - sph.ptr[1] = std::atan2(ptr[1], ptr[0]);  
76 - if(sph.ptr[0] == 0)  
77 - sph.ptr[2] = 0;  
78 - else  
79 - sph.ptr[2] = std::acos(ptr[2] / sph.ptr[0]);  
80 - return sph;  
81 - }  
82 -  
83 - /// Convert the vector from cartesian to spherical coordinates (r, theta, phi -> x, y, z where theta = [0, 2*pi])  
84 - CUDA_CALLABLE vec3<T> sph2cart() const{  
85 - vec3<T> cart;  
86 - cart.ptr[0] = ptr[0] * std::cos(ptr[1]) * std::sin(ptr[2]);  
87 - cart.ptr[1] = ptr[0] * std::sin(ptr[1]) * std::sin(ptr[2]);  
88 - cart.ptr[2] = ptr[0] * std::cos(ptr[2]);  
89 -  
90 - return cart;  
91 - }  
92 -  
93 - /// Computes the normalized vector (where each coordinate is divided by the L2 norm)  
94 - CUDA_CALLABLE vec3<T> norm() const{  
95 - vec3<T> result;  
96 - T l = len(); //compute the vector length  
97 - return (*this) / l;  
98 - }  
99 -  
100 - /// Computes the cross product of a 3-dimensional vector  
101 - CUDA_CALLABLE vec3<T> cross(const vec3<T> rhs) const{  
102 -  
103 - vec3<T> result;  
104 -  
105 - result[0] = (ptr[1] * rhs.ptr[2] - ptr[2] * rhs.ptr[1]);  
106 - result[1] = (ptr[2] * rhs.ptr[0] - ptr[0] * rhs.ptr[2]);  
107 - result[2] = (ptr[0] * rhs.ptr[1] - ptr[1] * rhs.ptr[0]);  
108 -  
109 - return result;  
110 - }  
111 -  
112 - /// Compute the Euclidean inner (dot) product  
113 - CUDA_CALLABLE T dot(vec3<T> rhs) const{  
114 - return ptr[0] * rhs.ptr[0] + ptr[1] * rhs.ptr[1] + ptr[2] * rhs.ptr[2];  
115 - }  
116 -  
117 - /// Arithmetic addition operator  
118 -  
119 - /// @param rhs is the right-hand-side operator for the addition  
120 - CUDA_CALLABLE vec3<T> operator+(vec3<T> rhs) const{  
121 - vec3<T> result;  
122 - result.ptr[0] = ptr[0] + rhs[0];  
123 - result.ptr[1] = ptr[1] + rhs[1];  
124 - result.ptr[2] = ptr[2] + rhs[2];  
125 - return result;  
126 - }  
127 -  
128 - /// Arithmetic addition to a scalar  
129 -  
130 - /// @param rhs is the right-hand-side operator for the addition  
131 - CUDA_CALLABLE vec3<T> operator+(T rhs) const{  
132 - vec3<T> result;  
133 - result.ptr[0] = ptr[0] + rhs;  
134 - result.ptr[1] = ptr[1] + rhs;  
135 - result.ptr[2] = ptr[2] + rhs;  
136 - return result;  
137 - }  
138 -  
139 - /// Arithmetic subtraction operator  
140 -  
141 - /// @param rhs is the right-hand-side operator for the subtraction  
142 - CUDA_CALLABLE vec3<T> operator-(vec3<T> rhs) const{  
143 - vec3<T> result;  
144 - result.ptr[0] = ptr[0] - rhs[0];  
145 - result.ptr[1] = ptr[1] - rhs[1];  
146 - result.ptr[2] = ptr[2] - rhs[2];  
147 - return result;  
148 - }  
149 - /// Arithmetic subtraction to a scalar  
150 -  
151 - /// @param rhs is the right-hand-side operator for the addition  
152 - CUDA_CALLABLE vec3<T> operator-(T rhs) const{  
153 - vec3<T> result;  
154 - result.ptr[0] = ptr[0] - rhs;  
155 - result.ptr[1] = ptr[1] - rhs;  
156 - result.ptr[2] = ptr[2] - rhs;  
157 - return result;  
158 - }  
159 -  
160 - /// Arithmetic scalar multiplication operator  
161 -  
162 - /// @param rhs is the right-hand-side operator for the subtraction  
163 - CUDA_CALLABLE vec3<T> operator*(T rhs) const{  
164 - vec3<T> result;  
165 - result.ptr[0] = ptr[0] * rhs;  
166 - result.ptr[1] = ptr[1] * rhs;  
167 - result.ptr[2] = ptr[2] * rhs;  
168 - return result;  
169 - }  
170 -  
171 - /// Arithmetic scalar division operator  
172 -  
173 - /// @param rhs is the right-hand-side operator for the subtraction  
174 - CUDA_CALLABLE vec3<T> operator/(T rhs) const{  
175 - return (*this) * ((T)1.0/rhs);  
176 - }  
177 -  
178 - /// Multiplication by a scalar, followed by assignment  
179 - CUDA_CALLABLE vec3<T> operator*=(T rhs){  
180 - ptr[0] = ptr[0] * rhs;  
181 - ptr[1] = ptr[1] * rhs;  
182 - ptr[2] = ptr[2] * rhs;  
183 - return *this;  
184 - }  
185 -  
186 - /// Addition and assignment  
187 - CUDA_CALLABLE vec3<T> operator+=(vec3<T> rhs){  
188 - ptr[0] = ptr[0] + rhs;  
189 - ptr[1] = ptr[1] + rhs;  
190 - ptr[2] = ptr[2] + rhs;  
191 - return *this;  
192 - }  
193 -  
194 - /// Assign a scalar to all values  
195 - CUDA_CALLABLE vec3<T> & operator=(T rhs){  
196 - ptr[0] = ptr[0] = rhs;  
197 - ptr[1] = ptr[1] = rhs;  
198 - ptr[2] = ptr[2] = rhs;  
199 - return *this;  
200 - }  
201 -  
202 - /// Casting and assignment  
203 - template<typename Y>  
204 - CUDA_CALLABLE vec3<T> & operator=(vec3<Y> rhs){  
205 - ptr[0] = (T)rhs.ptr[0];  
206 - ptr[1] = (T)rhs.ptr[1];  
207 - ptr[2] = (T)rhs.ptr[2];  
208 - return *this;  
209 - }  
210 -  
211 - /// Unary minus (returns the negative of the vector)  
212 - CUDA_CALLABLE vec3<T> operator-() const{  
213 - vec3<T> result;  
214 - result.ptr[0] = -ptr[0];  
215 - result.ptr[1] = -ptr[1];  
216 - result.ptr[2] = -ptr[2];  
217 - return result;  
218 - }  
219 -  
220 -<<<<<<< HEAD  
221 -//#ifndef __NVCC__  
222 -=======  
223 ->>>>>>> 9f5c0d4a055a2a19e69a97db1441aa617f96180c  
224 - /// Outputs the vector as a string  
225 - std::string str() const{  
226 - std::stringstream ss;  
227 -  
228 - const size_t N = 3;  
229 -  
230 - ss<<"[";  
231 - for(size_t i=0; i<N; i++)  
232 - {  
233 - ss<<ptr[i];  
234 - if(i != N-1)  
235 - ss<<", ";  
236 - }  
237 - ss<<"]";  
238 -  
239 - return ss.str();  
240 - }  
241 -<<<<<<< HEAD  
242 -//#endif  
243 -=======  
244 ->>>>>>> 9f5c0d4a055a2a19e69a97db1441aa617f96180c  
245 -  
246 - size_t size(){ return 3; }  
247 -  
248 - }; //end class vec3  
249 -} //end namespace stim  
250 -  
251 -/// Multiply a vector by a constant when the vector is on the right hand side  
252 -template <typename T>  
253 -stim::vec3<T> operator*(T lhs, stim::vec3<T> rhs){  
254 - return rhs * lhs;  
255 -}  
256 -  
257 -//stream operator  
258 -template<typename T>  
259 -std::ostream& operator<<(std::ostream& os, stim::vec3<T> const& rhs){  
260 - os<<rhs.str();  
261 - return os;  
262 -}  
263 -  
264 -#endif  
stim/math/vec3_BASE_62876.h deleted
View file @9b56370
1 -#ifndef STIM_VEC3_H  
2 -#define STIM_VEC3_H  
3 -  
4 -  
5 -#include <stim/cuda/cudatools/callable.h>  
6 -  
7 -  
8 -namespace stim{  
9 -  
10 -  
11 -/// A class designed to act as a 3D vector with CUDA compatibility  
12 -template<typename T>  
13 -class vec3{  
14 -  
15 -protected:  
16 - T ptr[3];  
17 -  
18 -public:  
19 -  
20 - CUDA_CALLABLE vec3(){}  
21 -  
22 - CUDA_CALLABLE vec3(T v){  
23 - ptr[0] = ptr[1] = ptr[2] = v;  
24 - }  
25 -  
26 - CUDA_CALLABLE vec3(T x, T y, T z){  
27 - ptr[0] = x;  
28 - ptr[1] = y;  
29 - ptr[2] = z;  
30 - }  
31 -  
32 - //copy constructor  
33 - CUDA_CALLABLE vec3( const vec3<T>& other){  
34 - ptr[0] = other.ptr[0];  
35 - ptr[1] = other.ptr[1];  
36 - ptr[2] = other.ptr[2];  
37 - }  
38 -  
39 - //access an element using an index  
40 - CUDA_CALLABLE T& operator[](size_t idx){  
41 - return ptr[idx];  
42 - }  
43 -  
44 - CUDA_CALLABLE T* data(){  
45 - return ptr;  
46 - }  
47 -  
48 -/// Casting operator. Creates a new vector with a new type U.  
49 - template< typename U >  
50 - CUDA_CALLABLE operator vec3<U>(){  
51 - vec3<U> result;  
52 - result.ptr[0] = (U)ptr[0];  
53 - result.ptr[1] = (U)ptr[1];  
54 - result.ptr[2] = (U)ptr[2];  
55 -  
56 - return result;  
57 - }  
58 -  
59 - // computes the squared Euclidean length (useful for several operations where only >, =, or < matter)  
60 - CUDA_CALLABLE T len_sq() const{  
61 - return ptr[0] * ptr[0] + ptr[1] * ptr[1] + ptr[2] * ptr[2];  
62 - }  
63 -  
64 - /// computes the Euclidean length of the vector  
65 - CUDA_CALLABLE T len() const{  
66 - return sqrt(len_sq());  
67 - }  
68 -  
69 -  
70 - /// Convert the vector from cartesian to spherical coordinates (x, y, z -> r, theta, phi where theta = [0, 2*pi])  
71 - CUDA_CALLABLE vec3<T> cart2sph() const{  
72 - vec3<T> sph;  
73 - sph.ptr[0] = len();  
74 - sph.ptr[1] = std::atan2(ptr[1], ptr[0]);  
75 - if(sph.ptr[0] == 0)  
76 - sph.ptr[2] = 0;  
77 - else  
78 - sph.ptr[2] = std::acos(ptr[2] / sph.ptr[0]);  
79 - return sph;  
80 - }  
81 -  
82 - /// Convert the vector from cartesian to spherical coordinates (r, theta, phi -> x, y, z where theta = [0, 2*pi])  
83 - CUDA_CALLABLE vec3<T> sph2cart() const{  
84 - vec3<T> cart;  
85 - cart.ptr[0] = ptr[0] * std::cos(ptr[1]) * std::sin(ptr[2]);  
86 - cart.ptr[1] = ptr[0] * std::sin(ptr[1]) * std::sin(ptr[2]);  
87 - cart.ptr[2] = ptr[0] * std::cos(ptr[2]);  
88 -  
89 - return cart;  
90 - }  
91 -  
92 - /// Computes the normalized vector (where each coordinate is divided by the L2 norm)  
93 - CUDA_CALLABLE vec3<T> norm() const{  
94 - vec3<T> result;  
95 - T l = len(); //compute the vector length  
96 - return (*this) / l;  
97 - }  
98 -  
99 - /// Computes the cross product of a 3-dimensional vector  
100 - CUDA_CALLABLE vec3<T> cross(const vec3<T> rhs) const{  
101 -  
102 - vec3<T> result;  
103 -  
104 - result[0] = (ptr[1] * rhs.ptr[2] - ptr[2] * rhs.ptr[1]);  
105 - result[1] = (ptr[2] * rhs.ptr[0] - ptr[0] * rhs.ptr[2]);  
106 - result[2] = (ptr[0] * rhs.ptr[1] - ptr[1] * rhs.ptr[0]);  
107 -  
108 - return result;  
109 - }  
110 -  
111 - /// Compute the Euclidean inner (dot) product  
112 - CUDA_CALLABLE T dot(vec3<T> rhs) const{  
113 - return ptr[0] * rhs.ptr[0] + ptr[1] * rhs.ptr[1] + ptr[2] * rhs.ptr[2];  
114 - }  
115 -  
116 - /// Arithmetic addition operator  
117 -  
118 - /// @param rhs is the right-hand-side operator for the addition  
119 - CUDA_CALLABLE vec3<T> operator+(vec3<T> rhs) const{  
120 - vec3<T> result;  
121 - result.ptr[0] = ptr[0] + rhs[0];  
122 - result.ptr[1] = ptr[1] + rhs[1];  
123 - result.ptr[2] = ptr[2] + rhs[2];  
124 - return result;  
125 - }  
126 -  
127 - /// Arithmetic addition to a scalar  
128 -  
129 - /// @param rhs is the right-hand-side operator for the addition  
130 - CUDA_CALLABLE vec3<T> operator+(T rhs) const{  
131 - vec3<T> result;  
132 - result.ptr[0] = ptr[0] + rhs;  
133 - result.ptr[1] = ptr[1] + rhs;  
134 - result.ptr[2] = ptr[2] + rhs;  
135 - return result;  
136 - }  
137 -  
138 - /// Arithmetic subtraction operator  
139 -  
140 - /// @param rhs is the right-hand-side operator for the subtraction  
141 - CUDA_CALLABLE vec3<T> operator-(vec3<T> rhs) const{  
142 - vec3<T> result;  
143 - result.ptr[0] = ptr[0] - rhs[0];  
144 - result.ptr[1] = ptr[1] - rhs[1];  
145 - result.ptr[2] = ptr[2] - rhs[2];  
146 - return result;  
147 - }  
148 - /// Arithmetic subtraction to a scalar  
149 -  
150 - /// @param rhs is the right-hand-side operator for the addition  
151 - CUDA_CALLABLE vec3<T> operator-(T rhs) const{  
152 - vec3<T> result;  
153 - result.ptr[0] = ptr[0] - rhs;  
154 - result.ptr[1] = ptr[1] - rhs;  
155 - result.ptr[2] = ptr[2] - rhs;  
156 - return result;  
157 - }  
158 -  
159 - /// Arithmetic scalar multiplication operator  
160 -  
161 - /// @param rhs is the right-hand-side operator for the subtraction  
162 - CUDA_CALLABLE vec3<T> operator*(T rhs) const{  
163 - vec3<T> result;  
164 - result.ptr[0] = ptr[0] * rhs;  
165 - result.ptr[1] = ptr[1] * rhs;  
166 - result.ptr[2] = ptr[2] * rhs;  
167 - return result;  
168 - }  
169 -  
170 - /// Arithmetic scalar division operator  
171 -  
172 - /// @param rhs is the right-hand-side operator for the subtraction  
173 - CUDA_CALLABLE vec3<T> operator/(T rhs) const{  
174 - return (*this) * ((T)1.0/rhs);  
175 - }  
176 -  
177 - /// Multiplication by a scalar, followed by assignment  
178 - CUDA_CALLABLE vec3<T> operator*=(T rhs){  
179 - ptr[0] = ptr[0] * rhs;  
180 - ptr[1] = ptr[1] * rhs;  
181 - ptr[2] = ptr[2] * rhs;  
182 - return *this;  
183 - }  
184 -  
185 - /// Addition and assignment  
186 - CUDA_CALLABLE vec3<T> operator+=(vec3<T> rhs){  
187 - ptr[0] = ptr[0] + rhs;  
188 - ptr[1] = ptr[1] + rhs;  
189 - ptr[2] = ptr[2] + rhs;  
190 - return *this;  
191 - }  
192 -  
193 - /// Assign a scalar to all values  
194 - CUDA_CALLABLE vec3<T> & operator=(T rhs){  
195 - ptr[0] = ptr[0] = rhs;  
196 - ptr[1] = ptr[1] = rhs;  
197 - ptr[2] = ptr[2] = rhs;  
198 - return *this;  
199 - }  
200 -  
201 - /// Casting and assignment  
202 - template<typename Y>  
203 - CUDA_CALLABLE vec3<T> & operator=(vec3<Y> rhs){  
204 - ptr[0] = (T)rhs.ptr[0];  
205 - ptr[1] = (T)rhs.ptr[1];  
206 - ptr[2] = (T)rhs.ptr[2];  
207 - return *this;  
208 - }  
209 -  
210 - /// Unary minus (returns the negative of the vector)  
211 - CUDA_CALLABLE vec3<T> operator-() const{  
212 - vec3<T> result;  
213 - result.ptr[0] = -ptr[0];  
214 - result.ptr[1] = -ptr[1];  
215 - result.ptr[2] = -ptr[2];  
216 - return result;  
217 - }  
218 -  
219 -#ifndef __NVCC__  
220 - /// Outputs the vector as a string  
221 - std::string str() const{  
222 - std::stringstream ss;  
223 -  
224 - const size_t N = 3;  
225 -  
226 - ss<<"[";  
227 - for(size_t i=0; i<N; i++)  
228 - {  
229 - ss<<ptr[i];  
230 - if(i != N-1)  
231 - ss<<", ";  
232 - }  
233 - ss<<"]";  
234 -  
235 - return ss.str();  
236 - }  
237 -#endif  
238 -  
239 - size_t size(){ return 3; }  
240 -  
241 - }; //end class vec3  
242 -} //end namespace stim  
243 -  
244 -/// Multiply a vector by a constant when the vector is on the right hand side  
245 -template <typename T>  
246 -stim::vec3<T> operator*(T lhs, stim::vec3<T> rhs){  
247 - return rhs * lhs;  
248 -}  
249 -  
250 -//stream operator  
251 -template<typename T>  
252 -std::ostream& operator<<(std::ostream& os, stim::vec3<T> const& rhs){  
253 - os<<rhs.str();  
254 - return os;  
255 -}  
256 -  
257 -#endif  
stim/math/vec3_LOCAL_62876.h deleted
View file @9b56370
1 -#ifndef STIM_VEC3_H  
2 -#define STIM_VEC3_H  
3 -  
4 -  
5 -#include <stim/cuda/cudatools/callable.h>  
6 -  
7 -  
8 -namespace stim{  
9 -  
10 -  
11 -/// A class designed to act as a 3D vector with CUDA compatibility  
12 -template<typename T>  
13 -class vec3{  
14 -  
15 -protected:  
16 - T ptr[3];  
17 -  
18 -public:  
19 -  
20 - CUDA_CALLABLE vec3(){}  
21 -  
22 - CUDA_CALLABLE vec3(T v){  
23 - ptr[0] = ptr[1] = ptr[2] = v;  
24 - }  
25 -  
26 - CUDA_CALLABLE vec3(T x, T y, T z){  
27 - ptr[0] = x;  
28 - ptr[1] = y;  
29 - ptr[2] = z;  
30 - }  
31 -  
32 - //copy constructor  
33 - CUDA_CALLABLE vec3( const vec3<T>& other){  
34 - ptr[0] = other.ptr[0];  
35 - ptr[1] = other.ptr[1];  
36 - ptr[2] = other.ptr[2];  
37 - }  
38 -  
39 - //access an element using an index  
40 - CUDA_CALLABLE T& operator[](size_t idx){  
41 - return ptr[idx];  
42 - }  
43 -  
44 - CUDA_CALLABLE T* data(){  
45 - return ptr;  
46 - }  
47 -  
48 -/// Casting operator. Creates a new vector with a new type U.  
49 - template< typename U >  
50 - CUDA_CALLABLE operator vec3<U>(){  
51 - vec3<U> result;  
52 - result.ptr[0] = (U)ptr[0];  
53 - result.ptr[1] = (U)ptr[1];  
54 - result.ptr[2] = (U)ptr[2];  
55 -  
56 - return result;  
57 - }  
58 -  
59 - // computes the squared Euclidean length (useful for several operations where only >, =, or < matter)  
60 - CUDA_CALLABLE T len_sq() const{  
61 - return ptr[0] * ptr[0] + ptr[1] * ptr[1] + ptr[2] * ptr[2];  
62 - }  
63 -  
64 - /// computes the Euclidean length of the vector  
65 - CUDA_CALLABLE T len() const{  
66 - return sqrt(len_sq());  
67 - }  
68 -  
69 -  
70 - /// Convert the vector from cartesian to spherical coordinates (x, y, z -> r, theta, phi where theta = [0, 2*pi])  
71 - CUDA_CALLABLE vec3<T> cart2sph() const{  
72 - vec3<T> sph;  
73 - sph.ptr[0] = len();  
74 - sph.ptr[1] = std::atan2(ptr[1], ptr[0]);  
75 - if(sph.ptr[0] == 0)  
76 - sph.ptr[2] = 0;  
77 - else  
78 - sph.ptr[2] = std::acos(ptr[2] / sph.ptr[0]);  
79 - return sph;  
80 - }  
81 -  
82 - /// Convert the vector from cartesian to spherical coordinates (r, theta, phi -> x, y, z where theta = [0, 2*pi])  
83 - CUDA_CALLABLE vec3<T> sph2cart() const{  
84 - vec3<T> cart;  
85 - cart.ptr[0] = ptr[0] * std::cos(ptr[1]) * std::sin(ptr[2]);  
86 - cart.ptr[1] = ptr[0] * std::sin(ptr[1]) * std::sin(ptr[2]);  
87 - cart.ptr[2] = ptr[0] * std::cos(ptr[2]);  
88 -  
89 - return cart;  
90 - }  
91 -  
92 - /// Computes the normalized vector (where each coordinate is divided by the L2 norm)  
93 - CUDA_CALLABLE vec3<T> norm() const{  
94 - vec3<T> result;  
95 - T l = len(); //compute the vector length  
96 - return (*this) / l;  
97 - }  
98 -  
99 - /// Computes the cross product of a 3-dimensional vector  
100 - CUDA_CALLABLE vec3<T> cross(const vec3<T> rhs) const{  
101 -  
102 - vec3<T> result;  
103 -  
104 - result[0] = (ptr[1] * rhs.ptr[2] - ptr[2] * rhs.ptr[1]);  
105 - result[1] = (ptr[2] * rhs.ptr[0] - ptr[0] * rhs.ptr[2]);  
106 - result[2] = (ptr[0] * rhs.ptr[1] - ptr[1] * rhs.ptr[0]);  
107 -  
108 - return result;  
109 - }  
110 -  
111 - /// Compute the Euclidean inner (dot) product  
112 - CUDA_CALLABLE T dot(vec3<T> rhs) const{  
113 - return ptr[0] * rhs.ptr[0] + ptr[1] * rhs.ptr[1] + ptr[2] * rhs.ptr[2];  
114 - }  
115 -  
116 - /// Arithmetic addition operator  
117 -  
118 - /// @param rhs is the right-hand-side operator for the addition  
119 - CUDA_CALLABLE vec3<T> operator+(vec3<T> rhs) const{  
120 - vec3<T> result;  
121 - result.ptr[0] = ptr[0] + rhs[0];  
122 - result.ptr[1] = ptr[1] + rhs[1];  
123 - result.ptr[2] = ptr[2] + rhs[2];  
124 - return result;  
125 - }  
126 -  
127 - /// Arithmetic addition to a scalar  
128 -  
129 - /// @param rhs is the right-hand-side operator for the addition  
130 - CUDA_CALLABLE vec3<T> operator+(T rhs) const{  
131 - vec3<T> result;  
132 - result.ptr[0] = ptr[0] + rhs;  
133 - result.ptr[1] = ptr[1] + rhs;  
134 - result.ptr[2] = ptr[2] + rhs;  
135 - return result;  
136 - }  
137 -  
138 - /// Arithmetic subtraction operator  
139 -  
140 - /// @param rhs is the right-hand-side operator for the subtraction  
141 - CUDA_CALLABLE vec3<T> operator-(vec3<T> rhs) const{  
142 - vec3<T> result;  
143 - result.ptr[0] = ptr[0] - rhs[0];  
144 - result.ptr[1] = ptr[1] - rhs[1];  
145 - result.ptr[2] = ptr[2] - rhs[2];  
146 - return result;  
147 - }  
148 - /// Arithmetic subtraction to a scalar  
149 -  
150 - /// @param rhs is the right-hand-side operator for the addition  
151 - CUDA_CALLABLE vec3<T> operator-(T rhs) const{  
152 - vec3<T> result;  
153 - result.ptr[0] = ptr[0] - rhs;  
154 - result.ptr[1] = ptr[1] - rhs;  
155 - result.ptr[2] = ptr[2] - rhs;  
156 - return result;  
157 - }  
158 -  
159 - /// Arithmetic scalar multiplication operator  
160 -  
161 - /// @param rhs is the right-hand-side operator for the subtraction  
162 - CUDA_CALLABLE vec3<T> operator*(T rhs) const{  
163 - vec3<T> result;  
164 - result.ptr[0] = ptr[0] * rhs;  
165 - result.ptr[1] = ptr[1] * rhs;  
166 - result.ptr[2] = ptr[2] * rhs;  
167 - return result;  
168 - }  
169 -  
170 - /// Arithmetic scalar division operator  
171 -  
172 - /// @param rhs is the right-hand-side operator for the subtraction  
173 - CUDA_CALLABLE vec3<T> operator/(T rhs) const{  
174 - return (*this) * ((T)1.0/rhs);  
175 - }  
176 -  
177 - /// Multiplication by a scalar, followed by assignment  
178 - CUDA_CALLABLE vec3<T> operator*=(T rhs){  
179 - ptr[0] = ptr[0] * rhs;  
180 - ptr[1] = ptr[1] * rhs;  
181 - ptr[2] = ptr[2] * rhs;  
182 - return *this;  
183 - }  
184 -  
185 - /// Addition and assignment  
186 - CUDA_CALLABLE vec3<T> operator+=(vec3<T> rhs){  
187 - ptr[0] = ptr[0] + rhs;  
188 - ptr[1] = ptr[1] + rhs;  
189 - ptr[2] = ptr[2] + rhs;  
190 - return *this;  
191 - }  
192 -  
193 - /// Assign a scalar to all values  
194 - CUDA_CALLABLE vec3<T> & operator=(T rhs){  
195 - ptr[0] = ptr[0] = rhs;  
196 - ptr[1] = ptr[1] = rhs;  
197 - ptr[2] = ptr[2] = rhs;  
198 - return *this;  
199 - }  
200 -  
201 - /// Casting and assignment  
202 - template<typename Y>  
203 - CUDA_CALLABLE vec3<T> & operator=(vec3<Y> rhs){  
204 - ptr[0] = (T)rhs.ptr[0];  
205 - ptr[1] = (T)rhs.ptr[1];  
206 - ptr[2] = (T)rhs.ptr[2];  
207 - return *this;  
208 - }  
209 -  
210 - /// Unary minus (returns the negative of the vector)  
211 - CUDA_CALLABLE vec3<T> operator-() const{  
212 - vec3<T> result;  
213 - result.ptr[0] = -ptr[0];  
214 - result.ptr[1] = -ptr[1];  
215 - result.ptr[2] = -ptr[2];  
216 - return result;  
217 - }  
218 -  
219 -//#ifndef __NVCC__  
220 - /// Outputs the vector as a string  
221 - std::string str() const{  
222 - std::stringstream ss;  
223 -  
224 - const size_t N = 3;  
225 -  
226 - ss<<"[";  
227 - for(size_t i=0; i<N; i++)  
228 - {  
229 - ss<<ptr[i];  
230 - if(i != N-1)  
231 - ss<<", ";  
232 - }  
233 - ss<<"]";  
234 -  
235 - return ss.str();  
236 - }  
237 -//#endif  
238 -  
239 - size_t size(){ return 3; }  
240 -  
241 - }; //end class vec3  
242 -} //end namespace stim  
243 -  
244 -/// Multiply a vector by a constant when the vector is on the right hand side  
245 -template <typename T>  
246 -stim::vec3<T> operator*(T lhs, stim::vec3<T> rhs){  
247 - return rhs * lhs;  
248 -}  
249 -  
250 -//stream operator  
251 -template<typename T>  
252 -std::ostream& operator<<(std::ostream& os, stim::vec3<T> const& rhs){  
253 - os<<rhs.str();  
254 - return os;  
255 -}  
256 -  
257 -#endif  
stim/math/vec3_REMOTE_62876.h deleted
View file @9b56370
1 -#ifndef STIM_VEC3_H  
2 -#define STIM_VEC3_H  
3 -  
4 -  
5 -#include <stim/cuda/cudatools/callable.h>  
6 -#include <cmath>  
7 -  
8 -  
9 -namespace stim{  
10 -  
11 -  
12 -/// A class designed to act as a 3D vector with CUDA compatibility  
13 -template<typename T>  
14 -class vec3{  
15 -  
16 -protected:  
17 - T ptr[3];  
18 -  
19 -public:  
20 -  
21 - CUDA_CALLABLE vec3(){}  
22 -  
23 - CUDA_CALLABLE vec3(T v){  
24 - ptr[0] = ptr[1] = ptr[2] = v;  
25 - }  
26 -  
27 - CUDA_CALLABLE vec3(T x, T y, T z){  
28 - ptr[0] = x;  
29 - ptr[1] = y;  
30 - ptr[2] = z;  
31 - }  
32 -  
33 - //copy constructor  
34 - CUDA_CALLABLE vec3( const vec3<T>& other){  
35 - ptr[0] = other.ptr[0];  
36 - ptr[1] = other.ptr[1];  
37 - ptr[2] = other.ptr[2];  
38 - }  
39 -  
40 - //access an element using an index  
41 - CUDA_CALLABLE T& operator[](size_t idx){  
42 - return ptr[idx];  
43 - }  
44 -  
45 - CUDA_CALLABLE T* data(){  
46 - return ptr;  
47 - }  
48 -  
49 -/// Casting operator. Creates a new vector with a new type U.  
50 - template< typename U >  
51 - CUDA_CALLABLE operator vec3<U>(){  
52 - vec3<U> result;  
53 - result.ptr[0] = (U)ptr[0];  
54 - result.ptr[1] = (U)ptr[1];  
55 - result.ptr[2] = (U)ptr[2];  
56 -  
57 - return result;  
58 - }  
59 -  
60 - // computes the squared Euclidean length (useful for several operations where only >, =, or < matter)  
61 - CUDA_CALLABLE T len_sq() const{  
62 - return ptr[0] * ptr[0] + ptr[1] * ptr[1] + ptr[2] * ptr[2];  
63 - }  
64 -  
65 - /// computes the Euclidean length of the vector  
66 - CUDA_CALLABLE T len() const{  
67 - return sqrt(len_sq());  
68 - }  
69 -  
70 -  
71 - /// Convert the vector from cartesian to spherical coordinates (x, y, z -> r, theta, phi where theta = [0, 2*pi])  
72 - CUDA_CALLABLE vec3<T> cart2sph() const{  
73 - vec3<T> sph;  
74 - sph.ptr[0] = len();  
75 - sph.ptr[1] = std::atan2(ptr[1], ptr[0]);  
76 - if(sph.ptr[0] == 0)  
77 - sph.ptr[2] = 0;  
78 - else  
79 - sph.ptr[2] = std::acos(ptr[2] / sph.ptr[0]);  
80 - return sph;  
81 - }  
82 -  
83 - /// Convert the vector from cartesian to spherical coordinates (r, theta, phi -> x, y, z where theta = [0, 2*pi])  
84 - CUDA_CALLABLE vec3<T> sph2cart() const{  
85 - vec3<T> cart;  
86 - cart.ptr[0] = ptr[0] * std::cos(ptr[1]) * std::sin(ptr[2]);  
87 - cart.ptr[1] = ptr[0] * std::sin(ptr[1]) * std::sin(ptr[2]);  
88 - cart.ptr[2] = ptr[0] * std::cos(ptr[2]);  
89 -  
90 - return cart;  
91 - }  
92 -  
93 - /// Computes the normalized vector (where each coordinate is divided by the L2 norm)  
94 - CUDA_CALLABLE vec3<T> norm() const{  
95 - vec3<T> result;  
96 - T l = len(); //compute the vector length  
97 - return (*this) / l;  
98 - }  
99 -  
100 - /// Computes the cross product of a 3-dimensional vector  
101 - CUDA_CALLABLE vec3<T> cross(const vec3<T> rhs) const{  
102 -  
103 - vec3<T> result;  
104 -  
105 - result[0] = (ptr[1] * rhs.ptr[2] - ptr[2] * rhs.ptr[1]);  
106 - result[1] = (ptr[2] * rhs.ptr[0] - ptr[0] * rhs.ptr[2]);  
107 - result[2] = (ptr[0] * rhs.ptr[1] - ptr[1] * rhs.ptr[0]);  
108 -  
109 - return result;  
110 - }  
111 -  
112 - /// Compute the Euclidean inner (dot) product  
113 - CUDA_CALLABLE T dot(vec3<T> rhs) const{  
114 - return ptr[0] * rhs.ptr[0] + ptr[1] * rhs.ptr[1] + ptr[2] * rhs.ptr[2];  
115 - }  
116 -  
117 - /// Arithmetic addition operator  
118 -  
119 - /// @param rhs is the right-hand-side operator for the addition  
120 - CUDA_CALLABLE vec3<T> operator+(vec3<T> rhs) const{  
121 - vec3<T> result;  
122 - result.ptr[0] = ptr[0] + rhs[0];  
123 - result.ptr[1] = ptr[1] + rhs[1];  
124 - result.ptr[2] = ptr[2] + rhs[2];  
125 - return result;  
126 - }  
127 -  
128 - /// Arithmetic addition to a scalar  
129 -  
130 - /// @param rhs is the right-hand-side operator for the addition  
131 - CUDA_CALLABLE vec3<T> operator+(T rhs) const{  
132 - vec3<T> result;  
133 - result.ptr[0] = ptr[0] + rhs;  
134 - result.ptr[1] = ptr[1] + rhs;  
135 - result.ptr[2] = ptr[2] + rhs;  
136 - return result;  
137 - }  
138 -  
139 - /// Arithmetic subtraction operator  
140 -  
141 - /// @param rhs is the right-hand-side operator for the subtraction  
142 - CUDA_CALLABLE vec3<T> operator-(vec3<T> rhs) const{  
143 - vec3<T> result;  
144 - result.ptr[0] = ptr[0] - rhs[0];  
145 - result.ptr[1] = ptr[1] - rhs[1];  
146 - result.ptr[2] = ptr[2] - rhs[2];  
147 - return result;  
148 - }  
149 - /// Arithmetic subtraction to a scalar  
150 -  
151 - /// @param rhs is the right-hand-side operator for the addition  
152 - CUDA_CALLABLE vec3<T> operator-(T rhs) const{  
153 - vec3<T> result;  
154 - result.ptr[0] = ptr[0] - rhs;  
155 - result.ptr[1] = ptr[1] - rhs;  
156 - result.ptr[2] = ptr[2] - rhs;  
157 - return result;  
158 - }  
159 -  
160 - /// Arithmetic scalar multiplication operator  
161 -  
162 - /// @param rhs is the right-hand-side operator for the subtraction  
163 - CUDA_CALLABLE vec3<T> operator*(T rhs) const{  
164 - vec3<T> result;  
165 - result.ptr[0] = ptr[0] * rhs;  
166 - result.ptr[1] = ptr[1] * rhs;  
167 - result.ptr[2] = ptr[2] * rhs;  
168 - return result;  
169 - }  
170 -  
171 - /// Arithmetic scalar division operator  
172 -  
173 - /// @param rhs is the right-hand-side operator for the subtraction  
174 - CUDA_CALLABLE vec3<T> operator/(T rhs) const{  
175 - return (*this) * ((T)1.0/rhs);  
176 - }  
177 -  
178 - /// Multiplication by a scalar, followed by assignment  
179 - CUDA_CALLABLE vec3<T> operator*=(T rhs){  
180 - ptr[0] = ptr[0] * rhs;  
181 - ptr[1] = ptr[1] * rhs;  
182 - ptr[2] = ptr[2] * rhs;  
183 - return *this;  
184 - }  
185 -  
186 - /// Addition and assignment  
187 - CUDA_CALLABLE vec3<T> operator+=(vec3<T> rhs){  
188 - ptr[0] = ptr[0] + rhs;  
189 - ptr[1] = ptr[1] + rhs;  
190 - ptr[2] = ptr[2] + rhs;  
191 - return *this;  
192 - }  
193 -  
194 - /// Assign a scalar to all values  
195 - CUDA_CALLABLE vec3<T> & operator=(T rhs){  
196 - ptr[0] = ptr[0] = rhs;  
197 - ptr[1] = ptr[1] = rhs;  
198 - ptr[2] = ptr[2] = rhs;  
199 - return *this;  
200 - }  
201 -  
202 - /// Casting and assignment  
203 - template<typename Y>  
204 - CUDA_CALLABLE vec3<T> & operator=(vec3<Y> rhs){  
205 - ptr[0] = (T)rhs.ptr[0];  
206 - ptr[1] = (T)rhs.ptr[1];  
207 - ptr[2] = (T)rhs.ptr[2];  
208 - return *this;  
209 - }  
210 -  
211 - /// Unary minus (returns the negative of the vector)  
212 - CUDA_CALLABLE vec3<T> operator-() const{  
213 - vec3<T> result;  
214 - result.ptr[0] = -ptr[0];  
215 - result.ptr[1] = -ptr[1];  
216 - result.ptr[2] = -ptr[2];  
217 - return result;  
218 - }  
219 -  
220 - /// Outputs the vector as a string  
221 - std::string str() const{  
222 - std::stringstream ss;  
223 -  
224 - const size_t N = 3;  
225 -  
226 - ss<<"[";  
227 - for(size_t i=0; i<N; i++)  
228 - {  
229 - ss<<ptr[i];  
230 - if(i != N-1)  
231 - ss<<", ";  
232 - }  
233 - ss<<"]";  
234 -  
235 - return ss.str();  
236 - }  
237 -  
238 - size_t size(){ return 3; }  
239 -  
240 - }; //end class vec3  
241 -} //end namespace stim  
242 -  
243 -/// Multiply a vector by a constant when the vector is on the right hand side  
244 -template <typename T>  
245 -stim::vec3<T> operator*(T lhs, stim::vec3<T> rhs){  
246 - return rhs * lhs;  
247 -}  
248 -  
249 -//stream operator  
250 -template<typename T>  
251 -std::ostream& operator<<(std::ostream& os, stim::vec3<T> const& rhs){  
252 - os<<rhs.str();  
253 - return os;  
254 -}  
255 -  
256 -#endif