diff --git a/govector_test.go b/govector_test.go
index 037d64d..8d4e38c 100644
--- a/govector_test.go
+++ b/govector_test.go
@@ -101,7 +101,7 @@ func TestDot(t *testing.T) {
 	d = v1.Dot(v2)
 	fmt.Printf("%v\n", d)
 
-	if math.Abs(d-math.Acos(math.Pi/4)) < 0.0001 {
+	if math.Abs(float64(d)-math.Acos(math.Pi/4)) < 0.0001 {
 		t.Errorf("Dot Error")
 	}
 }
@@ -139,7 +139,7 @@ func TestAngle(t *testing.T) {
 	a := Angle(v2, v1)
 
 	fmt.Printf("%v %v %f\n", v1, v2, a*Rad2deg)
-	if math.Abs(a)-math.Pi/2 > Epsilon {
+	if math.Abs(float64(a))-math.Pi/2 > Epsilon {
 		t.Errorf("Angle Error")
 	}
 
@@ -150,7 +150,7 @@ func TestAngle(t *testing.T) {
 
 	fmt.Printf("%v %v %f\n", v1, v2, a*Rad2deg)
 
-	if math.Abs(a)-math.Pi/4 > Epsilon {
+	if math.Abs(float64(a))-math.Pi/4 > Epsilon {
 		t.Errorf("Angle Error")
 	}
 
diff --git a/vectorpoint.go b/vectorpoint.go
index f3fdedb..4d67bde 100644
--- a/vectorpoint.go
+++ b/vectorpoint.go
@@ -10,13 +10,13 @@ type Rect2d struct {
 }
 
 type Vector2d struct {
-	X float64 `json:"x"`
-	Y float64 `json:"y"`
+	X float32 `json:"x"`
+	Y float32 `json:"y"`
 }
 
 type Point2d struct {
-	X float64 `json:"x"`
-	Y float64 `json:"y"`
+	X float32 `json:"x"`
+	Y float32 `json:"y"`
 }
 
 const Epsilon = 1e-7
@@ -31,30 +31,30 @@ func (p Point2d) Add(v Vector2d) Point2d {
 	return Point2d{p.X + v.X, p.Y + v.Y}
 }
 
-func (v Vector2d) Mag() float64 {
-	return math.Abs(math.Sqrt(v.X*v.X + v.Y*v.Y))
+func (v Vector2d) Mag() float32 {
+	return float32(math.Abs(math.Sqrt(float64(v.X*v.X) + float64(v.Y*v.Y))))
 }
 
-func (v Vector2d) PopPop() float64 {
+func (v Vector2d) PopPop() float32 {
 	return v.Mag()
 }
 
-func (v Vector2d) Scale(s float64) Vector2d {
+func (v Vector2d) Scale(s float32) Vector2d {
 	return Vector2d{v.X * s, v.Y * s}
 }
 
-func (v1 Vector2d) Cross(v2 Vector2d) float64 {
+func (v1 Vector2d) Cross(v2 Vector2d) float32 {
 	return v1.X*v2.Y - v1.Y*v2.X
 }
 
-func (v1 Vector2d) Dot(v2 Vector2d) float64 {
+func (v1 Vector2d) Dot(v2 Vector2d) float32 {
 	return (v1.X * v2.X) + (v1.Y * v2.Y)
 }
 
-func (v1 Vector2d) Rotate(a float64) Vector2d {
-	x := v1.X*math.Cos(a) - v1.Y*math.Sin(a)
-	y := v1.X*math.Sin(a) + v1.Y*math.Cos(a)
-	return Vector2d{x, y}
+func (v1 Vector2d) Rotate(a float32) Vector2d {
+	x := float64(v1.X)*math.Cos(float64(a)) - float64(v1.Y)*math.Sin(float64(a))
+	y := float64(v1.X)*math.Sin(float64(a)) + float64(v1.Y)*math.Cos(float64(a))
+	return Vector2d{float32(x), float32(y)}
 }
 
 func Intersection(p1, p2 Point2d, v1, v2 Vector2d) (bool, Point2d) {
@@ -110,17 +110,26 @@ func (v Vector2d) Normalize() Vector2d {
 	return Vector2d{v.X / m, v.Y / m}
 }
 
-func Distance(p1, p2 Point2d) float64 {
+func Distance(p1, p2 Point2d) float32 {
 	return p1.Sub(p2).Mag()
 }
 
-func Angle(v1, v2 Vector2d) float64 {
+func Angle(v1, v2 Vector2d) float32 {
 	x := (v1.Dot(v2) / (v1.Mag() * v2.Mag()))
-	angle := math.Acos(x)
+	angle := math.Acos(float64(x))
+
+	if math.IsNaN(angle) {
+		if math.Abs(float64(v1.X-v2.X)) > Epsilon {
+			return 180.0
+		} else {
+			return 0
+		}
+	}
+
 	// Determine the sign to see what direction
 	// the angle should go in
 	if v1.Y*v2.X > v1.X*v2.Y {
 		angle = angle * -1.0
 	}
-	return angle
+	return float32(angle)
 }