test2

Pavel Govyadinov
2 parents 80d3850d 321ff17a
Showing 3 changed files with 121 additions and 86 deletions Show diff stats
stim/math/mathvec.h
stim/math/spharmonics.h
stim/visualization/gl_spharmonics.h
@@ -19,72 +19,71 @@ struct vec : public std::vector&lt;T&gt;
 	using std::vector<T>::at;
 	using std::vector<T>::resize;
 	using std::vector<T>::push_back;
-	CUDA_CALLABLE vec(){
+	vec(){
  
 	}
  
-//	//efficiency constructors, makes construction easier for 1D-4D vectors
-//	CUDA_CALLABLE vec(T rhs)
-//	{
-//		resize(1, rhs);
-//		cerr << " Created a vector " << endl;
-//		//for(int i=0; i<N; i++)
-//		//	v[i] = rhs;
-//	}
-
-	CUDA_CALLABLE vec(int s)
+	/// Create a vector with a set dimension d
+	vec(int d)
 	{
-		resize(s,0);
-	}	
+		resize(d,0);
+	}
  
-	CUDA_CALLABLE vec(T x, T y)
+
+//	//efficiency constructors, makes construction easier for 1D-4D vectors
+	vec(T x, T y)
 	{
-		push_back(x);
-		push_back(y);
+		resize(2, 0);
+		at(0) = x;
+		at(1) = y;
 	}
-	CUDA_CALLABLE vec(T x, T y, T z)
+	vec(T x, T y, T z)
 	{
-		push_back(x);
-		push_back(y);
-		push_back(z);
+		resize(3, 0);
+		at(0) = x;
+		at(1) = y;
+		at(2) = z;
 	}
-	CUDA_CALLABLE vec(T x, T y, T z, T w)
+	vec(T x, T y, T z, T w)
 	{
-		push_back(x);
-		push_back(y);
-		push_back(z);
-		push_back(w);
+		resize(4, 0);
+		at(0) = x;
+		at(1) = y;
+		at(2) = z;
+		at(3) = w;
 	}
  
  
  
 	//copy constructor
