Question

So following on from this question:

Erlang lists:index_of function?

I have the following code which works just fine:

-module(test_index_of).
-compile(export_all).

index_of(Q)->
    N=length(Q),
    Qs=lists:zip(lists:sort(Q), lists:seq(1, N)),
    IndexFn=fun(X)->
                {_, {_, I}}=lists:keysearch(X, 1, Qs),
            I
        end,     
    [IndexFn(X) || X <- Q].

test()->
    Q=[random:uniform() || _X <- lists:seq(1, 20)],
    {T1, _}=timer:tc(test_index_of, index_of, [Q]),
    io:format("~p~n", [T1]).

Problem is, I need to run the index_of function a very large number of times [10,000] on lists of length 20-30 characters; the index_of function is the performance bottleneck in my code. So although it looks to be implemented reasonably efficiently to me, I’m not convinced it’s the fastest solution.

Can anyone out there improve [performance-wise] on the current implementation of index_of ? [Zed mentioned gb_trees]

Thanks!

Answer 1

Not sure if I understand this completely, but if the above is your actual usecase, then…

First of all, you could generate Q as the following, and you already save the zipping part.

Q=[{N,random:uniform()} || N <- lists:seq(1, 20)]

Taking this further on, you could generate a tree indexed by the values from the beginning:

Tree = lists:foldl(
              fun(T, N) -> gb_trees:enter(uniform:random(), N, T) end,
              gb_trees:empty(),
              lists:seq(1, 20)
       ).

Then looking up your index becomes:

index_of(Item, Tree) ->
  case gb_trees:lookup(Item, Tree) of
    {value, Index} -> Index;
    _ -> not_found
  end.