Bell curve with left or right bias

Question

In Java I want to generate a random number from 1 to 100 that can be made to be based to either end of the scale whilst still having a chance of a number from the opposite end still being 'rolled'.

To clarify, in a normal situation over a number of rolls of 1 - 100 the average will be 50, but in some situations I want the average to shift down to say, 25%. But with there still being chance for 100% to be generated.

I have looked at Random.nextGaussian, which does shift the bell curve, but for a low end value this removes high end posibilities.

What formula or combination of formulas should I be using?

Bell_curve_with_shift

Answer 1

1. Work out the exact form of the distribution that you want.

2. Calculate the quantile function for that distribution.

3. Draw a uniform random number in [0, 1) using an appropriate generator.

4. That is the input to the quantile function.

The resulting numbers will be distributed as you need.

Answer 2

Figured out some easy ways to at least approach a result like this. I sort of failed grasping the math behind this all so I mostly arrived at this with trial and error and when I got something that looked good enough I called it a day.

Found two approaches:

1. Basically creating the triangular distribution and then adjusting its values with simple exponentiation. It creates a shape that is similar to the bell curve but it's got a sharp spike at the peak rather than a dull one. By changing the exponent the curve approaching the peak can either be concave or convex.

   

   /**
    * @param min lower bound
    * @param max upper bound
    * @param avg mode <min, max>
    * @param exp convex (0, 0.5> or concave <0.5, 1> or linear (0.5)
    */
   public static double triangleExponential(double min, double max, double avg, double exp) {
       if (min >= max || avg < min || avg > max) {
           throw new IllegalArgumentException();
       }
       double pivot = MathUtils.range(avg, min, max, 0, 1);
       double x = generator.nextUniform(0, 1);
       double nx;
       if (x < pivot) {
           nx = MathUtils.range(x, 0, pivot, 0, 1);
           nx = Math.pow(nx, exp);
           nx = MathUtils.range(nx, 0, 1, 0, pivot);
       } else {
           nx = MathUtils.range(x, pivot, 1, 0, 1);
           nx = 1 - Math.pow(nx, exp);
           nx = MathUtils.range(nx, 0, 1, pivot, 1);
       }
       return MathUtils.range(nx, 0, 1, min, max);
   }
   

2. Second approach it to just take the gaussian distribution and squish/stretch it as needed.

   

   /**
    * @param min lower bound
    * @param max upper bound
    * @param avg mode <min, max>
    * @param exp 'peak sharpness' (0, 2>
    */
   public static double squishedGaussian(double min, double max, double avg, double exp) {
       if (min >= max || avg < min || avg > max) {
           throw new IllegalArgumentException();
       }
       double pivot = MathUtils.range(avg, min, max, 0, 1);
       double uniform = generator.nextUniform(0, 1);
       double x = generateGaussian();
       if (uniform < pivot) {
           x = Math.pow(x, exp);
           x = MathUtils.range(x, 0, 1, 0, pivot);
       } else {
           x = 1 - (Math.pow(x, exp));
           x = MathUtils.range(x, 0, 1, pivot, 1);
       }
       return MathUtils.range(x, 0, 1, min, max);
   }
   
   static double generateGaussian() {
       double gaussianMax = 5; //Its more like 5.4
       double rand;
       do {
           rand = Math.abs(generator.nextGaussian(0, 1));
       } while (rand > gaussianMax);
       return 1 - MathUtils.range(rand, 0, gaussianMax, 0, 1);
   }
   

MathUtils.range is just a value range remapping function

    public static double range(double OldValue, double OldMin, double OldMax, double NewMin, double NewMax) {
        return (((OldValue - OldMin) * (NewMax - NewMin)) / (OldMax - OldMin)) + NewMin;
    }

and the generator is the RandomDataGenerator class from org.apache.commons.math3.random