commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pste...@apache.org
Subject cvs commit: jakarta-commons/math/src/java/org/apache/commons/math/random EmpiricalDistribution.java EmpiricalDistributionImpl.java RandomData.java RandomDataImpl.java ValueServer.java package.html
Date Mon, 14 Jun 2004 23:15:15 GMT
psteitz     2004/06/14 16:15:15

  Modified:    math/src/java/org/apache/commons/math/random
                        EmpiricalDistribution.java
                        EmpiricalDistributionImpl.java RandomData.java
                        RandomDataImpl.java ValueServer.java package.html
  Log:
  Formatting only. Removed tabs and trailing spaces.
  
  Revision  Changes    Path
  1.18      +41 -41    jakarta-commons/math/src/java/org/apache/commons/math/random/EmpiricalDistribution.java
  
  Index: EmpiricalDistribution.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/math/src/java/org/apache/commons/math/random/EmpiricalDistribution.java,v
  retrieving revision 1.17
  retrieving revision 1.18
  diff -u -r1.17 -r1.18
  --- EmpiricalDistribution.java	12 Apr 2004 02:27:49 -0000	1.17
  +++ EmpiricalDistribution.java	14 Jun 2004 23:15:14 -0000	1.18
  @@ -1,12 +1,12 @@
   /*
    * Copyright 2003-2004 The Apache Software Foundation.
  - * 
  + *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
  - * 
  + *
    *      http://www.apache.org/licenses/LICENSE-2.0
  - * 
  + *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  @@ -28,8 +28,8 @@
    * 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 
  - * <i>distribution digests</i>, that describe empirical distributions and 
  + * Implementations of this interface maintain 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>
    * <li>saving and re-loading distribution digests to/from "digest files" </li>
  @@ -39,53 +39,53 @@
    *     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 
  + * Applications can use <code>EmpiricalDistribution</code> implementations to
    * build grouped frequnecy 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.
    * @version $Revision$ $Date$
    */
   public interface EmpiricalDistribution {
  - 
  +
       /**
        * Computes the empirical distribution from the provided
        * array of numbers.
        * @param dataArray the data array
        */
  -    void load(double[] dataArray); 
  -        
  +    void load(double[] dataArray);
  +
       /**
        * Computes the empirical distribution from the input file.
        * @param filePath fully qualified name of a file in the local file system
        * @throws IOException if an IO error occurs
        */
  -    void load(String filePath) throws IOException; 
  -    
  +    void load(String filePath) throws IOException;
  +
       /**
        * Computes the empirical distribution from the input file.
        * @param file the input file
        * @throws IOException if an IO error occurs
        */
       void load(File file) throws IOException;
  -    
  +
       /**
        * Computes the empirical distribution using data read from a URL.
        * @param url url of the input file
        * @throws IOException if an IO error occurs
        */
       void load(URL url) throws IOException;
  -    
  -    /** 
  +
  +    /**
        * 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
        */
  -    double getNextValue() throws IllegalStateException;  
  -    
  -     
  -    /** 
  +    double getNextValue() throws IllegalStateException;
  +
  +
  +    /**
        * Returns a DescriptiveStatistics describing this distribution.
        * <strong>Preconditions:</strong><ul>
        * <li>the distribution must be loaded before invoking this method</li></ul>
  @@ -93,23 +93,23 @@
        * @throws IllegalStateException if the distribution has not been loaded
        */
       SummaryStatistics getSampleStats() throws IllegalStateException;
  -    
  -    /** 
  +
  +    /**
        * Loads a saved distribution from a file.
        * @param file File reference for a file containing a digested distribution
        * @throws IOException if an error occurs reading the file
        */
  -    void loadDistribution(File file) throws IOException;  
  -    
  -    /** 
  +    void loadDistribution(File file) throws IOException;
  +
  +    /**
        * Loads a saved distribution from a file.
  -     * @param filePath fully qualified file path for a file 
  -     * containing a digested distribution 
  +     * @param filePath fully qualified file path for a file
  +     * containing a digested distribution
        * @throws IOException if an error occurs reading the file
        */
  -    void loadDistribution(String filePath) throws IOException; 
  -    
  -    /** 
  +    void loadDistribution(String filePath) throws IOException;
  +
  +    /**
        * Saves distribution to a file. Overwrites the file if it exists.
        * <strong>Preconditions:</strong><ul>
        * <li>the distribution must be loaded before invoking this method</li></ul>
  @@ -117,10 +117,10 @@
        * @throws IOException if an error occurs reading the file
        * @throws IllegalStateException if the distribution has not been loaded
        */
  -    void saveDistribution(String filePath) throws 
  +    void saveDistribution(String filePath) throws
           IOException,IllegalStateException;
  -    
  -    /** 
  +
  +    /**
        * Saves distribution to a file. Overwrites the file if it exists.
        * <strong>Preconditions:</strong><ul>
        * <li>the distribution must be loaded before invoking this method</li></ul>
  @@ -129,32 +129,32 @@
        * @throws IllegalStateException if the distribution has not been loaded
        */
       void saveDistribution(File file) throws IOException,IllegalStateException;
  -    
  +
       /**
        * property indicating whether or not the distribution has been loaded
        * @return true if the distribution has been loaded
        */
  -    boolean isLoaded();  
  -    
  -     /** 
  +    boolean isLoaded();
  +
  +     /**
        * Returns the number of bins
        * @return the number of bins.
        */
       int getBinCount();
  -    
  -    /** 
  +
  +    /**
        * Returns a list of Univariates containing statistics describing the
        * values in each of the bins.  The ArrayList is indexed on the bin number.
        * @return ArrayList of bin statistics.
        */
       ArrayList getBinStats();
  -    
  -    /** 
  +
  +    /**
        * Returns the array of upper bounds for the bins.  Bins are: <br/>
        * [min,upperBounds[0]],(upperBounds[0],upperBounds[1]],...,
        *  (upperBounds[binCount-1],max]
        * @return array of bin upper bounds
        */
       double[] getUpperBounds();
  -    
  +
   }
  
  
  
  1.21      +54 -54    jakarta-commons/math/src/java/org/apache/commons/math/random/EmpiricalDistributionImpl.java
  
  Index: EmpiricalDistributionImpl.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/math/src/java/org/apache/commons/math/random/EmpiricalDistributionImpl.java,v
  retrieving revision 1.20
  retrieving revision 1.21
  diff -u -r1.20 -r1.21
  --- EmpiricalDistributionImpl.java	2 Jun 2004 00:20:21 -0000	1.20
  +++ EmpiricalDistributionImpl.java	14 Jun 2004 23:15:14 -0000	1.21
  @@ -1,12 +1,12 @@
   /*
    * Copyright 2003-2004 The Apache Software Foundation.
  - * 
  + *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
  - * 
  + *
    *      http://www.apache.org/licenses/LICENSE-2.0
  - * 
  + *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  @@ -30,11 +30,11 @@
   
   /**
    * Implements <code>EmpiricalDistribution</code> interface.  This implementation
  - * uses what amounts to the 
  + * 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>  
  + * <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>
  @@ -59,33 +59,33 @@
   
       /** Serializable version identifier */
       static final long serialVersionUID = -6773236347582113490L;
  -    
  +
       /** List of DescriptiveStatistics objects characterizing the bins */
       private ArrayList binStats = null;
  -    
  +
       /** Sample statistics */
       SummaryStatistics sampleStats = null;
  -    
  +
       /** number of bins */
       private int binCount = 1000;
  -    
  +
       /** is the distribution loaded? */
       private boolean loaded = false;
  -    
  +
       /** upper bounds of subintervals in (0,1) "belonging" to the bins */
       private double[] upperBounds = null;
  -    
  +
       /** RandomData instance to use in repeated calls to getNext() */
       private RandomData randomData = new RandomDataImpl();
  -    
  -    /** 
  +
  +    /**
        * Creates a new EmpiricalDistribution  with the default bin count
        */
       public EmpiricalDistributionImpl() {
           binStats = new ArrayList();
       }
  -    
  -    /** 
  +
  +    /**
        * Creates a new EmpiricalDistribution  with the specified bin count
        * @param binCount number of bins
        */
  @@ -106,12 +106,12 @@
               throw new RuntimeException(e.getMessage());
           }
           loaded = true;
  -        
  +
       }
  -    
  +
       public void load(String filePath) throws IOException {
  -        BufferedReader in = 
  -            new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));  
  +        BufferedReader in =
  +            new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
           try {
               DataAdapter da = new StreamDataAdapter(in);
               try {
  @@ -119,16 +119,16 @@
               } catch (Exception e) {
                   throw new IOException(e.getMessage());
               }
  -            in = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));  
  +            in = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
               fillBinStats(in);
               loaded = true;
           } finally {
              if (in != null) try {in.close();} catch (Exception ex) {};
           }
       }
  -    
  +
       public void load(URL url) throws IOException {
  -        BufferedReader in = 
  +        BufferedReader in =
               new BufferedReader(new InputStreamReader(url.openStream()));
           try {
               DataAdapter da = new StreamDataAdapter(in);
  @@ -144,7 +144,7 @@
              if (in != null) try {in.close();} catch (Exception ex) {};
           }
       }
  -     
  +
       public void load(File file) throws IOException {
           BufferedReader in = new BufferedReader(new FileReader(file));
           try {
  @@ -165,20 +165,20 @@
                   };
           }
       }
  -    
  +
       /**
  -     * Provides methods for computing <code>sampleStats</code> and 
  -     * <code>beanStats</code> abstracting the source of data. 
  +     * Provides methods for computing <code>sampleStats</code> and
  +     * <code>beanStats</code> abstracting the source of data.
        */
       private abstract class DataAdapter{
  -        public abstract void computeBinStats(double min, double delta) 
  +        public abstract void computeBinStats(double min, double delta)
                   throws Exception;
           public abstract void computeStats() throws Exception;
       }
       /**
        * 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. 
  +     * is returned.
        */
       private class DataAdapterFactory{
           public DataAdapter getAdapter(Object in) {
  @@ -206,7 +206,7 @@
           /**
            * Computes binStats
            */
  -        public void computeBinStats(double min, double delta) 
  +        public void computeBinStats(double min, double delta)
                   throws IOException {
               String str = null;
               double val = 0.0d;
  @@ -263,17 +263,17 @@
               for (int i = 0; i < inputArray.length; i++) {
                   SummaryStatistics stats =
                       (SummaryStatistics) binStats.get(
  -                        Math.max((int) Math.ceil((inputArray[i] - min) / delta) 
  +                        Math.max((int) Math.ceil((inputArray[i] - min) / delta)
                               - 1, 0));
                   stats.addValue(inputArray[i]);
               }
  -        }    
  +        }
       }
   
       /**
        * Fills binStats array (second pass through data file).
        */
  -    private void fillBinStats(Object in) throws IOException {    
  +    private void fillBinStats(Object in) throws IOException {
           // Load array of bin upper bounds -- evenly spaced from min - max
           double min = sampleStats.getMin();
           double max = sampleStats.getMax();
  @@ -284,7 +284,7 @@
               binUpperBounds[i] = binUpperBounds[i-1] + delta;
           }
           binUpperBounds[binCount -1] = max;
  -        
  +
           // Initialize binStats ArrayList
           if (!binStats.isEmpty()) {
               binStats.clear();
  @@ -293,7 +293,7 @@
               SummaryStatistics stats = SummaryStatistics.newInstance();
               binStats.add(i,stats);
           }
  -        
  +
           // Filling data in binStats Array
           DataAdapterFactory aFactory = new DataAdapterFactory();
           DataAdapter da = aFactory.getAdapter(in);
  @@ -306,7 +306,7 @@
                   throw new IOException(e.getMessage());
               }
           }
  -        
  +
           // Assign upperBounds based on bin counts
           upperBounds = new double[binCount];
           upperBounds[0] =
  @@ -319,27 +319,27 @@
           }
           upperBounds[binCount-1] = 1.0d;
       }
  -    
  +
       /**
        * Generates a random value from this distribution
        * @return the random value.
        * @throws IllegalStateException if the distribution has not been loaded
        */
  -    public double getNextValue() throws IllegalStateException {    
  -        
  +    public double getNextValue() throws IllegalStateException {
  +
           if (!loaded) {
               throw new IllegalStateException("distribution not loaded");
           }
  -        
  +
           // Start with a uniformly distributed random number in (0,1)
           double x = Math.random();
  -       
  +
           // 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 = (SummaryStatistics)binStats.get(i);
  -               if (stats.getN() > 0) { 
  -                   if (stats.getStandardDeviation() > 0) {  // more than one obs 
  +               if (stats.getN() > 0) {
  +                   if (stats.getStandardDeviation() > 0) {  // more than one obs
                           return randomData.nextGaussian
                               (stats.getMean(),stats.getStandardDeviation());
                      } else {
  @@ -350,41 +350,41 @@
           }
           throw new RuntimeException("No bin selected");
       }
  -       
  +
       public void loadDistribution(String filePath) throws IOException {
           throw new UnsupportedOperationException("Not Implemented yet :-(");
       }
  -    
  +
       public void loadDistribution(File file) throws IOException {
           throw new UnsupportedOperationException("Not Implemented yet :-(");
       }
  -       
  -    public void saveDistribution(String filePath) throws 
  +
  +    public void saveDistribution(String filePath) throws
           IOException,IllegalStateException {
          throw new UnsupportedOperationException("Not Implemented yet :-(");
       }
  -    
  -    public void saveDistribution(File file) throws 
  +
  +    public void saveDistribution(File file) throws
           IOException,IllegalStateException {
          throw new UnsupportedOperationException("Not Implemented yet :-(");
       }
  -        
  +
       public SummaryStatistics getSampleStats() {
           return sampleStats;
       }
  -    
  +
       public int getBinCount() {
           return binCount;
       }
  -      
  +
       public ArrayList getBinStats() {
           return binStats;
       }
  -       
  +
       public double[] getUpperBounds() {
           return upperBounds;
       }
  -    
  +
       public boolean isLoaded() {
           return loaded;
       }
  
  
  
  1.10      +70 -70    jakarta-commons/math/src/java/org/apache/commons/math/random/RandomData.java
  
  Index: RandomData.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/math/src/java/org/apache/commons/math/random/RandomData.java,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- RandomData.java	11 Apr 2004 19:00:45 -0000	1.9
  +++ RandomData.java	14 Jun 2004 23:15:15 -0000	1.10
  @@ -1,12 +1,12 @@
   /*
    * Copyright 2003-2004 The Apache Software Foundation.
  - * 
  + *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
  - * 
  + *
    *      http://www.apache.org/licenses/LICENSE-2.0
  - * 
  + *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  @@ -21,56 +21,56 @@
    * Random data generation utilities
    * @version $Revision$ $Date$
    */
  -public interface RandomData {      
  +public interface RandomData {
       /**
        * Generates a random string of hex characters of length
        * <code>len</code>.
        * <p>
  -     * The generated string will be random, but not cryptographically 
  -     * secure. To generate cryptographically secure strings, use 
  +     * The generated string will be random, but not cryptographically
  +     * secure. To generate cryptographically secure strings, use
        * <code>nextSecureHexString</code>
        * <p>
        * <strong>Preconditions</strong>:<ul>
  -     * <li><code>len > 0</code> (otherwise an IllegalArgumentException 
  +     * <li><code>len > 0</code> (otherwise an IllegalArgumentException
        *     is thrown.)</li>
        * </ul>
  -     * 
  +     *
        * @param len the length of the string to be generated
  -     * @return random string of hex characters of length <code>len</code>  
  +     * @return random string of hex characters of length <code>len</code>
        */
  -    String nextHexString(int len);  
  -    
  +    String nextHexString(int len);
  +
       /**
  -     * Generates a uniformly distributed random integer between 
  +     * Generates a uniformly distributed random integer between
        * <code>lower</code> and <code>upper</code> (endpoints included).
        * <p>
        * The generated integer will be random, but not cryptographically secure.
  -     * To generate cryptographically secure integer sequences, use 
  +     * To generate cryptographically secure integer sequences, use
        * <code>nextSecureInt</code>.
        * <p>
        * <strong>Preconditions</strong>:<ul>
  -     * <li><code>lower < upper</code> (otherwise an IllegalArgumentException 
  +     * <li><code>lower < upper</code> (otherwise an IllegalArgumentException
        *     is thrown.)</li>
        * </ul>
        *
        * @param lower lower bound for generated integer
        * @param upper upper bound for generated integer
  -     * @return a random integer greater than or equal to <code>lower</code> 
  +     * @return a random integer greater than or equal to <code>lower</code>
        * and less than or equal to <code>upper</code>.
        */
  -    int nextInt(int lower, int upper);  
  -    
  +    int nextInt(int lower, int upper);
  +
       /**
        * Generates a uniformly distributed random long integer between
        * <code>lower</code> and <code>upper</code> (endpoints included).
        * <p>
  -     * The generated long integer values will be random, but not 
  +     * The generated long integer values will be random, but not
        * cryptographically secure.
  -     * To generate cryptographically secure sequences of longs, use 
  +     * To generate cryptographically secure sequences of longs, use
        * <code>nextSecureLong</code>
        * <p>
        * <strong>Preconditions</strong>:<ul>
  -     * <li><code>lower < upper</code> (otherwise an IllegalArgumentException 
  +     * <li><code>lower < upper</code> (otherwise an IllegalArgumentException
        *     is thrown.)</li>
        * </ul>
        *
  @@ -79,39 +79,39 @@
        * @return a random integer greater than or equal to <code>lower</code>
        * and less than or equal to <code>upper</code>.
        */
  -    long nextLong(long lower, long upper);  
  -    
  +    long nextLong(long lower, long upper);
  +
       /**
  -     * Generates a random string of hex characters from a secure random 
  +     * Generates a random string of hex characters from a secure random
        * sequence.
        * <p>
  -     * If cryptographic security is not required, 
  +     * If cryptographic security is not required,
        * use <code>nextHexString()</code>.
        * <p>
        * <strong>Preconditions</strong>:<ul>
  -     * <li><code>len > 0</code> (otherwise an IllegalArgumentException 
  +     * <li><code>len > 0</code> (otherwise an IllegalArgumentException
        *     is thrown.)</li>
        * </ul>
        * @param len length of return string
        * @return the random hex string
        */
  -    String nextSecureHexString(int len);  
  -    
  +    String nextSecureHexString(int len);
  +
       /**
  -     * Generates a uniformly distributed random integer between 
  -     * <code>lower</code> and <code>upper</code> (endpoints included) 
  +     * Generates a uniformly distributed random integer between
  +     * <code>lower</code> and <code>upper</code> (endpoints included)
        * from a secure random sequence.
        * <p>
  -     * Sequences of integers generated using this method will be 
  -     * cryptographically secure. If cryptographic security is not required, 
  -     * <code>nextInt</code> should be used instead of this method. 
  +     * Sequences of integers generated using this method will be
  +     * cryptographically secure. If cryptographic security is not required,
  +     * <code>nextInt</code> should be used instead of this method.
        * <p>
        * <strong>Definition</strong>:
        * <a href="http://en.wikipedia.org/wiki/Cryptographically_secure_pseudo-random_number_generator">
        * Secure Random Sequence</a>
        * <p>
        * <strong>Preconditions</strong>:<ul>
  -     * <li><code>lower < upper</code> (otherwise an IllegalArgumentException 
  +     * <li><code>lower < upper</code> (otherwise an IllegalArgumentException
        *     is thrown.)</li>
        * </ul>
        *
  @@ -120,12 +120,12 @@
        * @return a random integer greater than or equal to <code>lower</code>
        * and less than or equal to <code>upper</code>.
        */
  -    int nextSecureInt(int lower, int upper);  
  -    
  +    int nextSecureInt(int lower, int upper);
  +
       /**
        * Generates a random long integer between <code>lower</code>
        * and <code>upper</code> (endpoints included).<p>
  -     * Sequences of long values generated using this method will be 
  +     * Sequences of long values generated using this method will be
        * cryptographically secure. If cryptographic security is not required,
        * <code>nextLong</code> should be used instead of this method.
        * <p>
  @@ -134,7 +134,7 @@
        * Secure Random Sequence</a>
        * <p>
        * <strong>Preconditions</strong>:<ul>
  -     * <li><code>lower < upper</code> (otherwise an IllegalArgumentException 
  +     * <li><code>lower < upper</code> (otherwise an IllegalArgumentException
        *     is thrown.)</li>
        * </ul>
        *
  @@ -143,36 +143,36 @@
        * @return a long integer greater than or equal to <code>lower</code>
        * and less than or equal to <code>upper</code>.
        */
  -    long nextSecureLong(long lower, long upper);  
  -    
  -    /** 
  -     * Generates a random value from the Poisson distribution with 
  +    long nextSecureLong(long lower, long upper);
  +
  +    /**
  +     * Generates a random value from the Poisson distribution with
        * the given mean.
        * <p>
  -     * <strong>Definition</strong>: 
  +     * <strong>Definition</strong>:
        * <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda366j.htm">
        * Poisson Distribution</a>
        * <p>
        * <strong>Preconditions</strong>: <ul>
  -     * <li>The specified mean <i>must</i> be positive (otherwise an 
  +     * <li>The specified mean <i>must</i> be positive (otherwise an
        *     IllegalArgumentException is thrown.)</li>
        * </ul>
        * @param mean Mean of the distribution
        * @return poisson deviate with the specified mean
        */
  -    long nextPoisson(double mean);  
  -    
  -    /** 
  +    long nextPoisson(double mean);
  +
  +    /**
        * Generates a random value from the
        * Normal (or Gaussian) distribution with the given mean
        * and standard deviation.
        * <p>
  -     * <strong>Definition</strong>: 
  +     * <strong>Definition</strong>:
        * <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda3661.htm">
        * Normal Distribution</a>
        * <p>
        * <strong>Preconditions</strong>: <ul>
  -     * <li><code>sigma > 0</code> (otherwise an IllegalArgumentException 
  +     * <li><code>sigma > 0</code> (otherwise an IllegalArgumentException
        *     is thrown.)</li>
        * </ul>
        * @param mu Mean of the distribution
  @@ -180,38 +180,38 @@
        * @return random value from Gaussian distribution with mean = mu,
        * standard deviation = sigma
        */
  -    double nextGaussian(double mu, double sigma);  
  -    
  +    double nextGaussian(double mu, double sigma);
  +
       /**
        * Generates a random value from the exponential distribution
        * with expected value = <code>mean</code>.
        * <p>
  -     * <strong>Definition</strong>: 
  +     * <strong>Definition</strong>:
        * <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda3667.htm">
        * Exponential Distribution</a>
        * <p>
        * <strong>Preconditions</strong>: <ul>
  -     * <li><code>mu >= 0</code> (otherwise an IllegalArgumentException 
  +     * <li><code>mu >= 0</code> (otherwise an IllegalArgumentException
        *     is thrown.)</li>
        * </ul>
        * @param mean Mean of the distribution
        * @return random value from exponential distribution
        */
  -    double nextExponential(double mean);   
  -    
  +    double nextExponential(double mean);
  +
       /**
        * Generates a uniformly distributed random value from the open interval
        * (<code>lower</code>,<code>upper</code>) (i.e., endpoints excluded).
        * <p>
  -     * <strong>Definition</strong>: 
  +     * <strong>Definition</strong>:
        * <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda3662.htm">
  -     * Uniform Distribution</a> <code>lower</code> and 
  -     * <code>upper - lower</code> are the 
  +     * Uniform Distribution</a> <code>lower</code> and
  +     * <code>upper - lower</code> are the
        * <a href = "http://www.itl.nist.gov/div898/handbook/eda/section3/eda364.htm">
        * location and scale parameters</a>, respectively.
        * <p>
        * <strong>Preconditions</strong>:<ul>
  -     * <li><code>lower < upper</code> (otherwise an IllegalArgumentException 
  +     * <li><code>lower < upper</code> (otherwise an IllegalArgumentException
        *     is thrown.)</li>
        * </ul>
        *
  @@ -221,14 +221,14 @@
        * and upper (exclusive)
        */
       double nextUniform(double lower, double upper);
  -    
  +
       /**
        * Generates an integer array of length <code>k</code> whose entries
        * are selected randomly, without repetition, from the integers <code>
  -     * 0 through n-1</code> (inclusive). 
  +     * 0 through n-1</code> (inclusive).
        * <p>
        * Generated arrays represent permutations
  -     * of <code>n</code> taken <code>k</code> at a time. 
  +     * of <code>n</code> taken <code>k</code> at a time.
        * <p>
        * <strong>Preconditions:</strong><ul>
        * <li> <code>k <= n</code></li>
  @@ -236,35 +236,35 @@
        * </ul>
        * If the preconditions are not met, an IllegalArgumentException is
        * thrown.
  -     * 
  +     *
        * @param n domain of the permutation
        * @param k size of the permutation
  -     * @return random k-permutation of n 
  +     * @return random k-permutation of n
        */
       int[] nextPermutation(int n, int k);
  -    
  +
       /**
        * Returns an array of <code>k</code> objects selected randomly
  -     * from the Collection <code>c</code>. 
  +     * from the Collection <code>c</code>.
        * <p>
        * Sampling from <code>c</code>
        * is without replacement; but if <code>c</code> contains identical
        * objects, the sample may include repeats.  If all elements of <code>
  -     * c</code> are distinct, the resulting object array represents a 
  +     * c</code> are distinct, the resulting object array represents a
        * <a href="http://rkb.home.cern.ch/rkb/AN16pp/node250.html#SECTION0002500000000000000000">
        * Simple Random Sample</a> of size
        * <code>k</code> from the elements of <code>c</code>.
  -     * <p>   
  +     * <p>
        * <strong>Preconditions:</strong><ul>
        * <li> k must be less than or equal to the size of c </li>
        * <li> c must not be empty </li>
        * </ul>
        * If the preconditions are not met, an IllegalArgumentException is
        * thrown.
  -     * 
  +     *
        * @param c collection to be sampled
        * @param k size of the sample
  -     * @return random sample of k elements from c 
  +     * @return random sample of k elements from c
        */
       Object[] nextSample(Collection c, int k);
   }
  
  
  
  1.15      +107 -107  jakarta-commons/math/src/java/org/apache/commons/math/random/RandomDataImpl.java
  
  Index: RandomDataImpl.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/math/src/java/org/apache/commons/math/random/RandomDataImpl.java,v
  retrieving revision 1.14
  retrieving revision 1.15
  diff -u -r1.14 -r1.15
  --- RandomDataImpl.java	2 Jun 2004 00:20:21 -0000	1.14
  +++ RandomDataImpl.java	14 Jun 2004 23:15:15 -0000	1.15
  @@ -1,12 +1,12 @@
   /*
    * Copyright 2003-2004 The Apache Software Foundation.
  - * 
  + *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
  - * 
  + *
    *      http://www.apache.org/licenses/LICENSE-2.0
  - * 
  + *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  @@ -25,22 +25,22 @@
   import java.util.Collection;
   
   /**
  - * Implements the <code>RandomData</code> interface using 
  - * <code>java.util.Random</code> and 
  - * <code>java.util.Random.SecureRandom</code> instances to generate data. 
  + * Implements the <code>RandomData</code> interface using
  + * <code>java.util.Random</code> and
  + * <code>java.util.Random.SecureRandom</code> instances to generate data.
    * <p>
  - * Supports reseeding the underlying 
  + * Supports reseeding the underlying
    * <a href="http://en.wikipedia.org/wiki/Pseudorandom_number_generator">
    * PRNG</a>. The <code>SecurityProvider</code> and <code>Algorithm</code>
    * used by the <code>SecureRandom</code> instance can also be reset.
    * <p>
  - * For details on the PRNGs, see the JDK documentation for 
  - * <code>java.util.Random</code> and 
  + * For details on the PRNGs, see the JDK documentation for
  + * <code>java.util.Random</code> and
    * <code>java.util.Random.SecureRandom</code>
    * <p>
    * <strong>Usage Notes</strong>: <ul>
    * <li>
  - * Instance variables are used to maintain <code>Random</code> and 
  + * Instance variables are used to maintain <code>Random</code> and
    * <code>SecureRandom</code> instances used in data generation. Therefore,
    * to generate a random sequence of values or strings, you should use just
    * <strong>one</strong> <code>RandomDataImpl</code> instance repeatedly.</li>
  @@ -55,38 +55,38 @@
    * the appropriate generator.  If you do not explicitly seed the generator, it
    * is by default seeded with the current time in milliseconds</li>
    * <li>
  - * The <code>reSeed</code> and <code>reSeedSecure</code> methods delegate 
  - * to the corresponding methods on the underlying <code>Random</code> and 
  - * <code>SecureRandom</code> instances.  Therefore, the contracts of these 
  - * methods are as defined in the JDK documentation.  In particular, 
  - * <code>reSeed(long)</code> fully resets the initial state of the non-secure 
  - * random number generator (so that reseeding with a specific value always 
  + * The <code>reSeed</code> and <code>reSeedSecure</code> methods delegate
  + * to the corresponding methods on the underlying <code>Random</code> and
  + * <code>SecureRandom</code> instances.  Therefore, the contracts of these
  + * methods are as defined in the JDK documentation.  In particular,
  + * <code>reSeed(long)</code> fully resets the initial state of the non-secure
  + * random number generator (so that reseeding with a specific value always
    * results in the same subsequent random sequence); whereas reSeedSecure(long)
  - * does <strong>not</strong> reinitialize the secure random number generator 
  - * (so secure sequences started with calls to reseedSecure(long) won't be 
  + * does <strong>not</strong> reinitialize the secure random number generator
  + * (so secure sequences started with calls to reseedSecure(long) won't be
    * identical).</li></ul>
  - * 
  + *
    * @version $Revision$ $Date$
    */
   public class RandomDataImpl implements RandomData, Serializable {
  -    
  +
       /** Serializable version identifier */
       static final long serialVersionUID = -626730818244969716L;
   
       /** underlying random number generator */
       private Random rand = null;
  -    
  +
       /** underlying secure random number generator */
       private SecureRandom secRand = null;
  -    
  +
       /**
        * Construct a RandomDataImpl.
        */
       public RandomDataImpl() {
       }
  -          
  +
       /**
  -     * <strong>Algorithm Description:</strong> hex strings are generated 
  +     * <strong>Algorithm Description:</strong> hex strings are generated
        * using a 2-step process. <ol>
        * <li>
        * len/2+1 binary bytes are generated using the underlying Random</li>
  @@ -99,28 +99,28 @@
           if (len <= 0) {
               throw new IllegalArgumentException("length must be positive");
           }
  -            
  +
           //Get a random number generator
           Random ran = getRan();
  -        
  +
           //Initialize output buffer
           StringBuffer outBuffer = new StringBuffer();
  -            
  +
           //Get int(len/2)+1 random bytes
           byte[] randomBytes = new byte[(len / 2) + 1];
           ran.nextBytes(randomBytes);
  - 
  +
           //Convert each byte to 2 hex digits
           for (int i = 0; i < randomBytes.length; i++) {
               Integer c = new Integer(randomBytes[i]);
  -                
  +
               /* Add 128 to byte value to make interval 0-255 before
                * doing hex conversion.
                * This guarantees <= 2 hex digits from toHexString()
                * toHexString would otherwise add 2^32 to negative arguments.
                */
                String hex = Integer.toHexString(c.intValue() + 128);
  -                
  +
                // Make sure we add 2 hex digits for each byte
                if (hex.length() == 1)  {
                    hex = "0" + hex;
  @@ -136,7 +136,7 @@
        * @param lower the lower bound.
        * @param upper the upper bound.
        * @return the random integer.
  -     */       
  +     */
       public int nextInt(int lower, int upper) {
           if (lower >= upper) {
               throw new IllegalArgumentException
  @@ -145,14 +145,14 @@
           Random rand = getRan();
           return lower + (int) (rand.nextDouble() * (upper - lower + 1));
       }
  -    
  +
       /**
        * Generate a random long value uniformly distributed between
        * <code>lower</code> and <code>upper</code>, inclusive.
        * @param lower the lower bound.
        * @param upper the upper bound.
        * @return the random integer.
  -     */       
  +     */
       public long nextLong(long lower, long upper) {
           if (lower >= upper) {
               throw new IllegalArgumentException
  @@ -161,19 +161,19 @@
           Random rand = getRan();
           return lower + (long) (rand.nextDouble() * (upper - lower + 1));
       }
  -    
  +
        /**
  -     * <strong>Algorithm Description:</strong> hex strings are generated in 
  +     * <strong>Algorithm Description:</strong> hex strings are generated in
        * 40-byte segments using a 3-step process. <ol>
        * <li>
  -     * 20 random bytes are generated using the underlying 
  +     * 20 random bytes are generated using the underlying
        * <code>SecureRandom</code>.</li>
        * <li>
        * SHA-1 hash is applied to yield a 20-byte binary digest.</li>
        * <li>
        * Each byte of the binary digest is converted to 2 hex digits</li></ol>
        * <p>
  -     * TODO: find external reference or provide justification for the claim 
  +     * TODO: find external reference or provide justification for the claim
        * that this yields a cryptographically secure sequence of hex strings.
        * @param len the desired string length.
        * @return the random string.
  @@ -182,7 +182,7 @@
           if (len <= 0) {
               throw new IllegalArgumentException("length must be positive");
           }
  -       
  +
          // Get SecureRandom and setup Digest provider
          SecureRandom secRan = getSecRan();
          MessageDigest alg = null;
  @@ -191,31 +191,31 @@
          } catch (NoSuchAlgorithmException ex) {
              return null; // gulp FIXME? -- this *should* never fail.
          }
  -       alg.reset(); 
  -       
  +       alg.reset();
  +
          //Compute number of iterations required (40 bytes each)
          int numIter = (len / 40) + 1;
  -       
  +
          StringBuffer outBuffer = new StringBuffer();
          for (int iter = 1; iter < numIter + 1; iter++) {
               byte[] randomBytes = new byte[40];
               secRan.nextBytes(randomBytes);
               alg.update(randomBytes);
  -    
  +
               //Compute hash -- will create 20-byte binary hash
               byte hash[] = alg.digest();
  -            
  +
               //Loop over the hash, converting each byte to 2 hex digits
               for (int i = 0; i < hash.length; i++) {
                   Integer c = new Integer(hash[i]);
  -        
  +
                   /* Add 128 to byte value to make interval 0-255
                    * This guarantees <= 2 hex digits from toHexString()
  -                 * toHexString would otherwise add 2^32 to negative 
  +                 * toHexString would otherwise add 2^32 to negative
                    * arguments
                    */
                   String hex = Integer.toHexString(c.intValue() + 128);
  -                    
  +
                  //Keep strings uniform length -- guarantees 40 bytes
                   if (hex.length() == 1) {
                       hex = "0" + hex;
  @@ -225,7 +225,7 @@
           }
           return outBuffer.toString().substring(0, len);
       }
  -     
  +
       /**
        * Generate a random int value uniformly distributed between
        * <code>lower</code> and <code>upper</code>, inclusive.  This algorithm
  @@ -233,7 +233,7 @@
        * @param lower the lower bound.
        * @param upper the upper bound.
        * @return the random integer.
  -     */       
  +     */
       public int nextSecureInt(int lower, int upper) {
             if (lower >= upper) {
                 throw new IllegalArgumentException
  @@ -242,7 +242,7 @@
             SecureRandom sec = getSecRan();
             return lower + (int) (sec.nextDouble() * (upper - lower + 1));
       }
  -     
  +
       /**
        * Generate a random long value uniformly distributed between
        * <code>lower</code> and <code>upper</code>, inclusive.  This algorithm
  @@ -250,7 +250,7 @@
        * @param lower the lower bound.
        * @param upper the upper bound.
        * @return the random integer.
  -     */       
  +     */
       public long nextSecureLong(long lower, long upper) {
           if (lower >= upper) {
               throw new IllegalArgumentException
  @@ -259,16 +259,16 @@
           SecureRandom sec = getSecRan();
           return lower + (long) (sec.nextDouble() * (upper - lower + 1));
       }
  -    
  -    /** 
  +
  +    /**
        * Generates a random long value from the Poisson distribution with the given mean.
        * <p>
        * <strong>Algorithm Description</strong>:
  -     * Uses simulation of a Poisson process using Uniform deviates, as 
  -     * described 
  +     * Uses simulation of a Poisson process using Uniform deviates, as
  +     * described
        * <a href ="http://dmawww.epfl.ch/benarous/Pmmi/interactive/rng7.htm">
        * here.</a>
  -     * <p>  
  +     * <p>
        * The Poisson process (and hence value returned) is bounded by 1000 * mean.
        * @param mean mean of the Poisson distribution.
        * @return the random Poisson value.
  @@ -282,7 +282,7 @@
           double r = 1.0d;
           double rnd = 1.0d;
           Random rand = getRan();
  -        while (n < 1000 * mean) {     
  +        while (n < 1000 * mean) {
               rnd = rand.nextDouble();
               r = r * rnd;
               if (r >= p) {
  @@ -293,9 +293,9 @@
           }
           return n;
       }
  -    
  +
       /**
  -     * Generate a random value from a Normal distribution.  This algorithm 
  +     * Generate a random value from a Normal distribution.  This algorithm
        * generates random values for the general Normal distribution with the
        * given mean, <code>mu</code> and the given standard deviation,
        * <code>sigma</code>.
  @@ -310,10 +310,10 @@
           Random rand = getRan();
           return sigma * rand.nextGaussian() + mu;
       }
  -    
  +
       /**
  -     * <strong>Algorithm Description</strong>:  Uses the 
  -     * <a href="http://www.jesus.ox.ac.uk/~clifford/a5/chap1/node5.html"> 
  +     * <strong>Algorithm Description</strong>:  Uses the
  +     * <a href="http://www.jesus.ox.ac.uk/~clifford/a5/chap1/node5.html">
        * Inversion Method</a> to generate exponential from uniform deviates.
        * @param mean the mean of the distribution.
        * @return the random Exponential value.
  @@ -330,12 +330,12 @@
           }
           return -mean * Math.log(unif);
       }
  -    
  +
       /**
  -     * <strong>Algorithm Description</strong>: scales the output of 
  +     * <strong>Algorithm Description</strong>: scales the output of
        * Random.nextDouble(), but rejects 0 values (i.e., will generate another
  -     * random double if Random.nextDouble() returns 0). 
  -     * This is necessary to provide a symmetric output interval 
  +     * random double if Random.nextDouble() returns 0).
  +     * This is necessary to provide a symmetric output interval
        * (both endpoints excluded).
        * @param lower the lower bound.
        * @param upper the upper bound.
  @@ -347,21 +347,21 @@
               ("lower bound must be <= upper bound");
           }
           Random rand = getRan();
  -        
  +
           // insure nextDouble() isn't 0.0
           double u = rand.nextDouble();
           while(u <= 0.0){
               u = rand.nextDouble();
           }
  -        
  +
           return lower + u * (upper - lower);
       }
  -    
  -    /** 
  +
  +    /**
        * Returns the static Random used to generate random data.
        * <p>
        * Creates and initializes if null.
  -     * 
  +     *
        * @return the static Random used to generate random data
        */
       private Random getRan() {
  @@ -371,8 +371,8 @@
           }
           return rand;
       }
  -    
  -    /** 
  +
  +    /**
        * Returns the static SecureRandom used to generate secure random data.
        * <p>
        * Creates and initializes if null.
  @@ -386,7 +386,7 @@
           }
           return secRand;
       }
  -    
  +
       /**
        * Reseeds the random number generator with the supplied seed.
        * <p>
  @@ -400,11 +400,11 @@
           }
           rand.setSeed(seed);
       }
  -    
  +
       /**
        * Reseeds the secure random number generator with the current time
  -     * in milliseconds. 
  -     * <p> 
  +     * in milliseconds.
  +     * <p>
        * Will create and initialize if null.
        */
       public void reSeedSecure() {
  @@ -413,7 +413,7 @@
           }
           secRand.setSeed(System.currentTimeMillis());
       }
  -    
  +
       /**
        * Reseeds the secure random number generator with the supplied seed.
        * <p>
  @@ -427,7 +427,7 @@
           }
           secRand.setSeed(seed);
       }
  -    
  +
       /**
        * Reseeds the random number generator with the current time
        * in milliseconds.
  @@ -438,29 +438,29 @@
           }
           rand.setSeed(System.currentTimeMillis());
       }
  -    
  +
       /**
        * Sets the PRNG algorithm for the underlying SecureRandom instance
  -     * using the Security Provider API.  The Security Provider API is defined in 
  +     * using the Security Provider API.  The Security Provider API is defined in
        * <a href="http://java.sun.com/j2se/1.3/docs/guide/security/CryptoSpec.html#AppA">
        * Java Cryptography Architecture API Specification & Reference.</a>
        * <p>
  -     * <strong>USAGE NOTE:</strong> This method carries <i>significant</i> 
  +     * <strong>USAGE NOTE:</strong> This method carries <i>significant</i>
        * overhead and may take several seconds to execute.
        * </p>
        *
        * @param algorithm the name of the PRNG algorithm
  -     * @param provider the name of the provider 
  -     * @throws NoSuchAlgorithmException if the specified algorithm 
  +     * @param provider the name of the provider
  +     * @throws NoSuchAlgorithmException if the specified algorithm
        * is not available
  -     * @throws NoSuchProviderException if the specified provider 
  +     * @throws NoSuchProviderException if the specified provider
        * is not installed
        */
  -    public void setSecureAlgorithm(String algorithm, String provider) 
  +    public void setSecureAlgorithm(String algorithm, String provider)
           throws NoSuchAlgorithmException, NoSuchProviderException {
           secRand = SecureRandom.getInstance(algorithm, provider);
       }
  -    
  +
       /**
        * Uses a 2-cycle permutation shuffle to generate a random permutation.
        * The shuffling process is described
  @@ -474,35 +474,35 @@
           if (k > n) {
               throw new IllegalArgumentException
                   ("permutation k exceeds n");
  -        }       
  +        }
           if (k == 0) {
               throw new IllegalArgumentException
                   ("permutation k must be > 0");
           }
  -        
  +
           int[] index = getNatural(n);
           shuffle(index, n - k);
           int[] result = new int[k];
           for (int i = 0; i < k; i++) {
               result[i] = index[n - i - 1];
           }
  -  
  +
           return result;
       }
  -    
  +
       /**
        * Uses a 2-cycle permutation shuffle to generate a random permutation.
  -     * <strong>Algorithm Description</strong>: Uses a 2-cycle permutation 
  -     * shuffle to generate a random permutation of <code>c.size()</code> and 
  -     * then returns the elements whose indexes correspond to the elements of 
  -     * the generated permutation.  
  -     * This technique is described, and proven to generate random samples, 
  +     * <strong>Algorithm Description</strong>: Uses a 2-cycle permutation
  +     * shuffle to generate a random permutation of <code>c.size()</code> and
  +     * then returns the elements whose indexes correspond to the elements of
  +     * the generated permutation.
  +     * This technique is described, and proven to generate random samples,
        * <a href="http://www.maths.abdn.ac.uk/~igc/tch/mx4002/notes/node83.html">
        * here</a>
        * @param c Collection to sample from.
        * @param k sample size.
        * @return the random sample.
  -     */ 
  +     */
       public Object[] nextSample(Collection c, int k) {
           int len = c.size();
           if (k > len) {
  @@ -513,22 +513,22 @@
               throw new IllegalArgumentException
                   ("sample size must be > 0");
           }
  -            
  +
          Object[] objects = c.toArray();
          int[] index = nextPermutation(len, k);
          Object[] result = new Object[k];
          for (int i = 0; i < k; i++) {
              result[i] = objects[index[i]];
  -       }  
  +       }
          return result;
       }
  -    
  +
       //------------------------Private methods----------------------------------
  -    
  -    /** 
  +
  +    /**
        * Uses a 2-cycle permutation shuffle to randomly re-order the last elements
        * of list.
  -     * 
  +     *
        * @param list list to be shuffled
        * @param end element past which shuffling begins
        */
  @@ -536,16 +536,16 @@
           int target = 0;
           for (int i = list.length - 1 ; i >= end; i--) {
               if (i == 0) {
  -                target = 0; 
  +                target = 0;
               } else {
                   target = nextInt(0, i);
               }
               int temp = list[target];
               list[target] = list[i];
               list[i] = temp;
  -        }      
  +        }
       }
  -    
  +
       /**
        * Returns an array representing n.
        *
  @@ -559,5 +559,5 @@
           }
           return natural;
       }
  -        
  +
   }
  
  
  
  1.13      +79 -79    jakarta-commons/math/src/java/org/apache/commons/math/random/ValueServer.java
  
  Index: ValueServer.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/math/src/java/org/apache/commons/math/random/ValueServer.java,v
  retrieving revision 1.12
  retrieving revision 1.13
  diff -u -r1.12 -r1.13
  --- ValueServer.java	21 Feb 2004 21:35:15 -0000	1.12
  +++ ValueServer.java	14 Jun 2004 23:15:15 -0000	1.13
  @@ -1,12 +1,12 @@
   /*
    * Copyright 2003-2004 The Apache Software Foundation.
  - * 
  + *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
  - * 
  + *
    *      http://www.apache.org/licenses/LICENSE-2.0
  - * 
  + *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  @@ -26,19 +26,19 @@
    * Generates values for use in simulation applications.
    * <p>
    * How values are generated is determined by the <code>mode</code>
  - * property. 
  - * <p> 
  + * property.
  + * <p>
    * Supported <code>mode</code> values are: <ul>
    * <li> DIGEST_MODE -- uses an empirical distribution </li>
  - * <li> REPLAY_MODE -- replays data from <code>valuesFileURL</code></li> 
  + * <li> REPLAY_MODE -- replays data from <code>valuesFileURL</code></li>
    * <li> UNIFORM_MODE -- generates uniformly distributed random values with
    *                      mean = <code>mu</code> </li>
    * <li> EXPONENTIAL_MODE -- generates exponentially distributed random values
    *                         with mean = <code>mu</code></li>
    * <li> GAUSSIAN_MODE -- generates Gaussian distributed random values with
  - *                       mean = <code>mu</code> and 
  + *                       mean = <code>mu</code> and
    *                       standard deviation = <code>sigma</code></li>
  - * <li> CONSTANT_MODE -- returns <code>mu</code> every time.</li></ul> 
  + * <li> CONSTANT_MODE -- returns <code>mu</code> every time.</li></ul>
    *
    * @version $Revision$ $Date$
    *
  @@ -46,54 +46,54 @@
   public class ValueServer implements Serializable {
       /** mode determines how values are generated */
       private int mode = 5;
  -    
  +
       /** URI to raw data values  */
       private URL valuesFileURL = null;
  -    
  +
       /** Mean for use with non-data-driven modes */
       private double mu = 0.0;
  -    
  +
       /** Standard deviation for use with GAUSSIAN_MODE */
       private double sigma = 0.0;
  -    
  +
       /** Empirical probability distribution for use with DIGEST_MODE */
       private EmpiricalDistribution empiricalDistribution = null;
  -    
  +
       /** file pointer for REPLAY_MODE */
       private BufferedReader filePointer = null;
  -    
  +
       /** RandomDataImpl to use for random data generation */
       private RandomDataImpl randomData = new RandomDataImpl();
  -    
  +
       // Data generation modes ======================================
  -   
  +
       /** Use empirical distribution  */
  -    public static final int DIGEST_MODE = 0;        
  -    
  +    public static final int DIGEST_MODE = 0;
  +
       /** Replay data from valuesFilePath */
  -    public static final int REPLAY_MODE = 1;      
  -    
  +    public static final int REPLAY_MODE = 1;
  +
       /** Uniform random deviates with mean = mu */
  -    public static final int UNIFORM_MODE = 2;    
  -    
  +    public static final int UNIFORM_MODE = 2;
  +
       /** Exponential random deviates with mean = mu */
  -    public static final int EXPONENTIAL_MODE = 3;  
  -    
  +    public static final int EXPONENTIAL_MODE = 3;
  +
       /** Gaussian random deviates with mean = mu, std dev = sigma */
  -    public static final int GAUSSIAN_MODE = 4;  
  -    
  +    public static final int GAUSSIAN_MODE = 4;
  +
       /** Always return mu */
  -    public static final int CONSTANT_MODE = 5;   
  -    
  +    public static final int CONSTANT_MODE = 5;
  +
       /** Creates new ValueServer */
       public ValueServer() {
       }
   
  -    /** 
  +    /**
        * Returns the next generated value, generated according
  -     * to the mode value (see MODE constants). 
  +     * to the mode value (see MODE constants).
        *
  -     * @return generated value 
  +     * @return generated value
        * @throws IOException in REPLAY_MODE if a file I/O error occurs
        */
       public double getNext() throws IOException {
  @@ -108,7 +108,7 @@
                          ("Bad mode: " + mode);
           }
       }
  -    
  +
       /**
        * Fills the input array with values generated using getNext() repeatedly.
        *
  @@ -120,9 +120,9 @@
               values[i] = getNext();
           }
       }
  -    
  +
       /**
  -     * Returns an array of length <code>length</code> with values generated 
  +     * Returns an array of length <code>length</code> with values generated
        * using getNext() repeatedly.
        *
        * @param length length of output array
  @@ -135,9 +135,9 @@
               out[i] = getNext();
           }
           return out;
  -    }       
  -    
  -    /** 
  +    }
  +
  +    /**
        * Computes the empirical distribution using values from the file
        * in <code>valuesFileURL</code>, using the default number of bins.
        * <p>
  @@ -153,8 +153,8 @@
           empiricalDistribution = new EmpiricalDistributionImpl();
           empiricalDistribution.load(valuesFileURL);
       }
  -    
  -    /** 
  +
  +    /**
        * Computes the empirical distribution using values from the file
        * in <code>valuesFileURL</code> and <code>binCount</code> bins.
        * <p>
  @@ -168,28 +168,28 @@
        * distribution
        * @throws IOException if an error occurs reading the input file
        */
  -    public void computeDistribution(int binCount) 
  +    public void computeDistribution(int binCount)
               throws IOException {
           empiricalDistribution = new EmpiricalDistributionImpl(binCount);
           empiricalDistribution.load(valuesFileURL);
           mu = empiricalDistribution.getSampleStats().getMean();
           sigma = empiricalDistribution.getSampleStats().getStandardDeviation();
       }
  -    
  +
       /** Getter for property mode.
        * @return Value of property mode.
        */
       public int getMode() {
           return mode;
       }
  -    
  +
       /** Setter for property mode.
        * @param mode New value of property mode.
        */
       public void setMode(int mode) {
           this.mode = mode;
       }
  -    
  +
       /**
        * Getter for <code>valuesFileURL<code>
        * @return Value of property valuesFileURL.
  @@ -197,7 +197,7 @@
       public URL getValuesFileURL() {
           return valuesFileURL;
       }
  -    
  +
       /**
        * Sets the <code>valuesFileURL</code> using a string URL representation
        * @param url String representation for new valuesFileURL.
  @@ -206,7 +206,7 @@
       public void setValuesFileURL(String url) throws MalformedURLException {
           this.valuesFileURL = new URL(url);
       }
  -    
  +
       /**
        * Sets the <code>valuesFileURL</code>
        * @param url New value of property valuesFileURL.
  @@ -214,15 +214,15 @@
       public void setValuesFileURL(URL url) {
           this.valuesFileURL = url;
       }
  -    
  +
       /** Getter for property empiricalDistribution.
        * @return Value of property empiricalDistribution.
        */
       public EmpiricalDistribution getEmpiricalDistribution() {
           return empiricalDistribution;
  -    }    
  -    
  -    /**  
  +    }
  +
  +    /**
        * Opens <code>valuesFileURL</code> to use in REPLAY_MODE.
        *
        * @throws IOException if an error occurs opening the file
  @@ -231,8 +231,8 @@
       public void openReplayFile() throws IOException {
           resetReplayFile();
       }
  -    
  -    /**  
  +
  +    /**
        * Resets REPLAY_MODE file pointer to the beginning of the <code>valuesFileURL</code>.
        *
        * @throws IOException if an error occurs opening the file
  @@ -246,8 +246,8 @@
           }
           filePointer = new BufferedReader(new InputStreamReader(valuesFileURL.openStream()));
       }
  -    
  -    /** 
  +
  +    /**
        * Closes <code>valuesFileURL</code> after use in REPLAY_MODE.
        *
        * @throws IOException if an error occurs closing the file
  @@ -256,66 +256,66 @@
           if (filePointer != null) {
               filePointer.close();
               filePointer = null;
  -        }     
  +        }
       }
  -    
  +
       /** Getter for property mu.
        * @return Value of property mu.
        */
       public double getMu() {
           return mu;
       }
  -    
  +
       /** Setter for property mu.
        * @param mu New value of property mu.
        */
       public void setMu(double mu) {
           this.mu = mu;
       }
  -    
  +
       /** Getter for property sigma.
        * @return Value of property sigma.
        */
       public double getSigma() {
           return sigma;
       }
  -    
  +
       /** Setter for property sigma.
        * @param sigma New value of property sigma.
        */
       public void setSigma(double sigma) {
           this.sigma = sigma;
       }
  -    
  +
       //------------- private methods ---------------------------------
  -    
  -    /** 
  +
  +    /**
        * Gets a random value in DIGEST_MODE.
        * <p>
        * <strong>Preconditions</strong>: <ul>
        * <li>Before this method is called, <code>computeDistribution()</code>
  -     * must have completed successfully; otherwise an 
  +     * must have completed successfully; otherwise an
        * <code>IllegalStateException</code> will be thrown</li></ul>
        *
  -     * @return next random value from the empirical distribution digest 
  +     * @return next random value from the empirical distribution digest
        */
       private double getNextDigest() {
           if ((empiricalDistribution == null) ||
               (empiricalDistribution.getBinStats().size() == 0)) {
               throw new IllegalStateException("Digest not initialized");
           }
  -        return empiricalDistribution.getNextValue();     
  +        return empiricalDistribution.getNextValue();
       }
  -    
  +
       /**
        * Gets next sequential value from the <code>valuesFileURL</code>.
        * <p>
        * Throws an IOException if the read fails.
        * <p>
  -     * This method will open the <code>valuesFileURL</code> if there is no 
  +     * This method will open the <code>valuesFileURL</code> if there is no
        * replay file open.
        * <p>
  -     * The <code>valuesFileURL</code> will be closed and reopened to wrap around 
  +     * The <code>valuesFileURL</code> will be closed and reopened to wrap around
        * from EOF to BOF if EOF is encountered.
        *
        * @return next value from the replay file
  @@ -330,29 +330,29 @@
               closeReplayFile();
               resetReplayFile();
               str = filePointer.readLine();
  -        }         
  +        }
           return new Double(str).doubleValue();
       }
  -    
  -    /** 
  -     * Gets a uniformly distributed random value with mean = mu. 
  +
  +    /**
  +     * Gets a uniformly distributed random value with mean = mu.
        *
        * @return random uniform value
        */
       private double getNextUniform() {
           return randomData.nextUniform(0, 2 * mu);
       }
  -    
  -    /** 
  -     * Gets an exponentially distributed random value with mean = mu. 
  +
  +    /**
  +     * Gets an exponentially distributed random value with mean = mu.
        *
        * @return random exponential value
        */
       private double getNextExponential() {
  -        return randomData.nextExponential(mu);    
  +        return randomData.nextExponential(mu);
       }
  -    
  -    /** 
  +
  +    /**
        * Gets a Gaussian distributed random value with mean = mu
        * and standard deviation = sigma.
        *
  @@ -361,5 +361,5 @@
       private double getNextGaussian() {
           return randomData.nextGaussian(mu, sigma);
       }
  -    
  +
   }
  
  
  
  1.6       +2 -2      jakarta-commons/math/src/java/org/apache/commons/math/random/package.html
  
  Index: package.html
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/math/src/java/org/apache/commons/math/random/package.html,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- package.html	26 Apr 2004 18:28:17 -0000	1.5
  +++ package.html	14 Jun 2004 23:15:15 -0000	1.6
  @@ -14,6 +14,6 @@
      See the License for the specific language governing permissions and
      limitations under the License.
     -->
  -	<!-- $Revision$ $Date$ -->
  -	<body>Random number and random data generators.</body>
  +    <!-- $Revision$ $Date$ -->
  +    <body>Random number and random data generators.</body>
   </html>
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org


Mime
View raw message