diff --git a/stim/gl/gl_spider.h b/stim/gl/gl_spider.h
index 80325d7..2b1a884 100644
--- a/stim/gl/gl_spider.h
+++ b/stim/gl/gl_spider.h
@@ -73,8 +73,8 @@ class gl_spider
 			dV[best][1]*S[1]*R[1],
 			dV[best][2]*S[2]*R[2],
 			1);
-			//next = (cT*next).norm();
 			next = (cT*next).norm();
+			//next = (cT*next);
 			setPosition(	p[0]+next[0]*m[0]/stepsize,
 					p[1]+next[1]*m[0]/stepsize,
 					p[2]+next[2]*m[0]/stepsize);
@@ -522,11 +522,11 @@ class gl_spider
 		gl_spider
 		(int samples = 1089)
 		{
-			p.push(0.0,0.0,0.0);
-			d.push(0.0,0.0,1.0);
-			m.push(1.0, 1.0);
-			S.push(1.0,1.0,1.0);
-			R.push(1.0,1.0,1.0);
+			p = vec<float>(0.0, 0.0, 0.0);
+			d = vec<float>(0.0, 0.0, 1.0);
+			m = vec<float>(1.0, 1.0);
+			S = vec<float>(1.0, 1.0, 1.0);
+			R = vec<float>(1.0, 1.0, 1.0);
 			//setPosition(0.0,0.0,0.0);
 			//setDirection(0.0,0.0,1.0);
 			//setMagnitude(1.0);
@@ -538,11 +538,11 @@ class gl_spider
 		(float pos_x, float pos_y, float pos_z, float dir_x, float dir_y, float dir_z,
 			float mag_x, int numSamples = 1089)
 		{
-			p.push(pos_x, pos_y, pos_z);
-			d.push(dir_x, dir_y, dir_z);
-			m.push(mag_x, mag_x);
-			S.push(1.0,1.0,1.0);
-			R.push(1.0,1.0,1.0);
+			p = vec<float>(pos_x, pos_y, pos_z);
+			d = vec<float>(dir_x, dir_y, dir_z);
+			m = vec<float>(mag_x, mag_x);
+			S = vec<float>(1.0,1.0,1.0);
+			R = vec<float>(1.0,1.0,1.0);
 			//setPosition(pos_x, pos_y, pos_z);
 			//setDirection(dir_x, dir_y, dir_z);
 			//setMagnitude(mag_x);
@@ -734,8 +734,8 @@ class gl_spider
 		{
 			Bind();
 			findOptimalDirection();
-			findOptimalPosition();
-			findOptimalScale();
+			//findOptimalPosition();
+			//findOptimalScale();
 //			branchDetection();
 			Unbind();
 		}
diff --git a/stim/math/mathvec.h b/stim/math/mathvec.h
index d8523dc..9e1de54 100644
--- a/stim/math/mathvec.h
+++ b/stim/math/mathvec.h
@@ -19,36 +19,36 @@ struct vec : public std::vector<T>
 	using std::vector<T>::at;
 	using std::vector<T>::resize;
 	using std::vector<T>::push_back;
-	vec(){
+	CUDA_CALLABLE vec(){
 
 	}
 
 //	//efficiency constructors, makes construction easier for 1D-4D vectors
-	vec(T rhs)
-	{
-		resize(1, rhs);
+//	CUDA_CALLABLE vec(T rhs)
+//	{
+//		resize(1, rhs);
 //		cerr << " Created a vector " << endl;
 //		//for(int i=0; i<N; i++)
 //		//	v[i] = rhs;
-	}
+//	}
 
-//	vec(int s)
-//	{
-//		resize(s,0);
-//	}	
+	CUDA_CALLABLE vec(int s)
+	{
+		resize(s,0);
+	}	
 
-	vec(T x, T y)
+	CUDA_CALLABLE vec(T x, T y)
 	{
 		push_back(x);
 		push_back(y);
 	}
-	vec(T x, T y, T z)
+	CUDA_CALLABLE vec(T x, T y, T z)
 	{
 		push_back(x);
 		push_back(y);
 		push_back(z);
 	}
-	vec(T x, T y, T z, T w)
+	CUDA_CALLABLE vec(T x, T y, T z, T w)
 	{
 		push_back(x);
 		push_back(y);
@@ -59,32 +59,32 @@ struct vec : public std::vector<T>
 	
 	
 	//copy constructor
-	vec( const vec<T>& other){
+	CUDA_CALLABLE vec( const vec<T>& other){
 		unsigned int N = other.size();
 		for(int i=0; i<N; i++)
 			push_back(other[i]);
 	}
 
-	vec<T> push(T x)
+	CUDA_CALLABLE vec<T> push(T x)
 	{
 		push_back(x);
 		return *this;
 	}
 	
-	vec<T> push(T x, T y)
+	CUDA_CALLABLE vec<T> push(T x, T y)
 	{
 		push_back(x);
 		push_back(y);
 		return *this;
 	}
-	vec<T> push(T x, T y, T z)
+	CUDA_CALLABLE vec<T> push(T x, T y, T z)
 	{
 		push_back(x);
 		push_back(y);
 		push_back(z);
 		return *this;
 	}
-	vec<T> push(T x, T y, T z, T w)
+	CUDA_CALLABLE vec<T> push(T x, T y, T z, T w)
 	{
 		push_back(x);
 		push_back(y);
@@ -93,7 +93,7 @@ struct vec : public std::vector<T>
 		return *this;
 	}
 	template< typename U >
-	operator vec<U>(){
+	CUDA_CALLABLE operator vec<U>(){
 		unsigned int N = size();
 		vec<U> result;
 		for(int i=0; i<N; i++)
@@ -105,7 +105,7 @@ struct vec : public std::vector<T>
 	//template<class U>
 	//friend vec<U, N>::operator vec<T, N>();
 
-	T len() const
+	CUDA_CALLABLE T len() const
 	{
 		unsigned int N = size();
 
@@ -119,7 +119,7 @@ struct vec : public std::vector<T>
 
 	}
 
-	vec<T> cart2sph() const
+	CUDA_CALLABLE vec<T> cart2sph() const
 	{
 		//convert the vector from cartesian to spherical coordinates
 		//x, y, z -> r, theta, phi (where theta = 0 to 2*pi)
@@ -136,7 +136,7 @@ struct vec : public std::vector<T>
 		return sph;
 	}
 
-	vec<T> sph2cart() const
+	CUDA_CALLABLE vec<T> sph2cart() const
 	{
 		//convert the vector from cartesian to spherical coordinates
 		//r, theta, phi -> x, y, z (where theta = 0 to 2*pi)
@@ -149,7 +149,7 @@ struct vec : public std::vector<T>
 		return cart;
 	}
 
-	vec<T> norm() const
+	CUDA_CALLABLE vec<T> norm() const
 	{
 		unsigned int N = size();
 
@@ -168,7 +168,7 @@ struct vec : public std::vector<T>
         return result;
 	}
 
-	vec<T> cross(const vec<T> rhs) const
+	CUDA_CALLABLE vec<T> cross(const vec<T> rhs) const
 	{
 		vec<T> result;
 
@@ -180,7 +180,7 @@ struct vec : public std::vector<T>
 		return result;
 	}
 
-    T dot(vec<T> rhs) const
+    CUDA_CALLABLE T dot(vec<T> rhs) const
     {
         T result = (T)0;
 	unsigned int N = size();
@@ -192,7 +192,7 @@ struct vec : public std::vector<T>
     }
 
 	//arithmetic
-	vec<T> operator+(vec<T> rhs) const
+	CUDA_CALLABLE vec<T> operator+(vec<T> rhs) const
 	{
 		vec<T> result;
 
@@ -202,7 +202,7 @@ struct vec : public std::vector<T>
 
 		return result;
 	}
-	vec<T> operator+(T rhs) const
+	CUDA_CALLABLE vec<T> operator+(T rhs) const
 	{
 		vec<T> result;
 		unsigned int N = size();
@@ -211,7 +211,7 @@ struct vec : public std::vector<T>
 
 		return result;
 	}
-	vec<T> operator-(vec<T> rhs) const
+	CUDA_CALLABLE vec<T> operator-(vec<T> rhs) const
 	{
         vec<T> result;
 
@@ -221,7 +221,7 @@ struct vec : public std::vector<T>
 
         return result;
 	}
-	vec<T> operator*(T rhs) const
+	CUDA_CALLABLE vec<T> operator*(T rhs) const
 	{
         vec<T> result;
 
@@ -231,7 +231,7 @@ struct vec : public std::vector<T>
 
         return result;
 	}
-	vec<T> operator/(T rhs) const
+	CUDA_CALLABLE vec<T> operator/(T rhs) const
 	{
         vec<T> result;
 
@@ -241,20 +241,20 @@ struct vec : public std::vector<T>
 
         return result;
 	}
-	vec<T> operator*=(T rhs){
+	CUDA_CALLABLE vec<T> operator*=(T rhs){
 
 		unsigned int N = size();
 		for(int i=0; i<N; i++)
 			at(i) = at(i) * rhs;
 		return *this;
 	}
-	vec<T> operator+=(vec<T> rhs){
+	CUDA_CALLABLE vec<T> operator+=(vec<T> rhs){
 		unsigned int N = size();
 		for(int i=0; i<N; i++)
 			at(i) += rhs[i];
 		return *this;
 	}
-	vec<T> & operator=(T rhs){
+	CUDA_CALLABLE vec<T> & operator=(T rhs){
 
 		unsigned int N = size();
 		for(int i=0; i<N; i++)
@@ -263,7 +263,7 @@ struct vec : public std::vector<T>
 	}
 
 	template<typename Y>
-	vec<T> & operator=(vec<Y> rhs){
+	CUDA_CALLABLE vec<T> & operator=(vec<Y> rhs){
 		unsigned int N = rhs.size();
 		resize(N);
 
@@ -272,7 +272,7 @@ struct vec : public std::vector<T>
 		return *this;
 	}
 	//unary minus
-	vec<T> operator-() const{
+	CUDA_CALLABLE vec<T> operator-() const{
 		vec<T> r;
 
 		//negate the vector
@@ -317,7 +317,7 @@ std::ostream& operator<<(std::ostream& os, stim::vec<T> v)
 
 
 template <typename T>
-stim::vec<T> operator*(T lhs, stim::vec<T> rhs)
+CUDA_CALLABLE stim::vec<T> operator*(T lhs, stim::vec<T> rhs)
 {
 	stim::vec<T> r;
 
--
libgit2 0.21.4