math question

sneakyimp

i would like to generate a number between 2 and 7. i want my generating function to favor lower numbers and i want higher numbers to be less likely - the higher, the more remote ths possibility.

can anyone recommend a function?

NogDog

You could do something like this:

$randomNumber = min(rand(2, 7), rand(2, 7));

The more rand(2, 7) expressions you add to the min() function, the more it will be weighted toward the bottom.

etully

Sneaky,

It really depends on how you want it weighted.  Let's say you picked 1000 numbers.  Do you want them to be slightly weighted like this:

2: 200 times
3: 200 times
4: 150 times
5: 150 times
6: 100 times
7: 100 times

Do you wanted it weighted in a linear fashion like this:

2: 220 times
3: 200 times
4: 180 times
5: 160 times
6: 140 times
7: 120 times

Or do you want it distributed exponentially (curved) like this:

2: 600 times
3: 200 times
4: 100 times
5: 50 times
6: 30 times
7: 20 times

Or maybe some odd distribution like this:

2: 900 times
3: 20 times
4: 20 times
5: 20 times
6: 20 times
7: 20 times

All of those fit the pattern of favoring lower numbers and making higher numbers less likely. Once you can describe how they should be distributed, then we can pick a formula that hands out the numbers in that ratio.

sneakyimp

I'm partial to the linear and exponential options - and i would like to keep this idea as general as possible...so I can make it 2 to 7 or 1 to 350 or whatever.

My thinking wasn't so much that I would put a limit on how many items are 2 and how many are 3, 4, etc. but rather than I would specify how many events total and have them distributed over the range I specify. I realize that we need to specify some kind of gradient for the function and am totally open to any suggestions or ideas.

etully

It's not a question of hard and fast limits. I'm not suggesting some guarantee that the number 3 will show up exactly 47 times, no more, no less. That's not what I'm saying.

I'm talking about general statistically random distribution.

For example, let's say you build the function so that you pass it the low end, the high end, and the number of numbers you want returned like this:

function get_number_list(low,high,quantity) { }

And that function will return a number of numbers and you want to favor the low numbers. That's fine, but it doesn't answer the question of how MUCH you want to favor the low numbers.

For example, if you run the function and ask for low=17, high=36, and quantity=1000, what are the odds that the number should be a 36? Since there are 20 numbers in this particular range, if the numbers were all evenly distributed, you would see the number 36 about 50 times roughly. (About 50 out of the 1000 numbers would be a 36 which means that each number has about a 5% chance of being picked.) Or put another way, in an even distribution, 5% of the numbers will be a 17, and 5% of the numbers will be an 18, etc. all the way up to 36.

But you're saying you don't want that. You want the low numbers to appear in the list more often.

And that's fine, but it doesn't tell us HOW MUCH more often they should come up. Instead of an even distribution like this:

Lower numbers ------ up to the higher numbers -->
5% 5% 5% 5% 5% 5% 5% 5% 5% 5% 5% 5% 5% 5% 5% 5% 5% 5% 5% 5%

Do you want a sharp favor of the low numbers like this?

80% 10% 5% 1% 1% 1% 1% 1% 1% 1% 1% 1% 1% 1% 1% 1% 1% 1% 1% 1%

Or do you want a more gradual favoring of the lower numbers like this:

30% 15% 10% 5% 5% 5% 4% 4% 4% 2% 2% 2% 2% 2% 2% 2% 1% 1% 1% 1%

The answer to that question dictates the slope (or steepness) of the curve of the function that we will use to make sure that low numbers are favored over higher numbers.

bpat1434

How about doing both. Do a linear and exponential since he said he was favoring those.

etully

There are an infinite number of exponential functions and an infinite number of linear functions. Some heavily favor the lower numbers, some slightly favor the lower numbers. He says he wants to favor the lower numbers but I have no idea how much he wants to favor the lower numbers.

I could pick some exponential or linear function at random - or I could pick my favorite one - but it's no good to him for his particular application.

Let's say he's trying to pick prizes for a contest. Some people will win the $1000 prize but most people will win the $3 prize. If I choose a function that slightly favors the lower numbers, then he could end up giving away five or six prizes in the $900 range. If a choose a different function that heavily favors the lower numbers, then he only has to give away one or two prizes in the $900 range. To the person who's paying for the prizes, it makes a huge difference. Six times $900 is a lot more money than two times $900.

sneakyimp

What I'm trying to do is enter events into an event listing database for load testing. I want to favor events that are close to the current day and have fewer events that occur a year from now.

how much do i want to favor nearby days? I'm not sure yet. What I'm looking for is the basic mechanism I can use in php to do so with some reasonable amount of control.

I'm familiar with exponential decay:
http://en.wikipedia.org/wiki/Exponential_decay

what i'm not familiar with is how to implement it within the context of a php random number generator.

etully

// Pick a random number between 1 and 100
$x = rand(1,100);

// Divide by 100 so that the number is actually between 0.01 and 1
$x = $x / 100;

// Find the coresponding Y value associated with X on an exponential graph such as y=x²
$y = pow($x,2);

// Now Y is a number between .0001 and 1 but it's more likely to be closer to the lower end
// Now think of Y as a percentage and multiply it by the high end minus the low end
// for example, if you want to pick numbers from 30-40 but favor the lower end, you're
// really picking from 11 numbers and then adding 29

$r = ( rand(1,$high-$low) * $y ) + $low ;

That will give you one number in the range. If you wanted to make a function called create list that returns an array of n numbers, I would do it like this:

