Why is array's sample method not random?

I replaced your sample line with this one:

brownianMove = [-1, 1].choose

and then it worked. No idea, why auxArray.sample does not work as expected.

ADDITION: If you need different probabilities, this is a way to do it:

brownianMove = (knit -1, 3, 1, 5).choose

This will give you a 3:5 chance for -1 (=3/8 probability for -1)

1 Like

Ah yes, sample behaves oddly, based on my brief experience. If you need a non-repeating selection of more than 1 element (say 5), the workaround I’ve found is something like this:

brownianMove = auxArray.shuffle.take(5);

Otherwise, if you only need 1, then choose is the way to go, as @Nechoj has already suggested.

1 Like

Sure, [1, -1], but this is a toy case of the Markov chain transitions I’m working on, which generates more complex auxArrays in a similar manner. I did try the choose method instead of sample on my toy above, and choose generates exactly the same 2:1 proportion. By the way, I don’t see choose documented here.

Even with [1, -1].choose, I seem to be getting a 3:2 ratio on the data I’ve tested so far. In fact, on this data set, [1, -1].choose gives 18:12, but my auxArray.choose gives 16:14, which is acceptable:

BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 2, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 3, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 4, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 5, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 6, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 7, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 8, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 2, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 2, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 3, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 4, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 5, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 6, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 7, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 8, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7, 8]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7]
BrownianTransition 2, [0, 1, 2, 3, 4, 5, 6, 7]
BrownianTransition 1, [0, 1, 2, 3, 4, 5, 6, 7]

Using rrand, I get a 55:45 proportion, which is promising, I guess:

  brownianMove = rrand_i(0, 1)
  if(brownianMove == 0)
    brownianMove = -1
  end

Interesting, have you looked at the other types of noise available with the new use_random_source? It should be :white by default, so it’s odd that there’s an uneven distribution. That said, the probabilities are independent, so it’s within the realm of probability that you’ll get slight differences.

Also, have you tried using other random seeds to see if it might lean the other way? 2:3 instead of 3:2 for instance. That would indicate it’s just luck.

Given a much larger sample, things should average out.

Over here, I found this code:

t = Time.now.to_i
use_random_seed t

Doing that in conjunction with rrand_i does give different sequences, so it’s not deterministic—but the ratios are just as bad, like 60-67%. As pointed out, pseudo-randomness and repeatability have a musical value, but I’m concerned about melodies always ending up in the stratosphere, and things like that.

I think it’s just a particularity of the particular deterministic sequence of random numbers used by Sonic Pi. Changing the dataset would not affect the sequence of 1s and -1s (at least f the sequences of data are the same length). Instead you could change it by adding a call to use_random_seed 10000 (or some other number) at the start.

In my simultaneous post with yours, I did try use_random_seed, and results are not better. It’s odd that Sonic Pi’s random list doesn’t tend to 50/50 over the long run. There might be some other factor involved here.

You really need to look at large numbers. All following three possibilities give about 5000 ones

ones = 0
10000.times do
  if [-1, 1].choose == 1
    ones += 1
  end
end
puts ones
ones = 0
10000.times do
  if [-1, 1].sample == 1
    ones += 1
  end
end
puts ones
auxArray = []
20.times {|idx|
  auxArray[idx * 2] = -1
  auxArray[(idx * 2) + 1] = 1
}
ones = 0
10000.times do
  if auxArray.sample == 1
    ones += 1
  end
end
puts ones
2 Likes

That’s great to know, thanks for doing that. It does restore my faith.

I’m definitely getting consistent 60-67% unbalance at around 20 trials, so I wonder if the devs can tweak the randomization stream so that it doesn’t take so long to lose its bulge. I mean, even changing seeds reproduces the early segment bulge, which does cause a problem as my Markov melodies—whose matrices I purposely assemble for balance—bottom out too soon and throw an error when the note is out of playable range (MIDI < 0). I can have the melody return early if an error condition is detected, or I can adjust my Markov chains to SPI’s biases. I actually think adjusting to SPI’s quirks is fine because re-weighting and aborting early are themselves musical effects that can work out nicely when you know generally what to expect (i.e., exploiting the happy accidents). I wouldn’t complain, though, if they flattened out the bulge, or had some kind of randomness alternatives.

Statistical theory gives us the following estimate:

If p is the probability for a 1 and n is the number of retries, then sd=sqrt(p*(1-p)/n) is the standard error for the number of 1s (if the process is Markovian = independent retries).

That means, if p=0.5 and n=25, then sd=0.1. This gives you a 95% confidence interval of [0.5-2sd, 0.5+2sd] = [0.3, 0.7]. That means with a confidence of 95% the achieved proportion of 1’s will be within this interval when trying 25 times. You shouldn’t be surprised when you get a bias of 0.6 at this low number of retries.

When you do n=100 retries, then sd=0.05 and the 95% confidence interval is [0.4, 0.6].
When you do n=10000 retries, then sd=0.005 and the 95% confidence interval is [0.49, 0.51].

That’s called the Law of Large Numbers :wink:

OK, but it’s so consistently 60-67%. I guess I could do a large number of small number trials to see if I ever get something close to 50/50. But there’s another aspect I’ve forgotten to mention: the bulge is always in the same direction, so that’s weird, isn’t it?

Any updates? Here’s a large number of small trials:

leanFalse = 0;
leanTrue = 0;

