diff --git a/src/FSharpUnitTests/FsUnit.fs b/src/FSharpUnitTests/FsUnit.fs
index e6da2926..09778d30 100644
--- a/src/FSharpUnitTests/FsUnit.fs
+++ b/src/FSharpUnitTests/FsUnit.fs
@@ -70,7 +70,7 @@ module SpecOps =
     
     let equal expected actual =
         make (fun () ->
-            if actual = expected 
+            if actual.Equals(expected)
                 then Pass
                 else Fail (sprintf "Expected: %A\nActual: %A" expected actual))
             (sprintf "NOT Expected: %A\nActual: %A" expected actual)
@@ -146,29 +146,29 @@ module SpecOps =
                     else Fail (sprintf "Expected actual to be same reference as expected %A" other))
                 (sprintf "Expected %A to have different reference than %A" x other)
 
-    let approximately_equal (expected: float) (actual: float) =
+    let approximately_equal (places : int) (expected: float) (actual: float) =
         make (fun () ->
-            if Precision.AlmostEqualInDecimalPlaces(actual, expected, 5)
+            if Precision.AlmostEqualInDecimalPlaces(actual, expected, places)
                 then Pass
                 else Fail (sprintf "Expected: %A\nActual: %A" expected actual))
             (sprintf "NOT Expected: %A\nActual: %A" expected actual)
             
-    let approximately_vector_equal (expected: #Vector) (actual: #Vector) =
+    let approximately_vector_equal (places : int) (expected: #Vector) (actual: #Vector) =
         make (fun () ->
             let mutable f = true
             for i=0 to expected.Count-1 do
-              f <- f && Precision.AlmostEqualInDecimalPlaces(expected.[i], actual.[i], 5)
+              f <- f && Precision.AlmostEqualInDecimalPlaces(expected.[i], actual.[i], places)
             if f
                 then Pass
                 else Fail (sprintf "Expected: %A\nActual: %A" expected actual))
             (sprintf "NOT Expected: %A\nActual: %A" expected actual)
             
-    let approximately_matrix_equal (expected: #Matrix) (actual: #Matrix) =
+    let approximately_matrix_equal (places : int) (expected: #Matrix) (actual: #Matrix) =
         make (fun () ->
             let mutable f = true
             for i=0 to expected.RowCount-1 do
               for j=0 to expected.ColumnCount-1 do
-                f <- f && Precision.AlmostEqualInDecimalPlaces(expected.[i,j], actual.[i,j], 5)
+                f <- f && Precision.AlmostEqualInDecimalPlaces(expected.[i,j], actual.[i,j], places)
             if f
                 then Pass
                 else Fail (sprintf "Expected: %A\nActual: %A" expected actual))
diff --git a/src/FSharpUnitTests/Program.fs b/src/FSharpUnitTests/Program.fs
index ac0d6c4f..33981fe7 100644
--- a/src/FSharpUnitTests/Program.fs
+++ b/src/FSharpUnitTests/Program.fs
@@ -13,17 +13,17 @@ let DenseVectorTests =
     
     specs "DenseVector" [
         spec "DenseVector.init"
-            (Double.DenseVector.init 100 (fun i -> float i / 100.0) |> should equal largev)
+            (Double.DenseVector.init 100 (fun i -> float i / 100.0) |> should approximately_vector_equal 16 largev)
         spec "DenseVector.of_list"
-            (Double.DenseVector.of_list [ for i in 0 .. 99 -> float i / 100.0 ] |> should equal largev)
+            (Double.DenseVector.of_list [ for i in 0 .. 99 -> float i / 100.0 ] |> should approximately_vector_equal 16 largev)
         spec "DenseVector.of_seq"
-            (Double.DenseVector.of_seq (seq { for i in 0 .. 99 -> float i / 100.0 }) |> should equal largev)
+            (Double.DenseVector.of_seq (seq { for i in 0 .. 99 -> float i / 100.0 }) |> should approximately_vector_equal 16 largev)
         spec "DenseVector.rangef"
             (Double.DenseVector.rangef 0.0 0.01 0.99
-             |> should equal (new Double.DenseVector( [| for i in 0 .. 99 -> 0.01 * float i |] ) ))
+             |> should approximately_vector_equal 16 (new Double.DenseVector( [| for i in 0 .. 99 -> 0.01 * float i |] ) ))
         spec "DenseVector.range"
             (Double.DenseVector.range 0 99
-             |> should equal (new Double.DenseVector( [| for i in 0 .. 99 -> float i |] ) ))
+             |> should approximately_vector_equal 16 (new Double.DenseVector( [| for i in 0 .. 99 -> float i |] ) ))
     ]
     
 /// Report on errors and success and exit.