Continuous Transforms

/**
 * The {@link ContinuousDistributionTransform} class implements a
 * continuous statistical transform leveraging a
 * {@link ContinuousDistribution} instance which is referenced internally.
 * @author Charles Ames
 */
public abstract class ContinuousDistributionTransform
extends TransformBase<Double> implements Transform.Continuous {
   private ContinuousDistribution distribution;
   /**
    * Constructor for {@link ContinuousDistributionTransform} instances.
    * @param container An entity which contains this transform.
    */
   public ContinuousDistributionTransform(WriteableEntity container) {
      super(container);
   }
   protected ContinuousDistribution getDistribution() {
      if (null == distribution) {
         distribution = new ContinuousDistribution(null);
      }
      return distribution;
   }
   /**
    * Add a new range interval with associated leftmost and rightmost
    * weights.
    * @param left Leftmost ordinate.
    * @param right Rightmost ordinate
    * @param origin Weight for leftmost ordinate.
    * @param goal Weight for rightmost ordinate.
    * @throws IllegalArgumentException when right is &le; left.
    * @throws IllegalArgumentException when the value is negative or
    * when the new interval of values
    * is not contiguous with the existing range of values.
    * @throws IllegalArgumentException when either the origin is
    * negative or the goal is negative.
    */
   public final void addItem(double left, double right, double origin, double goal) {
      distribution.addItem(left, right, origin, goal);
   }
   /**
    * Get the heaviest weight in the distribution.
    * @return The heaviest weight.
    * @throws IllegalArgumentException when the distribution has
    * not been normalized.
    * @throws RuntimeException when the distribution has no peak-weight item.
    */
   public final double getHeaviestWeight() {
      ContinuousDistributionItem heaviestItem = distribution.getHeaviestItem();
      return Double.max(heaviestItem.getOrigin(), heaviestItem.getGoal());
   }
   @Override
   public Double convert(double driver) {
      if (null == distribution)
         throw new UninitializedException("Distribution not initialized");
      return distribution.quantile(driver);
   }
   @Override
   public Double minGraphValue(double tail) {
      return distribution.minGraphValue(tail);
   }
   @Override
   public Double maxGraphValue(double tail) {
      return distribution.maxGraphValue(tail);
   }
   @Override
   public Double minRange() {
      return distribution.minRange();
   }
   @Override
   public Double maxRange() {
      return distribution.maxRange();
   }
}

/**
 * The {@link BoundedTransform} class partially implements a continuous
 * statistical transform mapping the driver domain from zero to unity
 * to a finite range which is bounded by {@link #minRange} and
 * {@link maxRange} fields.
 * @author Charles Ames
 */
public abstract class BoundedTransform
extends ContinuousDistributionTransform {
   /**
    * Determines the leftmost bound of the range.
    */
   private double minRange;
   /**
    * Determines the rightmost bound of the range.
    */
   private double maxRange;
   /**
    * Constructor for {@link BoundedTransform} instances.
    * @param container An entity which contains this transform.
    */
   public BoundedTransform(WriteableEntity container) {
      super(container);
      this.minRange = Double.NaN;
      this.maxRange = Double.NaN;
   }
   /**
    * Getter for {@link #minRange}.
    * @return The assigned {@link #minRange} value.
    * @throws UninitializedException when {@link #minRange}
    * is not initialized.
    */
   @Override
   public final Double minRange() {
      if (Double.isNaN(this.minRange))
         throw new UninitializedException("Min range not initialized");
      return this.minRange;
   }
   /**
    * Setter for {@link #minRange}.
    * @param minRange The intended {@link #minRange} value.
    */
   public final void setMinRange(double minRange) {
      checkMinRange(minRange);
      this.minRange = minRange;
   }
   /**
    * Check if the indicated value is suitable for {@link #minRange}.
    * @param minRange The indicated value.
    */
   public final void checkMinRange(double minRange) {
      if (!Double.isNaN(this.maxRange)) {
         if (this.maxRange - minRange < MathMethods.TINY) {
            throw new IllegalArgumentException(
                  "Max range not significantly greater than min range.");
         }
      }
   }
   /**
    * Getter for {@link #maxRange}.
    * @return The assigned {@link #maxRange} value.
    * @throws UninitializedException when {@link #maxRange}
    * is not initialized.
    */
   @Override
   public final Double maxRange() {
      if (Double.isNaN(this.maxRange))
         throw new UninitializedException("Max range not initialized");
      return this.maxRange;
   }
   /**
    * Setter for {@link #maxRange}.
    * @param maxRange The intended {@link #maxRange} value.
    */
   public final void setMaxRange(double maxRange) {
      checkMaxRange(maxRange);
      this.maxRange = maxRange;
   }
   /**
    * Check if the indicated value is suitable for {@link #maxRange}.
    * @param maxRange The indicated value.
    */
   public final void checkMaxRange(double maxRange) {
      if (!Double.isNaN(this.minRange)) {
         if (maxRange - this.minRange < MathMethods.TINY) {
            throw new IllegalArgumentException(
                  "Max range not significantly greater than min range.");
         }
      }
   }
   @Override
   public final Double minGraphValue(double tail) {
      return minRange();
   }
   @Override
   public final Double maxGraphValue(double tail) {
      return maxRange();
   }
   @Override
   public Double convert(double driver) {
      return interpolate(super.convert(driver));
   }
   /**
    * Take an interpolation factor, scale it to the range (max-min),
    * then offset it by the lower bound.
    * @param factor Argument ranging from zero to unity.
    * @return A value interpolated between {@link minRange}
    * and {@link maxRange}.
    */
   public Double interpolate(double factor) {
      double l = minRange();
      return (maxRange()-l) * factor + l;
   }
}