Transforms

/**
 * Objects implementing the {@link Transform} interface share common methods
 * including {@link Transform#convert(double)}, which maps driver values
 * (double-precision values between zero and unity) into the range of the
 * transform.
 * @author Charles Ames
 * @param <T> The type of output from {@link Transform#convert(double)}.
 * Discrete transforms map driver values to {@link Integer} results.
 * Continuous transforms map driver values to {@link Double} results.
 */
public interface Transform<T extends Number> {
   /**
    * Transform the indicated driver value.
    * @param driver The indicated driver value.
    * @return The transformed result.
    */
   public T convert(double driver);
   /**
    * Call on the indicated {@link Driver} instance to select a value.
    * @param driver The indicated {@link Driver} instance.
    * @return The selected value.
    * @throws RuntimeException when the distribution has not been
    * normalized.
    */
   public T convert(Driver driver);
   /**
    * Transform a driver value drawn from the assigned {@link Driver} instance.
    * @param driver The indicated driver value.
    * @throws NoSuchObjectException When the driver field has not been assigned.
    * @return The transformed result.
    */
   public T next();
   /**
    * Set the source from which driver values will be drawn when
    * the {@link Transform#next()} method is called.
    * @param driver The intended source for driver values.
    */
   public void setDriver(Driver driver);
   /**
    * Get the source from which driver values are being drawn when
    * the {@link Transform#next()} method is called.
    * @throws NoSuchObjectException When the driver field has not been assigned.
    * @return The assigned source for driver values.
    */
   public Driver getDriver();
   /**
    * Get the lower range bound.
    * @return the lower range bound.
    */
   public T minRange();
   /**
    * Get the upper range bound.
    * @return the upper range bound.
    */
   public T maxRange();
   /**
    * Calculate a practical lower bound for graphing output from this
    * transform.
    * @param tail The combined weight of out-of-range values.  Ranges
    * from zero to unity, but smaller values are suggested.
    * @return A practical lower bound for graphing output from this
    * transform.
    * @throws IllegalArgumentException when the tail falls outside the
    * domain from zero to unity.
    */
   public T minGraphValue(double tail);
   /**
    * Calculate a practical upper bound for graphing output from this
    * transform.
    * @param tail The combined weight of out-of-range values.  Ranges
    * from zero to unity, but smaller values are suggested.
    * @return A practical upper bound for graphing output from this
    * transform.
    * @throws IllegalArgumentException when the tail falls outside the
    * range from zero to unity.
    */
   public T maxGraphValue(double tail);
   /**
    * The {@link DiscreteTransform} interface particularizes
    * the {@link Transform} interface to classes whose
    * {@link Transform#convert(Integer)} method outputs
    * double-precision numbers.
    * @author Charles Ames
    */
   public interface Discrete
   extends Transform<Integer>, Indexer {}
   /**
    * The {@link ContinuousTransform} interface particularizes
    * the {@link Transform} interface to classes whose
    * {@link Transform#convert(Double)} method outputs
    * double-precision numbers.
    * @author Charles Ames
    */
   public interface Continuous
   extends Transform<Double> {}
}

 /**
 * The abstract {@link TransformBase} class implements base functionality
 * objects satisfying the {@link Transform} interface.
 * Many discrete {@link TransformBase} instances wrap
 * {@link DiscreteDistribution}, while many continuous
 * {@link TransformBase} instances wrap {@link ContinuousDistribution}.
 * @param <T> The type of value selected:
 * Discrete transforms map driver values to {@link Integer} results.
 * Continuous transforms map driver values to {@link Double} results.
 * @author Charles Ames
 */
public abstract class TransformBase<T extends Number>
extends WriteableEntity implements Transform<T> {
   private Driver driver;
   /**
    * Constructor for {@link TransformBase} instances with container.
    * @param container An entity which contains this transform.
    */
   public TransformBase(WriteableEntity container) {
      super(container);
      this.driver = null;
   }
   @Override
   public T convert(Driver driver) {
      return convert(driver.next());
   }
   @Override
   public final T next() {
      return convert(getDriver());
   }
   /**
    * Test if the sequence of values still contains values not yet presented.
    * @return true if unpresented values remain pending; false otherwise.
    * if the sequence is complete.
    * @throws {@link UnsupportedOperationException} when no driver has been assigned.
    */
   public final boolean hasNext() {
      Driver driver = getDriver();
      return driver.hasNext();
   }
   @Override
   public final Driver getDriver() {
      if (null == driver)
         throw new NoSuchObjectException("Driver not assigned");
      return driver;
   }
   @Override
   public void setDriver(Driver driver) {
      this.driver = driver;
   }
}