(0...1000000).each do |i|
  use_random_seed(i);
  numTrues = 0;
  25.times do
    numTrues += 1 if one_in(2);
  end
  if (numTrues > 12)
    leanTrue += 1;
  else
    leanFalse += 1;
  end
end

puts("leanFalse: #{leanFalse}");
puts("leanTrue: #{leanTrue}");

Results:
leanFalse: 478156
leanTrue: 521844

That’s 52:48 over a million trials of 25 each.

Great, but I’ve never seen a single one that was better than 60/40—not one. How about this: assuming overall odds of 52% for true, what are the odds of getting 100 consecutive trials that are greater than 60% true?

Here, every time I hit 100 consecutive matches of your condition, I reset the counter, so as to count every hundred:

numChains = 0;
currentChain = 0;

numTrials = 25;
threshold = (numTrials * 0.6).to_i;

(0...1000000).each do |i|
  use_random_seed(i);
  numTrues = 0;
  numTrials.times do
    numTrues += 1 if one_in(2);
  end
  if (numTrues > threshold)
    currentChain += 1;
    if (currentChain == 100)
      numChains += 1;
      currentChain = 0;
    end
  else
    currentChain = 0;
  end
end

puts("numChains: #{numChains}");

Result: 0

The streaks you’re observing are probably all within the realm of probability.

It looks pretty balanced around 50% to me:

auxArray = []

10.times {|idx|
  auxArray[idx * 2] = -1
  auxArray[(idx * 2) + 1] = 1
}

define :checkBalance do |samples|
  plus = 0
  minus = 0
  samples.times do
    if auxArray.sample > 0 then
      plus += 1
    else
      minus += 1
    end
  end
  100.0 * plus / samples
end

20.times do
  puts "balance (%):", checkBalance(15)
end
{run: 14, time: 0.0}
 ├─ "balance (%):" 33.333333333333336
 ├─ "balance (%):" 46.666666666666664
 ├─ "balance (%):" 60.0
 ├─ "balance (%):" 53.333333333333336
 ├─ "balance (%):" 40.0
 ├─ "balance (%):" 40.0
 ├─ "balance (%):" 60.0
 ├─ "balance (%):" 60.0
 ├─ "balance (%):" 53.333333333333336
 ├─ "balance (%):" 53.333333333333336
 ├─ "balance (%):" 53.333333333333336
 ├─ "balance (%):" 66.66666666666667
 ├─ "balance (%):" 60.0
 ├─ "balance (%):" 40.0
 ├─ "balance (%):" 40.0
 ├─ "balance (%):" 60.0
 ├─ "balance (%):" 46.666666666666664
 ├─ "balance (%):" 40.0
 ├─ "balance (%):" 60.0
 └─ "balance (%):" 60.0
 

Here is a modification of @d0lfyn 's try with 1000000 samples of size 25. There is a statistics of each result and compared to the theoretical value (based on binomial numbers).

def binom(n,k)
  if k > 0 and n != k
    (1+n-k..n).inject(:*)/(1..k).inject(:*)
  else
    1
  end
end

results = (knit 0, 26).to_a
num_tries = 100000

(0...num_tries).each do |i|
  use_random_seed(i)
  numTrues = 0
  25.times do
    numTrues += 1 if one_in(2)
  end
  results[numTrues] += 1
end

results.each_with_index do |r, i|
  puts "#{i} #{r} #{(binom(25, i)*0.5**25*num_tries).to_i}"
end

The result is a list of 3 figures: the number of 1s achieved (0 … 25), how often this result was achieved during the run, and the theoretical number of such results.

Trying with 100000 samples of size 25 there is a good correspondence between measurement and theory. So, there is no issue with small sample sizes, if the seed is choosen randomly.

ADDITION: It works the same way when you omit the use_random_seed line. It’s not needed to proove that small samples are ok

1 Like

Pardon my math, but I don’t follow you here. I’m asking if the chances of true are 52% on every trial, what are the odds (1 in how many) that 100 consecutive trials will be more than 60% true? When you post “Result: 0”, I don’t know what you’re referring to.

For example, a parallel with slightly different numbers: the chances of a coin flip coming up heads is 50%. The odds of getting heads 10 times in a row is 1 in 1024–I know how to calculate that because it’s easy. So then, if I do 25-flip trials, what are the odds that 100 consecutive of these 25-flip trials produce 15 or more heads? I don’t know how to do that (without a good bit of studying).

To complete the analogy, say I have a bad coin that comes up heads 52% of the time. What are the odds that 100 consecutive 25-flip trials produce 15 or more heads? I don’t know how to do that.

How is the seed chosen in each of those trials? If the seed is random and independent in each trial, that would be a very low probability, but if the seed is the same each time, or highly correlated (e.g. Time.now.to_i) then it could be pretty likely.

1 Like

To calculate these probabilities use:

def binom(n,k)
  if k > 0 and n != k
    (1+n-k..n).inject(:*)/(1..k).inject(:*)
  else
    1
  end
end

n = 100
k = 42
p = 0.52
prob = binom(n, k)*p**k*(1-p)**(n-k)

puts prob

This gives the probability that you will get 42 1s in 100 tries if the propability for a 1 is 0.52. In order to know the probability getting more than 42, you will need to sum up all the probabilities for k=43…100:

def binom(n,k)
  if k > 0 and n != k
    (1+n-k..n).inject(:*)/(1..k).inject(:*)
  else
    1
  end
end

n = 100
p = 0.52

prob = 0
(43..100).each do |k|
  prob += binom(n, k)*p**k*(1-p)**(n-k)
end

puts prob
1 Like