anchor.diff:                   digits(LargeNorm)),
       ?assertEqual(LargeNorm,
                    list_to_float(digits(LargeNorm))),
  +    %% issue #10 - mochinum:frexp(math:pow(2, -1074)).
  +    ?assertEqual("5.0e-324",
  +                 digits(math:pow(2, -1074))),
       ok.
   
   frexp_test() ->
       %% zero
  -    {0.0, 0} = frexp(0.0),
  +    ?assertEqual({0.0, 0}, frexp(0.0)),
       %% one
  -    {0.5, 1} = frexp(1.0),
  +    ?assertEqual({0.5, 1}, frexp(1.0)),
       %% negative one
  -    {-0.5, 1} = frexp(-1.0),
  +    ?assertEqual({-0.5, 1}, frexp(-1.0)),
       %% small denormalized number
       %% 4.94065645841246544177e-324
       <<SmallDenorm/float>> = <<0,0,0,0,0,0,0,1>>,
  -    {0.5, -1073} = frexp(SmallDenorm),
  +    ?assertEqual({0.5, -1073}, frexp(SmallDenorm)),
       %% large denormalized number
       %% 2.22507385850720088902e-308
       <<BigDenorm/float>> = <<0,15,255,255,255,255,255,255>>,
  -    {0.99999999999999978, -1022} = frexp(BigDenorm),
  +    ?assertEqual(
  +       {0.99999999999999978, -1022},
  +       frexp(BigDenorm)),
       %% small normalized number
       %% 2.22507385850720138309e-308
       <<SmallNorm/float>> = <<0,16,0,0,0,0,0,0>>,
  -    {0.5, -1021} = frexp(SmallNorm),
  +    ?assertEqual({0.5, -1021}, frexp(SmallNorm)),
       %% large normalized number
       %% 1.79769313486231570815e+308
       <<LargeNorm/float>> = <<127,239,255,255,255,255,255,255>>,
  -    {0.99999999999999989, 1024} = frexp(LargeNorm),
  +    ?assertEqual(
  +        {0.99999999999999989, 1024},
  +        frexp(LargeNorm)),
  +    %% issue #10 - mochinum:frexp(math:pow(2, -1074)).
  +    ?assertEqual(
  +       {0.5, -1073},
  +       frexp(math:pow(2, -1074))),
       ok.
   
   -endif.
  
positive.code: -ifdef(TEST).
  
  int_ceil_test() ->
      1 = int_ceil(0.0001),
      0 = int_ceil(0.0),
      1 = int_ceil(0.99),
      1 = int_ceil(1.0),
      -1 = int_ceil(-1.5),
      -2 = int_ceil(-2.0),
      ok.
  
  int_pow_test() ->
      1 = int_pow(1, 1),
      1 = int_pow(1, 0),
      1 = int_pow(10, 0),
      10 = int_pow(10, 1),
      100 = int_pow(10, 2),
      1000 = int_pow(10, 3),
      ok.
  
  digits_test() ->
  
negative.code:     ?assertEqual("4503599627370496.0",
                   digits(4503599627370496.0)),
      %% small denormalized number
      %% 4.94065645841246544177e-324 =:= 5.0e-324
      <<SmallDenorm/float>> = <<0,0,0,0,0,0,0,1>>,
      ?assertEqual("5.0e-324",
                   digits(SmallDenorm)),
      ?assertEqual(SmallDenorm,
                   list_to_float(digits(SmallDenorm))),
  