anchor.diff:          _ ->
               I - 1
       end.
  +
  +
  +register_sum(I, _Registers, Sum) when I < 0 ->
  +    Sum;
  +register_sum(I, Registers, Sum) when I >= 0 ->
  +    Val = case gb_trees:lookup(I, Registers) of
  +              {value, R} ->
  +                  pow(2, -R);
  +              none ->
  +                  pow(2, -0)
  +          end,
  +    register_sum(I - 1, Registers, Sum + Val).
  +
  +count_zeros(I, _Registers, Count) when I < 0 ->
  +    Count;
  +count_zeros(I, Registers, Count) when I >= 0 ->
  +    %% FIXME: shouldn't we also count the value if it is equal to 0?
  +    Val = case gb_trees:lookup(I, Registers) =:= none of
  +              true  -> 1;
  +              false -> 0
  +          end,
  +    count_zeros(I - 1, Registers, Count + Val).
  +
  +
   
   estimate_bias(E, P) ->
       BiasVector = list_to_tuple(hyper_const:bias_data(P)),
  
positive.code: 
      #hyper{p = P, registers = Registers}.
  
  encode_registers(M, Registers) ->
      ByteEncoded = lists:map(fun (I) ->
                                      case gb_trees:lookup(I, Registers) of
                                          {value, V} ->
                                              <<V:8/integer>>;
                                          none ->
                                              <<0>>
                                      end
                              end, lists:seq(0, M)),
      base64:encode(
        zlib:gzip(
          iolist_to_binary(ByteEncoded))).
  
  decode_registers(B) ->
      ByteEncoded = zlib:gunzip(base64:decode(B)),
  
negative.code:              false -> E
           end,
  
      V = count_zeros(M-1, Registers, 0),
  
      H = case V of
              0 ->
                  Ep;
  