Float to list 2

[saleyn]

This patch implements a float_to_list/2 BIF that solves a problem of float_to_list/1 not allowing to specify
the number of digits after the decimal point when formatting floats. Additionally this new BIF is optimized to run 5-10x faster than float_to_list/1 for floats under 2^52.

float_to_list(Float, Options) -> string()

Float = float()
Options = [Option]
Option = {precision, Precision::integer()} | compact

Text representation of a float formatted using given options

Returns a string which corresponds to the text
representation of Float using fixed decimal point formatting.
When precision option is specified
the returned value will contain at most Precision number of
digits past the decimal point. When compact option is provided
the trailing zeros at the end of the list are truncated.

The simple test module included below illustrates the performance difference.

  1> test:test().
  float_to_list(123.400000)                   = {1.14305,
                                                 "1.23400000000000005684e+02"}
  float_to_list(123.400000, [])               = {0.124313,"123.4000"}
  float_to_list(123.400000, [{precision, 4}]) = {0.130213,"123.4000"}
  float_to_list(123.400000, 4)                = {0.125899,"123.4000"}
  ok

Test module:

-module(test).
-export([test/0, test/1]).

test() ->
    test(123.4).
test(N) ->
    Self = self(),
    spawn(fun() -> tc(Self, 1000000, fun() -> float_to_list(N) end) end),
    receive
    Msg0 -> io:format("float_to_list(~f)                   = ~p\n", [N, Msg0])
    end,
    spawn(fun() -> tc(Self, 1000000, fun() -> float_to_list(N, []) end) end),
    receive
    Msg1 -> io:format("float_to_list(~f, [])               = ~p\n", [N, Msg1])
    end,
    spawn(fun() -> tc(Self, 1000000, fun() -> float_to_list(N, [{precision, 4}]) end) end),
    receive
    Msg2 -> io:format("float_to_list(~f, [{precision, 4}]) = ~p\n", [N, Msg2])
    end,
    spawn(fun() -> tc(Self, 1000000, fun() -> float_to_list(N, 4) end) end),
    receive
    Msg3 -> io:format("float_to_list(~f, 4)                = ~p\n", [N, Msg3])
    end.


tc(Pid, N, F) when N > 0 ->
    loop(Pid, N, N, F, erlang:now()).

loop(Pid, 1, N, F, Time1) ->
    Res = F(),
    Int = timer:now_diff(erlang:now(), Time1),
    Pid ! {Int / N, Res};
loop(Pid, N, X, F, Time1) ->
    F(),
    loop(Pid, N-1, X, F, Time1).