anchor.diff:      io:format("Testing standard normal~n",[]),
       IntendedMean = 0,
       IntendedVariance = 1,
  -    [basic_normal_1(?LOOP, IntendedMean, IntendedVariance,
  -                    rand:seed_s(Alg), 0, 0)
  -     || Alg <- [default|algs()]],
  +    Result =
  +        lists:filter(
  +          fun (R) -> R =/= [] end,
  +          [basic_normal_1(?LOOP, IntendedMean, IntendedVariance,
  +                          rand:seed_s(Alg), 0, 0)
  +           || Alg <- [default|algs()]]),
  +    Result =:= [] orelse
  +        ct:fail(Result),
       ok.
   
   basic_stats_normal(Config) when is_list(Config) ->
  
positive.code:             1 ->
                  rand:uniform_real_s(S0)
          end,
      I = trunc(X*100),
      A = array:set(I, 1+array:get(I,A0), A0),
      basic_uniform_1(N-1, S, Sum+X, A);
  basic_uniform_1(0, {#{type:=Alg}, _}, Sum, A) ->
      Loop = ?LOOP,
      AverExp = 1.0 / 2,
      Buckets = 100,
      Counters = array:to_list(A),
      Min = lists:min(Counters),
      Max = lists:max(Counters),
      basic_verify(Alg, Loop, Sum, AverExp, Buckets, Min, Max).
  
  basic_uniform_2(N, S0, Sum, A0) when N > 0 ->
      {X,S} = rand:uniform_s(100, S0),
      A = array:set(X-1, 1+array:get(X-1,A0), A0),
      basic_uniform_2(N-1, S, Sum+X, A);
  basic_uniform_2(0, {#{type:=Alg}, _}, Sum, A) ->
      Loop = ?LOOP,
      AverExp = ((100 - 1) / 2) + 1,
      Buckets = 100,
      Counters = tl(array:to_list(A)),
      Min = lists:min(Counters),
      Max = lists:max(Counters),
      basic_verify(Alg, Loop, Sum, AverExp, Buckets, Min, Max).
  
  basic_bytes(N, S0, Sum0, A0) when N > 0 ->
      ByteSize = 100,
      {Bin,S} = rand:bytes_s(ByteSize, S0),
      {Sum,A} = basic_bytes_incr(Bin, Sum0, A0),
      basic_bytes(N-1, S, Sum, A);
  basic_bytes(0, {#{type:=Alg}, _}, Sum, A) ->
      ByteSize = 100,
      Loop = (?LOOP * ByteSize) div 100,
      Buckets = 256,
      AverExp = (Buckets - 1) / 2,
      Counters = array:to_list(A),
      Min = lists:min(Counters),
      Max = lists:max(Counters),
      basic_verify(Alg, Loop, Sum, AverExp, Buckets, Min, Max).
  
  basic_bytes_incr(Bin, Sum, A) ->
      basic_bytes_incr(Bin, Sum, A, 0).
  
negative.code:     StandardX = (X - IntendedMean) / math:sqrt(IntendedVariance),
      basic_normal_1(N-1, IntendedMean, IntendedVariance, S,
                     StandardX+StandardSum, StandardX*StandardX+StandardSq);
  basic_normal_1(0, IntendedMean, IntendedVariance, {#{type:=Alg}, _}, StandardSum, StandardSumSq) ->
      StandardMean = StandardSum / ?LOOP,
      StandardVariance = (StandardSumSq - (StandardSum*StandardSum/?LOOP))/(?LOOP - 1),
      StandardStdDev =  math:sqrt(StandardVariance),
  