anchor.diff:      testCase "log works" <| fun () ->
           log 232.12 |> checkTo3dp 5447.
           checkTo3dp 1098. (log 3.0)
  -        equal (log 0.0, negativeInfinity)
  -        equal (isNaN (log -2.0), true)
  -        equal (isNaN (log System.Double.NaN), true)
  -        equal (isNaN (log negativeInfinity), true)
  -        equal (log positiveInfinity, positiveInfinity)
  +        log 0.0 |> equal negativeInfinity
  +        isNaN (log -2.0) |> equal true
  +        isNaN (log System.Double.NaN) |> equal true
  +        isNaN (log negativeInfinity) |> equal true
  +        log positiveInfinity |> equal positiveInfinity
   
       // https://github.com/dotnet/corefx/blob/master/src/System.Runtime.Extensions/tests/System/Math.cs#L239
       testCase "Math.Log(double, double) works" <| fun () ->
  -        equal (3.0, Math.Log(8.0, 2.0))
  -        equal (1.0, Math.Log(3.0, 3.0))
  +        Math.Log(8.0, 2.0) |> equal 3.0
  +        Math.Log(3.0, 3.0) |> equal 1.0
           Math.Log(14., 3.0) |> checkTo3dp 2402.
  -        equal (negativeInfinity, Math.Log(0.0, 3.0))
  -        equal (positiveInfinity, Math.Log(positiveInfinity, 3.0))
  -        equal (true, isNaN (Math.Log(-3.0, 3.0)))
  -        equal (true, isNaN (Math.Log(System.Double.NaN, 3.0)))
  -        equal (true, isNaN (Math.Log(negativeInfinity, 3.0)))
  +        Math.Log(0.0, 3.0) |> equal negativeInfinity
  +        Math.Log(positiveInfinity, 3.0) |> equal positiveInfinity
  +        isNaN (Math.Log(-3.0, 3.0)) |> equal true
  +        isNaN (Math.Log(System.Double.NaN, 3.0)) |> equal true
  +        isNaN (Math.Log(negativeInfinity, 3.0)) |> equal true
   
       testCase "log10 works" <| fun () ->
           log10 232.12 |> checkTo3dp 2365.
  
positive.code:     // As per https://github.com/dotnet/corefx/blob/master/src/System.Runtime.Extensions/tests/System/Math.cs#L217
      testCase "sqrt matches .net core implementation" <| fun () ->
          checkTo3dp 1732. (sqrt 3.0)
          equal (sqrt 0.0 , 0.0)
          equal (isNaN (sqrt -3.0), true)
          equal (isNaN (sqrt System.Double.NaN), true)
          equal (isNaN (sqrt negativeInfinity), true)
          equal (sqrt positiveInfinity, positiveInfinity)
  
      testCase "Double.Parse works with IFormatProvider" <| fun () ->
          // culture compiles to { } for now and it is ignored on the call-site
          let culture = Globalization.CultureInfo.InvariantCulture
          let result = System.Double.Parse("10.5", culture)
          equal(10.5, result)
  
      testCase "Single.Parse works with IFormatProvider" <| fun () ->
          // culture compiles to { } for now and it is ignored on the call-site
          let culture = Globalization.CultureInfo.InvariantCulture
          let result = System.Single.Parse("10.5", culture)
          equal(10.5, float result)
  
      testCase "acos works" <| fun () ->
          acos 0.25 |> checkTo3dp 1318.
  
negative.code:         checkTo3dp 2718. Math.E
  
      testCase "Math.abs works" <| fun () ->
          Math.Abs -4 |> equal 4
  
      testCase "Math.pown works" <| fun () ->
          Math.Pow(2.2, 3.0) |> checkTo3dp 10648.
  