commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From t.@apache.org
Subject svn commit: r1241567 - in /commons/proper/math/trunk/src: main/java/org/apache/commons/math/random/ test/java/org/apache/commons/math/random/
Date Tue, 07 Feb 2012 19:29:33 GMT
Author: tn
Date: Tue Feb  7 19:29:32 2012
New Revision: 1241567

URL: http://svn.apache.org/viewvc?rev=1241567&view=rev
Log:
Merged EmpiricalDistributionImpl into EmpiricalDistribution, updated javadoc.
JIRA: MATH-670

Removed:
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/EmpiricalDistributionImpl.java
Modified:
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/EmpiricalDistribution.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/ValueServer.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/EmpiricalDistributionTest.java

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/EmpiricalDistribution.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/EmpiricalDistribution.java?rev=1241567&r1=1241566&r2=1241567&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/EmpiricalDistribution.java
(original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/EmpiricalDistribution.java
Tue Feb  7 19:29:32 2012
@@ -17,21 +17,32 @@
 
 package org.apache.commons.math.random;
 
-import java.io.IOException;
+import java.io.BufferedReader;
 import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Serializable;
 import java.net.URL;
+import java.util.ArrayList;
 import java.util.List;
 
+import org.apache.commons.math.exception.MathIllegalArgumentException;
+import org.apache.commons.math.exception.MathIllegalStateException;
 import org.apache.commons.math.exception.NullArgumentException;
+import org.apache.commons.math.exception.ZeroException;
+import org.apache.commons.math.exception.util.LocalizedFormats;
 import org.apache.commons.math.stat.descriptive.StatisticalSummary;
 import org.apache.commons.math.stat.descriptive.SummaryStatistics;
+import org.apache.commons.math.util.FastMath;
+import org.apache.commons.math.util.MathUtils;
 
 /**
- * Represents an <a href="http://random.mat.sbg.ac.at/~ste/dipl/node11.html">
+ * Represents an <a href="http://http://en.wikipedia.org/wiki/Empirical_distribution_function">
  * empirical probability distribution</a> -- a probability distribution derived
  * from observed data without making any assumptions about the functional form
  * of the population distribution that the data come from.<p>
- * Implementations of this interface maintain data structures, called
+ * An <code>EmpiricalDistribution</code> maintains data structures, called
  * <i>distribution digests</i>, that describe empirical distributions and
  * support the following operations: <ul>
  * <li>loading the distribution from a file of observed data values</li>
@@ -41,22 +52,183 @@ import org.apache.commons.math.stat.desc
  *     as well as the observations within each bin</li>
  * <li>generating random values from the distribution</li>
  * </ul>
- * Applications can use <code>EmpiricalDistribution</code> implementations to
- * build grouped frequency histograms representing the input data or to
- * generate random values "like" those in the input file -- i.e., the values
- * generated will follow the distribution of the values in the file.</p>
+ * Applications can use <code>EmpiricalDistribution</code> to build grouped
+ * frequency histograms representing the input data or to generate random values
+ * "like" those in the input file -- i.e., the values generated will follow the
+ * distribution of the values in the file.</p>
+ * <p>The implementation uses what amounts to the
+ * <a href="http://nedwww.ipac.caltech.edu/level5/March02/Silverman/Silver2_6.html">
+ * Variable Kernel Method</a> with Gaussian smoothing:<p>
+ * <strong>Digesting the input file</strong>
+ * <ol><li>Pass the file once to compute min and max.</li>
+ * <li>Divide the range from min-max into <code>binCount</code> "bins."</li>
+ * <li>Pass the data file again, computing bin counts and univariate
+ *     statistics (mean, std dev.) for each of the bins </li>
+ * <li>Divide the interval (0,1) into subintervals associated with the bins,
+ *     with the length of a bin's subinterval proportional to its count.</li></ol>
+ * <strong>Generating random values from the distribution</strong><ol>
+ * <li>Generate a uniformly distributed value in (0,1) </li>
+ * <li>Select the subinterval to which the value belongs.
+ * <li>Generate a random Gaussian value with mean = mean of the associated
+ *     bin and std dev = std dev of associated bin.</li></ol></p><p>
+ *<strong>USAGE NOTES:</strong><ul>
+ *<li>The <code>binCount</code> is set by default to 1000.  A good rule
of thumb
+ *    is to set the bin count to approximately the length of the input file divided
+ *    by 10. </li>
+ *<li>The input file <i>must</i> be a plain text file containing one valid
numeric
+ *    entry per line.</li>
+ * </ul></p>
  *
  * @version $Id$
  */
-public interface EmpiricalDistribution {
+public class EmpiricalDistribution implements Serializable {
+
+    /** Default bin count */
+    public static final int DEFAULT_BIN_COUNT = 1000;
+
+    /** Serializable version identifier */
+    private static final long serialVersionUID = 5729073523949762654L;
+
+    /** List of SummaryStatistics objects characterizing the bins */
+    private final List<SummaryStatistics> binStats;
+
+    /** Sample statistics */
+    private SummaryStatistics sampleStats = null;
+
+    /** Max loaded value */
+    private double max = Double.NEGATIVE_INFINITY;
+
+    /** Min loaded value */
+    private double min = Double.POSITIVE_INFINITY;
+
+    /** Grid size */
+    private double delta = 0d;
+
+    /** number of bins */
+    private final int binCount;
+
+    /** is the distribution loaded? */
+    private boolean loaded = false;
+
+    /** upper bounds of subintervals in (0,1) "belonging" to the bins */
+    private double[] upperBounds = null;
+
+    /** RandomDataImpl instance to use in repeated calls to getNext() */
+    private final RandomDataImpl randomData;
+
+    /**
+     * Creates a new EmpiricalDistribution with the default bin count.
+     */
+    public EmpiricalDistribution() {
+        this(DEFAULT_BIN_COUNT, new RandomDataImpl());
+    }
+
+    /**
+     * Creates a new EmpiricalDistribution with the specified bin count.
+     *
+     * @param binCount number of bins
+     */
+    public EmpiricalDistribution(int binCount) {
+        this(binCount, new RandomDataImpl());
+    }
+
+    /**
+     * Creates a new EmpiricalDistribution with the specified bin count using the
+     * provided {@link RandomGenerator} as the source of random data.
+     *
+     * @param binCount number of bins
+     * @param generator random data generator (may be null, resulting in default JDK generator)
+     * @since 3.0
+     */
+    public EmpiricalDistribution(int binCount, RandomGenerator generator) {
+        this.binCount = binCount;
+        randomData = new RandomDataImpl(generator);
+        binStats = new ArrayList<SummaryStatistics>();
+    }
+
+    /**
+     * Creates a new EmpiricalDistribution with default bin count using the
+     * provided {@link RandomGenerator} as the source of random data.
+     *
+     * @param generator random data generator (may be null, resulting in default JDK generator)
+     * @since 3.0
+     */
+    public EmpiricalDistribution(RandomGenerator generator) {
+        this(DEFAULT_BIN_COUNT, generator);
+    }
+
+    /**
+     * Creates a new EmpiricalDistribution with the specified bin count using the
+     * provided {@link RandomDataImpl} instance as the source of random data.
+     *
+     * @param binCount number of bins
+     * @param randomData random data generator (may be null, resulting in default JDK generator)
+     * @since 3.0
+     */
+    public EmpiricalDistribution(int binCount, RandomDataImpl randomData) {
+        this.binCount = binCount;
+        this.randomData = randomData;
+        binStats = new ArrayList<SummaryStatistics>();
+    }
 
     /**
+     * Creates a new EmpiricalDistribution with default bin count using the
+     * provided {@link RandomDataImpl} as the source of random data.
+     *
+     * @param randomData random data generator (may be null, resulting in default JDK generator)
+     * @since 3.0
+     */
+    public EmpiricalDistribution(RandomDataImpl randomData) {
+        this(DEFAULT_BIN_COUNT, randomData);
+    }
+
+     /**
      * Computes the empirical distribution from the provided
      * array of numbers.
      *
-     * @param dataArray the data array
+     * @param in the input data array
+     * @exception NullArgumentException if in is null
      */
-    void load(double[] dataArray);
+    public void load(double[] in) throws NullArgumentException {
+        DataAdapter da = new ArrayDataAdapter(in);
+        try {
+            da.computeStats();
+            fillBinStats(in);
+        } catch (IOException e) {
+            throw new MathIllegalStateException(e, LocalizedFormats.SIMPLE_MESSAGE, e.getLocalizedMessage());
+        }
+        loaded = true;
+
+    }
+
+    /**
+     * Computes the empirical distribution using data read from a URL.
+     * @param url  url of the input file
+     *
+     * @throws IOException if an IO error occurs
+     * @throws NullArgumentException if url is null
+     */
+    public void load(URL url) throws IOException, NullArgumentException {
+        MathUtils.checkNotNull(url);
+        BufferedReader in =
+            new BufferedReader(new InputStreamReader(url.openStream()));
+        try {
+            DataAdapter da = new StreamDataAdapter(in);
+            da.computeStats();
+            if (sampleStats.getN() == 0) {
+                throw new ZeroException(LocalizedFormats.URL_CONTAINS_NO_DATA, url);
+            }
+            in = new BufferedReader(new InputStreamReader(url.openStream()));
+            fillBinStats(in);
+            loaded = true;
+        } finally {
+           try {
+               in.close();
+           } catch (IOException ex) {
+               // ignore
+           }
+        }
+    }
 
     /**
      * Computes the empirical distribution from the input file.
@@ -65,72 +237,332 @@ public interface EmpiricalDistribution {
      * @throws IOException if an IO error occurs
      * @throws NullArgumentException if file is null
      */
-    void load(File file) throws IOException;
+    public void load(File file) throws IOException, NullArgumentException {
+        MathUtils.checkNotNull(file);
+        BufferedReader in = new BufferedReader(new FileReader(file));
+        try {
+            DataAdapter da = new StreamDataAdapter(in);
+            da.computeStats();
+            in = new BufferedReader(new FileReader(file));
+            fillBinStats(in);
+            loaded = true;
+        } finally {
+            try {
+                in.close();
+            } catch (IOException ex) {
+                // ignore
+            }
+        }
+    }
 
     /**
-     * Computes the empirical distribution using data read from a URL.
+     * Provides methods for computing <code>sampleStats</code> and
+     * <code>beanStats</code> abstracting the source of data.
+     */
+    private abstract class DataAdapter{
+
+        /**
+         * Compute bin stats.
+         *
+         * @throws IOException  if an error occurs computing bin stats
+         */
+        public abstract void computeBinStats() throws IOException;
+
+        /**
+         * Compute sample statistics.
+         *
+         * @throws IOException if an error occurs computing sample stats
+         */
+        public abstract void computeStats() throws IOException;
+
+    }
+
+    /**
+     * Factory of <code>DataAdapter</code> objects. For every supported source
+     * of data (array of doubles, file, etc.) an instance of the proper object
+     * is returned.
+     */
+    private class DataAdapterFactory{
+        /**
+         * Creates a DataAdapter from a data object
+         *
+         * @param in object providing access to the data
+         * @return DataAdapter instance
+         */
+        public DataAdapter getAdapter(Object in) {
+            if (in instanceof BufferedReader) {
+                BufferedReader inputStream = (BufferedReader) in;
+                return new StreamDataAdapter(inputStream);
+            } else if (in instanceof double[]) {
+                double[] inputArray = (double[]) in;
+                return new ArrayDataAdapter(inputArray);
+            } else {
+                throw new MathIllegalArgumentException(
+                      LocalizedFormats.INPUT_DATA_FROM_UNSUPPORTED_DATASOURCE,
+                      in.getClass().getName(),
+                      BufferedReader.class.getName(), double[].class.getName());
+            }
+        }
+    }
+    /**
+     * <code>DataAdapter</code> for data provided through some input stream
+     */
+    private class StreamDataAdapter extends DataAdapter{
+
+        /** Input stream providing access to the data */
+        private BufferedReader inputStream;
+
+        /**
+         * Create a StreamDataAdapter from a BufferedReader
+         *
+         * @param in BufferedReader input stream
+         */
+        public StreamDataAdapter(BufferedReader in){
+            super();
+            inputStream = in;
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void computeBinStats() throws IOException {
+            String str = null;
+            double val = 0.0d;
+            while ((str = inputStream.readLine()) != null) {
+                val = Double.parseDouble(str);
+                SummaryStatistics stats = binStats.get(findBin(val));
+                stats.addValue(val);
+            }
+
+            inputStream.close();
+            inputStream = null;
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void computeStats() throws IOException {
+            String str = null;
+            double val = 0.0;
+            sampleStats = new SummaryStatistics();
+            while ((str = inputStream.readLine()) != null) {
+                val = Double.valueOf(str).doubleValue();
+                sampleStats.addValue(val);
+            }
+            inputStream.close();
+            inputStream = null;
+        }
+    }
+
+    /**
+     * <code>DataAdapter</code> for data provided as array of doubles.
+     */
+    private class ArrayDataAdapter extends DataAdapter {
+
+        /** Array of input  data values */
+        private double[] inputArray;
+
+        /**
+         * Construct an ArrayDataAdapter from a double[] array
+         *
+         * @param in double[] array holding the data
+         * @throws NullArgumentException if in is null
+         */
+        public ArrayDataAdapter(double[] in) throws NullArgumentException {
+            super();
+            MathUtils.checkNotNull(in);
+            inputArray = in;
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void computeStats() throws IOException {
+            sampleStats = new SummaryStatistics();
+            for (int i = 0; i < inputArray.length; i++) {
+                sampleStats.addValue(inputArray[i]);
+            }
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public void computeBinStats() throws IOException {
+            for (int i = 0; i < inputArray.length; i++) {
+                SummaryStatistics stats =
+                    binStats.get(findBin(inputArray[i]));
+                stats.addValue(inputArray[i]);
+            }
+        }
+    }
+
+    /**
+     * Fills binStats array (second pass through data file).
      *
-     * @param url url of the input file
-     * @throws IOException if an IO error occurs
-     * @throws NullArgumentException if url is null
+     * @param in object providing access to the data
+     * @throws IOException  if an IO error occurs
      */
-    void load(URL url) throws IOException, NullArgumentException;
+    private void fillBinStats(Object in) throws IOException {
+        // Set up grid
+        min = sampleStats.getMin();
+        max = sampleStats.getMax();
+        delta = (max - min)/(Double.valueOf(binCount)).doubleValue();
+
+        // Initialize binStats ArrayList
+        if (!binStats.isEmpty()) {
+            binStats.clear();
+        }
+        for (int i = 0; i < binCount; i++) {
+            SummaryStatistics stats = new SummaryStatistics();
+            binStats.add(i,stats);
+        }
+
+        // Filling data in binStats Array
+        DataAdapterFactory aFactory = new DataAdapterFactory();
+        DataAdapter da = aFactory.getAdapter(in);
+        da.computeBinStats();
+
+        // Assign upperBounds based on bin counts
+        upperBounds = new double[binCount];
+        upperBounds[0] =
+        ((double) binStats.get(0).getN()) / (double) sampleStats.getN();
+        for (int i = 1; i < binCount-1; i++) {
+            upperBounds[i] = upperBounds[i-1] +
+            ((double) binStats.get(i).getN()) / (double) sampleStats.getN();
+        }
+        upperBounds[binCount-1] = 1.0d;
+    }
+
+    /**
+     * Returns the index of the bin to which the given value belongs
+     *
+     * @param value  the value whose bin we are trying to find
+     * @return the index of the bin containing the value
+     */
+    private int findBin(double value) {
+        return FastMath.min(
+                FastMath.max((int) FastMath.ceil((value- min) / delta) - 1, 0),
+                binCount - 1);
+        }
 
     /**
      * Generates a random value from this distribution.
      * <strong>Preconditions:</strong><ul>
      * <li>the distribution must be loaded before invoking this method</li></ul>
      * @return the random value.
-     *
-     * @throws IllegalStateException if the distribution has not been loaded
+     * @throws MathIllegalStateException if the distribution has not been loaded
      */
-    double getNextValue() throws IllegalStateException;
+    public double getNextValue() throws MathIllegalStateException {
 
+        if (!loaded) {
+            throw new MathIllegalStateException(LocalizedFormats.DISTRIBUTION_NOT_LOADED);
+        }
+
+        // Start with a uniformly distributed random number in (0,1)
+        double x = randomData.nextUniform(0,1);
+
+        // Use this to select the bin and generate a Gaussian within the bin
+        for (int i = 0; i < binCount; i++) {
+           if (x <= upperBounds[i]) {
+               SummaryStatistics stats = binStats.get(i);
+               if (stats.getN() > 0) {
+                   if (stats.getStandardDeviation() > 0) {  // more than one obs
+                        return randomData.nextGaussian
+                            (stats.getMean(),stats.getStandardDeviation());
+                   } else {
+                       return stats.getMean(); // only one obs in bin
+                   }
+               }
+           }
+        }
+        throw new MathIllegalStateException(LocalizedFormats.NO_BIN_SELECTED);
+    }
 
     /**
-     * Returns a
-     * {@link org.apache.commons.math.stat.descriptive.StatisticalSummary}
-     * describing this distribution.
+     * Returns a {@link StatisticalSummary} describing this distribution.
      * <strong>Preconditions:</strong><ul>
-     * <li>the distribution must be loaded before invoking this method</li>
-     * </ul>
+     * <li>the distribution must be loaded before invoking this method</li></ul>
      *
      * @return the sample statistics
      * @throws IllegalStateException if the distribution has not been loaded
      */
-    StatisticalSummary getSampleStats() throws IllegalStateException;
+    public StatisticalSummary getSampleStats() {
+        return sampleStats;
+    }
 
     /**
-     * Property indicating whether or not the distribution has been loaded.
-     *
-     * @return true if the distribution has been loaded
-     */
-    boolean isLoaded();
-
-     /**
      * Returns the number of bins.
      *
-     * @return the number of bins
+     * @return the number of bins.
      */
-    int getBinCount();
+    public int getBinCount() {
+        return binCount;
+    }
 
     /**
-     * Returns a list of
-     * {@link org.apache.commons.math.stat.descriptive.SummaryStatistics}
-     * containing statistics describing the values in each of the bins.  The
-     * List is indexed on the bin number.
+     * Returns a List of {@link SummaryStatistics} instances containing
+     * statistics describing the values in each of the bins.  The list is
+     * indexed on the bin number.
      *
-     * @return List of bin statistics
+     * @return List of bin statistics.
      */
-    List<SummaryStatistics> getBinStats();
+    public List<SummaryStatistics> getBinStats() {
+        return binStats;
+    }
 
     /**
-     * Returns the array of upper bounds for the bins.  Bins are: <br/>
+     * <p>Returns a fresh copy of the array of upper bounds for the bins.
+     * Bins are: <br/>
      * [min,upperBounds[0]],(upperBounds[0],upperBounds[1]],...,
-     *  (upperBounds[binCount-2], upperBounds[binCount-1] = max].
+     *  (upperBounds[binCount-2], upperBounds[binCount-1] = max].</p>
+     *
+     * <p>Note: In versions 1.0-2.0 of commons-math, this method
+     * incorrectly returned the array of probability generator upper
+     * bounds now returned by {@link #getGeneratorUpperBounds()}.</p>
      *
      * @return array of bin upper bounds
+     * @since 2.1
      */
-    double[] getUpperBounds();
+    public double[] getUpperBounds() {
+        double[] binUpperBounds = new double[binCount];
+        binUpperBounds[0] = min + delta;
+        for (int i = 1; i < binCount - 1; i++) {
+            binUpperBounds[i] = binUpperBounds[i-1] + delta;
+        }
+        binUpperBounds[binCount - 1] = max;
+        return binUpperBounds;
+    }
 
+    /**
+     * <p>Returns a fresh copy of the array of upper bounds of the subintervals
+     * of [0,1] used in generating data from the empirical distribution.
+     * Subintervals correspond to bins with lengths proportional to bin counts.</p>
+     *
+     * <p>In versions 1.0-2.0 of commons-math, this array was (incorrectly) returned
+     * by {@link #getUpperBounds()}.</p>
+     *
+     * @since 2.1
+     * @return array of upper bounds of subintervals used in data generation
+     */
+    public double[] getGeneratorUpperBounds() {
+        int len = upperBounds.length;
+        double[] out = new double[len];
+        System.arraycopy(upperBounds, 0, out, 0, len);
+        return out;
+    }
+
+    /**
+     * Property indicating whether or not the distribution has been loaded.
+     *
+     * @return true if the distribution has been loaded
+     */
+    public boolean isLoaded() {
+        return loaded;
+    }
+
+    /**
+     * Reseeds the random number generator used by {@link #getNextValue()}.
+     *
+     * @param seed random generator seed
+     * @since 3.0
+     */
+    public void reSeed(long seed) {
+        randomData.reSeed(seed);
+    }
 }

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/ValueServer.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/ValueServer.java?rev=1241567&r1=1241566&r2=1241567&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/ValueServer.java
(original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/ValueServer.java
Tue Feb  7 19:29:32 2012
@@ -170,7 +170,7 @@ public class ValueServer {
      * @throws IOException if an I/O error occurs reading the input file
      */
     public void computeDistribution() throws IOException {
-        computeDistribution(EmpiricalDistributionImpl.DEFAULT_BIN_COUNT);
+        computeDistribution(EmpiricalDistribution.DEFAULT_BIN_COUNT);
     }
 
     /**
@@ -189,7 +189,7 @@ public class ValueServer {
      */
     public void computeDistribution(int binCount)
             throws IOException {
-        empiricalDistribution = new EmpiricalDistributionImpl(binCount, randomData);
+        empiricalDistribution = new EmpiricalDistribution(binCount, randomData);
         empiricalDistribution.load(valuesFileURL);
         mu = empiricalDistribution.getSampleStats().getMean();
         sigma = empiricalDistribution.getSampleStats().getStandardDeviation();

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/EmpiricalDistributionTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/EmpiricalDistributionTest.java?rev=1241567&r1=1241566&r2=1241567&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/EmpiricalDistributionTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/random/EmpiricalDistributionTest.java
Tue Feb  7 19:29:32 2012
@@ -38,18 +38,18 @@ import org.junit.Test;
 
 public final class EmpiricalDistributionTest {
 
-    protected EmpiricalDistributionImpl empiricalDistribution = null;
-    protected EmpiricalDistributionImpl empiricalDistribution2 = null;
+    protected EmpiricalDistribution empiricalDistribution = null;
+    protected EmpiricalDistribution empiricalDistribution2 = null;
     protected File file = null;
     protected URL url = null;
     protected double[] dataArray = null;
 
     @Before
     public void setUp() throws IOException {
-        empiricalDistribution = new EmpiricalDistributionImpl(100);
+        empiricalDistribution = new EmpiricalDistribution(100);
         url = getClass().getResource("testData.txt");
 
-        empiricalDistribution2 = new EmpiricalDistributionImpl(100);
+        empiricalDistribution2 = new EmpiricalDistribution(100);
         BufferedReader in =
                 new BufferedReader(new InputStreamReader(
                         url.openStream()));
@@ -142,9 +142,9 @@ public final class EmpiricalDistribution
      */
     @Test
     public void testGridTooFine() throws Exception {
-        empiricalDistribution = new EmpiricalDistributionImpl(1001);
+        empiricalDistribution = new EmpiricalDistribution(1001);
         tstGen(0.1);
-        empiricalDistribution2 = new EmpiricalDistributionImpl(1001);
+        empiricalDistribution2 = new EmpiricalDistribution(1001);
         tstDoubleGen(0.1);
     }
 
@@ -153,10 +153,10 @@ public final class EmpiricalDistribution
      */
     @Test
     public void testGridTooFat() throws Exception {
-        empiricalDistribution = new EmpiricalDistributionImpl(1);
+        empiricalDistribution = new EmpiricalDistribution(1);
         tstGen(5); // ridiculous tolerance; but ridiculous grid size
                    // really just checking to make sure we do not bomb
-        empiricalDistribution2 = new EmpiricalDistributionImpl(1);
+        empiricalDistribution2 = new EmpiricalDistribution(1);
         tstDoubleGen(5);
     }
 
@@ -166,13 +166,13 @@ public final class EmpiricalDistribution
     @Test
     public void testBinIndexOverflow() throws Exception {
         double[] x = new double[] {9474.94326071674, 2080107.8865462579};
-        new EmpiricalDistributionImpl().load(x);
+        new EmpiricalDistribution().load(x);
     }
 
     @Test
     public void testSerialization() {
         // Empty
-        EmpiricalDistribution dist = new EmpiricalDistributionImpl();
+        EmpiricalDistribution dist = new EmpiricalDistribution();
         EmpiricalDistribution dist2 = (EmpiricalDistribution) TestUtils.serializeAndRecover(dist);
         verifySame(dist, dist2);
 
@@ -184,17 +184,17 @@ public final class EmpiricalDistribution
 
     @Test(expected=NullArgumentException.class)
     public void testLoadNullDoubleArray() {
-       new EmpiricalDistributionImpl().load((double[]) null);
+       new EmpiricalDistribution().load((double[]) null);
     }
 
     @Test(expected=NullArgumentException.class)
     public void testLoadNullURL() throws Exception {
-        new EmpiricalDistributionImpl().load((URL) null);
+        new EmpiricalDistribution().load((URL) null);
     }
 
     @Test(expected=NullArgumentException.class)
     public void testLoadNullFile() throws Exception {
-        new EmpiricalDistributionImpl().load((File) null);
+        new EmpiricalDistribution().load((File) null);
     }
 
     /**
@@ -203,7 +203,7 @@ public final class EmpiricalDistribution
     @Test
     public void testGetBinUpperBounds() {
         double[] testData = {0, 1, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10};
-        EmpiricalDistributionImpl dist = new EmpiricalDistributionImpl(5);
+        EmpiricalDistribution dist = new EmpiricalDistribution(5);
         dist.load(testData);
         double[] expectedBinUpperBounds = {2, 4, 6, 8, 10};
         double[] expectedGeneratorUpperBounds = {4d/13d, 7d/13d, 9d/13d, 11d/13d, 1};
@@ -217,14 +217,14 @@ public final class EmpiricalDistribution
         double[] testData = {0, 1, 2, 3, 4};
         RandomGenerator generator = new RandomAdaptorTest.ConstantGenerator(0.5);
         
-        EmpiricalDistribution dist = new EmpiricalDistributionImpl(5, generator);
+        EmpiricalDistribution dist = new EmpiricalDistribution(5, generator);
         dist.load(testData);
         for (int i = 0; i < 5; i++) {
             Assert.assertEquals(2.0, dist.getNextValue(), 0d);
         }
         
         // Verify no NPE with null generator argument
-        dist = new EmpiricalDistributionImpl(5, (RandomGenerator) null);
+        dist = new EmpiricalDistribution(5, (RandomGenerator) null);
         dist.load(testData);
         dist.getNextValue();
     }



Mime
View raw message