function create_list($low,$high,$n) {
	$i=0;
	$numbers = array();
	while ($i < $n) {
		$numbers[$i] = floor(( rand(1,$high-$low) * pow((rand(1,100) / 100),2) ) + $low ) ;
	$i++;
	}
return $numbers;
}

sneakyimp

my original attempt was much like your first suggestion:

function get_near_rnd($min, $max) {
  $r1 = rand($min, $max);
  $r2 = rand($min, $max);

  return $min + floor(($r1-1)/$r2);
} // get_rnd()

I have modified etully's suggestion a bit and put up a test page. it seems to work really well! good job, junor crumudgeon.

am i correct in thinking that if you set exp=1 you get a linear graph?

link (you can set the params yourself):
http://jaith.net/rand.php?lo=10&hi=20&div=20&exp=2&n=1000

Here's the code:

<?
// from etully with mods
function weighted_rand_list($low,$high,$n, $div, $exp) {
  if ($div==0) die('division by zero not permitted');
  $i=0;
  $numbers = array();
  while ($i < $n) {
    $numbers[$i] = rand_weighted($low, $high, $div, $exp);
    $i++;
  }
  return $numbers;
}

function rand_weighted($low, $high, $div, $exp) {
  if ($div==0) die('division by zero not permitted');
  $adiv = abs($div);
  $result = floor(( rand(1,$high-$low) * pow((rand(1,$div) / $div),$exp) ) + $low ) ;
  return $result;
}

// validate
if (is_numeric($_GET['lo'])) {
  $lo = $_GET['lo'];
  echo 'low:' . $lo . '<br>';
} else {
  die('lo is not numeric');
}

if (is_numeric($_GET['hi'])) {
  $hi = $_GET['hi'];
  echo 'hi:' . $hi . '<br>';
} else {
  die('hi is not numeric');
}

if (is_numeric($_GET['div'])) {
  $div = $_GET['div'];
  echo 'div:' . $div . '<br>';
} else {
  die('div is not numeric');
}

if (is_numeric($_GET['exp'])) {
  $exp = $_GET['exp'];
  echo 'exp:' . $exp . '<br>';
} else {
  die('exp is not numeric');
}

if (is_numeric($_GET['n'])) {
  $n = $_GET['n'];
  echo 'n:' . $n . '<br>';
} else {
  die('n is not numeric');
}


// tha test

$rands = weighted_rand_list($lo, $hi, $n, $div, $exp);
echo 'items in random array:' . sizeof($rands) . '<br>';

// make a graph
$frequencies = array();
for($i=($lo-10); $i<=($hi+10); $i++) {
  $frequencies[$i] = 0;
}

reset($rands);
foreach($rands as $i => $num) {
  if (!isset($frequencies[$num])) {
    $frequencies[$num] = 0;
  }

  $frequencies[$num]++;

}

ksort($frequencies);
reset($frequencies);

echo '<table width="100%" border="0" cellspacing="0" cellpadding="0" style="font-size:9px;">';
echo ' <tr>';
echo '  <td width="1%">number</td>';
echo '  <td>occurrences</td>';
echo ' </tr>';

$freq_sum = 0;
foreach($frequencies as $val => $freq) {
  $freq_sum += $freq;
  echo ' <tr>';
  echo '  <td alight="right">' . $val . '  </td>';
  echo '  <td align="left">';
  if ($freq == 0) {
    echo '-';
  } else {
    echo '   <img src="images/redpix.gif" height="5" width="' . $freq . '" title="' . $freq . '">';
  }
  echo '  </td>';
  echo ' </tr>';
}

echo '</table>';

echo 'all frequencies sum to:' . $freq_sum . '<br>';
?>

suntra

Well you could use a "X^2" equation...

Remember : y = ax² + bx + c

Let's say we have a maximum number : M

If a < 0, then you have an inverted curve.

Let's use a = -1/M, b = 0, and c = M

So, at 0, you can have a number between between 0 and M, and at M, only zero...

So, first thing to do is to get a random value between 0 and M to set the value of x...

Then, with the formula shown above, set the value of Y...

Finall, let's set a random value between 0 and $intY...

$intM = 30; // for example
$intA = -1 / $intM;
$intB = 0;
$intC = $intM;
$intX = rand(0, $intM);
$intY = ($intA * pow($intX, 2)) + ($intB * $intX) + $intC;
$intR = rand(0, $intY);

There you go !

suntra

After 1 000 000 repetitions in a for loop, this is what I get :

1 : 73543 (7.3543 %)
2 : 57188 (5.7188 %)
3 : 57424 (5.7424 %)
4 : 49194 (4.9194 %)
5 : 49444 (4.9444 %)
6 : 44139 (4.4139 %)
7 : 43824 (4.3824 %)
8 : 39922 (3.9922 %)
9 : 39857 (3.9857 %)
10 : 36619 (3.6619 %)
11 : 33876 (3.3876 %)
12 : 33692 (3.3692 %)
13 : 31497 (3.1497 %)
14 : 28749 (2.8749 %)
15 : 29172 (2.9172 %)
16 : 26788 (2.6788 %)
17 : 25334 (2.5334 %)
18 : 22943 (2.2943 %)
19 : 23315 (2.3315 %)
20 : 21844 (2.1844 %)
21 : 20077 (2.0077 %)
22 : 18488 (1.8488 %)
23 : 17577 (1.7577 %)
24 : 15631 (1.5631 %)
25 : 14706 (1.4706 %)
26 : 12335 (1.2335 %)
27 : 10802 (1.0802 %)
28 : 8606 (0.8606 %)
29 : 6475 (0.6475 %)
30 : 1037 (0.1037 %)