Proximate Randomness: Moderate¹

Figure 3: Histogram of sample-to-sample differences from Moderate.next() after 10,000 consecutive samples.

Transitions

Figure 3 plots the range of sample-to-sample differences along the vertical Δx axis against the relative concentrations of these values along the horizontal f(Δx) axis. Compared to the the Borel driver, concentrations drop more closely to zero, both as Δx approaches -1 from above and as Δx approaches 1 from below. The standard deviation of Δx around zero is 0.234, which is well short both of the 0.410 deviation found for the Lehmer driver and of the 0.353 deviation found for the Borel driver — an indication of proximity dependence.

Figure 4: Divergence of 4-nibble pattern counts from Moderate.next() with 10,000 samples per pattern.

Independence

Figure 4 presents a trend graph of histogram tallies for 4-nibble patterns generated using Moderate.next(). My first attempt to produce this graph following the methods used for the Lehmer driver flatlined with negligible tallies at all points. To obtain a nontrivial result it was necessary to limit the graph to the 2049 largest tallies. The most frequent patterns were 0 0 0 0, and 15 15 15 15, both having an under 1% presence. Following with some 1/3 the maximum presence were the patterns 1 0 0 0 and 14 15 15 15. These details are consistent with the histogram on the right side of Figure 2, which has samples concentrating at the bottom and top of the driver range.

The glaring conclusion from Figure 4 is that the Moderate driver fails the 4-nibble independence test, and does so dramatically.

/**
 * Instances of the {@link Moderate} class generate a driver sequence using
 * John Myhill's method of moderated randomness.
 * @author Charles Ames
 */
public class Moderate extends DriverBase {
   /**
    * Constructor for {@link Moderate} instances with container.
    * @param container An entity which contains this driver.
    */
   public Moderate(WriteableEntity container) {
      super(container);
   }
   /**
    * Constructor for {@link Moderate} instances without container.
    */
   public Moderate() {
      super(null);
   }
   @Override
   protected double generate() {
      double value = getValue();
      Random random = getRandom();
      if (.5 < random.nextDouble()) {
         double a = value * random.nextDouble();
         double b = value * random.nextDouble();
         value = value - Math.abs(b - a);
      }
      else {
         double a = value + (1. - value) * random.nextDouble();
         double b = value + (1. - value) * random.nextDouble();
         value = value + Math.abs(b - a);
      }
      return value;
   }
}

Coding

The type hierarchy for Moderate is:

• DriverBase extends WriteableEntity implements Driver
• Moderate extends DriverBase

Listing 1 provides the source code for the Moderate class. The sequential process described at the top of this page is implemented by generate(), which is not public facing. Instead, generate() is called by DriverBase.next().

DriverBase.next() also takes care to store the new sample in the field DriverBase.value, where generate() can employ DriverBase.getValue() to pick this (now previous) sample up for the next sample iteration. DriverBase also offers setValue() and randomizeValue() methods to establish the initial sequence value.