-	CUDA_CALLABLE vec( const vec<T>& other){
+	vec( const vec<T>& other){
 		unsigned int N = other.size();
 		for(int i=0; i<N; i++)
 			push_back(other[i]);
 	}
  
-	CUDA_CALLABLE vec<T> push(T x)
+	//I'm not sure what these were doing here.
+	//Keep them now, we'll worry about it later.
+	vec<T> push(T x)
 	{
 		push_back(x);
 		return *this;
 	}
  
-	CUDA_CALLABLE vec<T> push(T x, T y)
+	vec<T> push(T x, T y)
 	{
 		push_back(x);
 		push_back(y);
 		return *this;
 	}
-	CUDA_CALLABLE vec<T> push(T x, T y, T z)
+	vec<T> push(T x, T y, T z)
 	{
 		push_back(x);
 		push_back(y);
 		push_back(z);
 		return *this;
 	}
-	CUDA_CALLABLE vec<T> push(T x, T y, T z, T w)
+	vec<T> push(T x, T y, T z, T w)
 	{
 		push_back(x);
 		push_back(y);
@@ -92,8 +91,10 @@ struct vec : public std::vector&lt;T&gt;
 		push_back(w);
 		return *this;
 	}
+
+	/// Casting operator. Creates a new vector with a new type U.
 	template< typename U >
-	CUDA_CALLABLE operator vec<U>(){
+	operator vec<U>(){
 		unsigned int N = size();
 		vec<U> result;
 		for(int i=0; i<N; i++)
@@ -102,10 +103,9 @@ struct vec : public std::vector&lt;T&gt;
 		return result;
 	}
  
-	//template<class U>
-	//friend vec<U, N>::operator vec<T, N>();
  
-	CUDA_CALLABLE T len() const
+	/// computes the Euclidean length of the vector
+	T len() const
 	{
 		unsigned int N = size();
  
@@ -119,10 +119,10 @@ struct vec : public std::vector&lt;T&gt;
  
 	}
  
-	CUDA_CALLABLE vec<T> cart2sph() const
+	/// Convert the vector from cartesian to spherical coordinates (x, y, z -> r, theta, phi where theta = [0, 2*pi])
+	vec<T> cart2sph() const
 	{
-		//convert the vector from cartesian to spherical coordinates
-		//x, y, z -> r, theta, phi (where theta = 0 to 2*pi)
+
  
 		vec<T> sph;
 		sph.push_back(std::sqrt(at(0)*at(0) + at(1)*at(1) + at(2)*at(2)));
@@ -136,11 +136,9 @@ struct vec : public std::vector&lt;T&gt;
 		return sph;
 	}
  
-	CUDA_CALLABLE vec<T> sph2cart() const
+	/// Convert the vector from cartesian to spherical coordinates (r, theta, phi -> x, y, z where theta = [0, 2*pi])
+	vec<T> sph2cart() const
 	{
-		//convert the vector from cartesian to spherical coordinates
-		//r, theta, phi -> x, y, z (where theta = 0 to 2*pi)
-
 		vec<T> cart;
 		cart.push_back(at(0) * std::cos(at(1)) * std::sin(at(2)));
 		cart.push_back(at(0) * std::sin(at(1)) * std::sin(at(2)));
@@ -149,7 +147,8 @@ struct vec : public std::vector&lt;T&gt;
 		return cart;
 	}
  
-	CUDA_CALLABLE vec<T> norm() const
+	/// Computes the normalized vector (where each coordinate is divided by the L2 norm)
+	vec<T> norm() const
 	{
 		unsigned int N = size();
  
@@ -168,22 +167,27 @@ struct vec : public std::vector&lt;T&gt;
         return result;
 	}
  
-	CUDA_CALLABLE vec<T> cross(const vec<T> rhs) const
+	/// Computes the cross product of a 3-dimensional vector
+	vec<T> cross(const vec<T> rhs) const
 	{
-		vec<T> result;
+		if(size() != 3)
+			std::cout<<"Error in stim::mathvec::cross() - the vector must have 3 components"<<std::endl;
+
+		vec<T> result(3);
  
 		//compute the cross product (only valid for 3D vectors)
-		result.push_back(at(1) * rhs[2] - at(2) * rhs[1]);
-		result.push_back(at(2) * rhs[0] - at(0) * rhs[2]);
-		result.push_back(at(0) * rhs[1] - at(1) * rhs[0]);
+		result[0] = (at(1) * rhs[2] - at(2) * rhs[1]);
+		result[1] = (at(2) * rhs[0] - at(0) * rhs[2]);
+		result[2] = (at(0) * rhs[1] - at(1) * rhs[0]);
  
 		return result;
 	}
  
-    CUDA_CALLABLE T dot(vec<T> rhs) const
+	/// Compute the Euclidean inner (dot) product
+    T dot(vec<T> rhs) const
     {
         T result = (T)0;
-	unsigned int N = size();
+        unsigned int N = size();
         for(int i=0; i<N; i++)
             result += at(i) * rhs[i];
  
@@ -191,70 +195,98 @@ struct vec : public std::vector&lt;T&gt;
  
     }
  
-	//arithmetic
-	CUDA_CALLABLE vec<T> operator+(vec<T> rhs) const
-	{
-		vec<T> result;
+	/// Arithmetic addition operator
  
+    /// @param rhs is the right-hand-side operator for the addition
+	vec<T> operator+(vec<T> rhs) const
+	{
 		unsigned int N = size();
+		vec<T> result(N);
+
 		for(int i=0; i<N; i++)
-		    result.push_back(at(i) + rhs[i]);
+		    result[i] = at(i) + rhs[i];
  
 		return result;
 	}
-	CUDA_CALLABLE vec<T> operator+(T rhs) const
+
+	/// Arithmetic addition to a scalar
+
+	/// @param rhs is the right-hand-side operator for the addition
+	vec<T> operator+(T rhs) const
 	{
-		vec<T> result;
 		unsigned int N = size();
+
+		vec<T> result(N);
 		for(int i=0; i<N; i++)
-		    result.push_back(at(i) + rhs);
+		    result[i] = at(i) + rhs;
  
 		return result;
 	}
-	CUDA_CALLABLE vec<T> operator-(vec<T> rhs) const
-	{
-        vec<T> result;
  
+	/// Arithmetic subtraction operator
+
+	/// @param rhs is the right-hand-side operator for the subtraction
+	vec<T> operator-(vec<T> rhs) const
+	{
 		unsigned int N = size();
+
+        vec<T> result(N);
+
         for(int i=0; i<N; i++)
-            result.push_back(at(i) - rhs[i]);
+            result[i] = at(i) - rhs[i];
  
         return result;
 	}
-	CUDA_CALLABLE vec<T> operator*(T rhs) const
-	{
-        vec<T> result;
  
+	/// Arithmetic scalar multiplication operator
+
+	/// @param rhs is the right-hand-side operator for the subtraction
+	vec<T> operator*(T rhs) const
+	{
 		unsigned int N = size();
+
+        vec<T> result(N);
+
         for(int i=0; i<N; i++)
-            result.push_back(at(i) * rhs);
+            result[i] = at(i) * rhs;
  
         return result;
 	}
-	CUDA_CALLABLE vec<T> operator/(T rhs) const
-	{
-        vec<T> result;
  
+	/// Arithmetic scalar division operator
+
+	/// @param rhs is the right-hand-side operator for the subtraction
+	vec<T> operator/(T rhs) const
+	{
 		unsigned int N = size();
+
+        vec<T> result(N);
+
         for(int i=0; i<N; i++)
-            result.push_back(at(i) / rhs);
+            result[i] = at(i) / rhs;
  
         return result;
 	}
-	CUDA_CALLABLE vec<T> operator*=(T rhs){
+
+	/// Multiplication by a scalar, followed by assignment
+	vec<T> operator*=(T rhs){
  
 		unsigned int N = size();
 		for(int i=0; i<N; i++)
 			at(i) = at(i) * rhs;
 		return *this;
 	}
-	CUDA_CALLABLE vec<T> operator+=(vec<T> rhs){
+
+	/// Addition and assignment
+	vec<T> operator+=(vec<T> rhs){
 		unsigned int N = size();
 		for(int i=0; i<N; i++)
 			at(i) += rhs[i];
 		return *this;
 	}
-	CUDA_CALLABLE vec<T> & operator=(T rhs){
+
+	/// Assign a scalar to all values
+	vec<T> & operator=(T rhs){
  
 		unsigned int N = size();
 		for(int i=0; i<N; i++)
@@ -262,8 +294,9 @@ struct vec : public std::vector&lt;T&gt;
 		return *this;
 	}
  
+	/// Casting and assignment
 	template<typename Y>
-	CUDA_CALLABLE vec<T> & operator=(vec<Y> rhs){
+	vec<T> & operator=(vec<Y> rhs){
 		unsigned int N = rhs.size();
 		resize(N);
  
@@ -271,19 +304,23 @@ struct vec : public std::vector&lt;T&gt;
 			at(i) = rhs[i];
 		return *this;
 	}
-	//unary minus
-	CUDA_CALLABLE vec<T> operator-() const{
-		vec<T> r;
  
-		//negate the vector
+	/// Unary minus (returns the negative of the vector)
+	vec<T> operator-() const{
+
 		unsigned int N = size();
+
+		vec<T> r(N);
+
+		//negate the vector
 		for(int i=0; i<N; i++)
-		    r.push_back(-at(i));
+		    r[i] = -at(i);
  
 		return r;
 	}
  
  
+	/// Outputs the vector as a string
 	std::string str() const
 	{
 		std::stringstream ss;
@@ -315,17 +352,13 @@ std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, stim::vec&lt;T&gt; v)
 }
  
  
-
+/// Multiply a vector by a constant when the vector is on the right hand side
 template <typename T>
-CUDA_CALLABLE stim::vec<T> operator*(T lhs, stim::vec<T> rhs)
+stim::vec<T> operator*(T lhs, stim::vec<T> rhs)
 {
 	stim::vec<T> r;
  
     return rhs * lhs;
 }
  
-//#if __GNUC__ > 3 && __GNUC_MINOR__ > 7
-//template<class T, int N> using rtsVector = rts::vector<T, N>;
-//#endif
-
 #endif
@@ -100,7 +100,7 @@ public:
 	/// @param sph_pts is a list of points in spherical coordinates (theta, phi) where theta = [0, 2pi] and phi = [0, pi]
 	/// @param l is the maximum degree of the spherical harmonic function
 	/// @param m is the maximum order
-	void pdf(std::vector<stim::vec<double>> sph_pts, unsigned int l, int m){
+	void pdf(std::vector<stim::vec<double> > sph_pts, unsigned int l, int m){
  
 		mcBegin( l, m );		//begin spherical harmonic sampling
  
@@ -14,6 +14,8 @@ template &lt;typename T&gt;
 class gl_spharmonics : public spharmonics<T>{
  
 protected:
+	using spharmonics<T>::C;
+	using spharmonics<T>::SH;
  
 	T* func;		//stores the raw function data (samples at each point)
  
@@ -184,4 +186,4 @@ public:
  
  
  
-#endif
 \ No newline at end of file
+#endif