commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mdigg...@apache.org
Subject cvs commit: jakarta-commons-sandbox/math/src/test/org/apache/commons/math MathUtilsTest.java
Date Fri, 06 Jun 2003 03:07:39 GMT
mdiggory    2003/06/05 20:07:39

  Modified:    math/src/java/org/apache/commons/math MathUtils.java
               math/src/test/org/apache/commons/math MathUtilsTest.java
  Log:
  PR: http://nagoya.apache.org/bugzilla/show_bug.cgi?id=20496
  Submitted by:	Albert Davidson Chou
  
  Revision  Changes    Path
  1.2       +175 -75   jakarta-commons-sandbox/math/src/java/org/apache/commons/math/MathUtils.java
  
  Index: MathUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons-sandbox/math/src/java/org/apache/commons/math/MathUtils.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- MathUtils.java	4 Jun 2003 02:31:13 -0000	1.1
  +++ MathUtils.java	6 Jun 2003 03:07:39 -0000	1.2
  @@ -14,7 +14,7 @@
    * 2. Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in
    *    the documentation and/or other materials provided with the
  - *    distribution. 
  + *    distribution.
    *
    * 3. The end-user documentation included with the redistribution, if
    *    any, must include the following acknowlegement:
  @@ -63,26 +63,126 @@
   public class MathUtils {
   
       /**
  -     * Returns an exact representation of the 
  -     * <a href="http://mathworld.wolfram.com/BinomialCoefficient.html"> 
  -     * Binomial Coefficient</a>,  "<code>n choose k</code>", 
  -     * the number of <code>k</code>-element subsets that can be selected from

  -     * an <code>n</code>-element set.
  -     * <p>
  -     * <Strong>Preconditions</strong>:<ul>
  -     * <li> <code>0 < k <= n </code> (otherwise 
  -     *      <code>IllegalArgumentException</code> is thrown)</li>
  -     * <li> The result is small enough to fit into a <code>long</code>.
 The 
  -     *      largest value of <code>n</code> for which all coefficients are

  -     *      <code> < Long.MAX_VALUE</code> is 66.  If the computed value

  -     *      exceeds <code>Long.MAX_VALUE</code> an <code>ArithMeticException
  -     *      </code> is thrown.</li>
  -     * </ul>
  -     * 
  -     * @param n the size of the set
  -     * @param k the size of the subsets to be counted
  -     * @return <code>n choose k</code>
  +     * For a double precision value x, this method returns +1.0 if x >= 0
  +     * and -1.0 if x < 0.
  +     *
  +     * @author Albert Davidson Chou
  +     * @param x the value, a double
  +     * @return +1.0 or -1.0, depending on the the sign of x
  +     */
  +    public static double sign( double x ) {
  +        if ( x >= 0.0 ) {
  +            return 1.0 ;
  +        } else {
  +            return -1.0 ;
  +        }
  +    }
  +
  +    /**
  +     * For a float value x, this method returns +1.0F if x >= 0
  +     * and -1.0F if x < 0.
  +     *
  +     * @author Albert Davidson Chou
  +     * @param x the value, a float
  +     * @return +1.0F or -1.0F, depending on the the sign of x
  +     */
  +    public static float sign( float x ) {
  +        if ( x >= 0.0F ) {
  +            return 1.0F ;
  +        } else {
  +            return -1.0F ;
  +        }
  +    }
  +
  +    /**
  +     * For a byte value x, this method returns (byte)(+1) if x >= 0
  +     * and (byte)(-1) if x < 0.
  +     *
  +     * @author Albert Davidson Chou
  +     * @param x the value, a byte
  +     * @return (byte)(+1) or (byte)(-1), depending on the the sign of x
  +     */
  +    public static byte sign( byte x ) {
  +        if ( x >= (byte)0 ) {
  +            return (byte)1 ;
  +        } else {
  +            return (byte)(-1) ;
  +        }
  +    }
  +
  +    /**
  +     * For a short value x, this method returns (short)(+1) if x >= 0
  +     * and (short)(-1) if x < 0.
  +     *
  +     * @author Albert Davidson Chou
  +     * @param x the value, a short
  +     * @return (short)(+1) or (short)(-1), depending on the the sign of x
  +     */
  +    public static short sign( short x ) {
  +        if ( x >= (short)0 ) {
  +            return (short)1 ;
  +        } else {
  +            return (short)(-1) ;
  +        }
  +    }
  +
  +    /**
  +     * For an int value x, this method returns +1 if x >= 0
  +     * and -1 if x < 0.
  +     *
  +     * @author Albert Davidson Chou
  +     * @param x the value, an int
  +     * @return +1 or -1, depending on the the sign of x
        */
  +    public static int sign( int x ) {
  +        if ( x >= 0 ) {
  +            return 1 ;
  +        } else {
  +            return -1 ;
  +        }
  +    }
  + 
  +    /**
  +     * For a long value x, this method returns +1L if x >= 0
  +     * and -1L if x < 0.
  +     *
  +     * @author Albert Davidson Chou
  +     * @param x the value, a long
  +     * @return +1L or -1L, depending on the the sign of x
  +     */
  +    public static long sign( long x ) {
  +        if ( x >= 0L ) {
  +            return 1L ;
  +        } else {
  +            return -1L ;
  +        }
  +    }
  +   /**
  +    * Returns an exact representation of the
  +    * <a href="http://mathworld.wolfram.com/BinomialCoefficient.html">
  +    * Binomial Coefficient</a>,  "<code>n choose k</code>",
  +    * the number of <code>k</code>-element subsets that can be selected from
  +    * an <code>n</code>-element set.
  +    * <p>
  +    * <Strong>Preconditions</strong>:<ul>
  +    * <li> <code>0 < k <= n </code> (otherwise 
  +    * <li> <code>0 < k <= n </code> (otherwise
  +    *      <code>IllegalArgumentException</code> is thrown)</li>
  +    * <li> The result is small enough to fit into a <code>long</code>.
 The 
  +    *      largest value of <code>n</code> for which all coefficients are 
  +    *      <code> < Long.MAX_VALUE</code> is 66.  If the computed value

  +    * <li> The result is small enough to fit into a <code>long</code>.
 The
  +    *      largest value of <code>n</code> for which all coefficients are
  +    *      <code> < Long.MAX_VALUE</code> is 66.  If the computed value
  +    *      exceeds <code>Long.MAX_VALUE</code> an <code>ArithMeticException
  +    *      </code> is thrown.</li>
  +    * </ul>
  +    * 
  +    *
  +    * @param n the size of the set
  +    * @param k the size of the subsets to be counted
  +    * @return <code>n choose k</code>
  +    */
       public static long binomialCoefficient(int n, int k) {     
           if (n < k) {
               throw new IllegalArgumentException
  @@ -98,51 +198,51 @@
           if ((k == 1) || (k == n - 1)) {
               return n;
           }
  -        
  +
           long result = Math.round(binomialCoefficientDouble(n, k));
           if (result == Long.MAX_VALUE) {
               throw new ArithmeticException
                   ("result too large to represent in a long integer");
           }
  -        return result;   
  -    } 
  -    
  -    /**
  -     * Returns a <code>double</code> representation of the 
  -     * <a href="http://mathworld.wolfram.com/BinomialCoefficient.html"> 
  -     * Binomial Coefficient</a>,  "<code>n choose k</code>", 
  -     * the number of <code>k</code>-element subsets that can be selected from

  +        return result;
  +    }
  +
  +    /**
  +     * Returns a <code>double</code> representation of the
  +     * <a href="http://mathworld.wolfram.com/BinomialCoefficient.html">
  +     * Binomial Coefficient</a>,  "<code>n choose k</code>",
  +     * the number of <code>k</code>-element subsets that can be selected from
        * an <code>n</code>-element set.
        * <p>
        * <Strong>Preconditions</strong>:<ul>
  -     * <li> <code>0 < k <= n </code> (otherwise 
  +     * <li> <code>0 < k <= n </code> (otherwise
        *      <code>IllegalArgumentException</code> is thrown)</li>
  -     * <li> The result is small enough to fit into a <code>double</code>.
 
  -     *      The largest value of <code>n</code> for which all coefficients
are 
  -     *      < Double.MAX_VALUE is 1029.  If the computed value exceeds 
  +     * <li> The result is small enough to fit into a <code>double</code>.
  +     *      The largest value of <code>n</code> for which all coefficients
are
  +     *      < Double.MAX_VALUE is 1029.  If the computed value exceeds
        *      Double.MAX_VALUE, Double.POSITIVE_INFINITY is returned</li>
        * </ul>
  -     * 
  +     *
        * @param n the size of the set
        * @param k the size of the subsets to be counted
        * @return <code>n choose k</code>
        */
  -    public static double binomialCoefficientDouble(int n, int k) {  
  -        return Math.floor(Math.exp(binomialCoefficientLog(n, k)) + .5);    
  +    public static double binomialCoefficientDouble(int n, int k) {
  +        return Math.floor(Math.exp(binomialCoefficientLog(n, k)) + .5);
       }
  -    
  +
       /**
        * Returns the natural <code>log</code> of the
  -     * <a href="http://mathworld.wolfram.com/BinomialCoefficient.html"> 
  -     * Binomial Coefficient</a>,  "<code>n choose k</code>", 
  -     * the number of <code>k</code>-element subsets that can be selected from

  +     * <a href="http://mathworld.wolfram.com/BinomialCoefficient.html">
  +     * Binomial Coefficient</a>,  "<code>n choose k</code>",
  +     * the number of <code>k</code>-element subsets that can be selected from
        * an <code>n</code>-element set.
        * <p>
        * <Strong>Preconditions</strong>:<ul>
  -     * <li> <code>0 < k <= n </code> (otherwise 
  +     * <li> <code>0 < k <= n </code> (otherwise
        *      <code>IllegalArgumentException</code> is thrown)</li>
        * </ul>
  -     * 
  +     *
        * @param n the size of the set
        * @param k the size of the subsets to be counted
        * @return <code>n choose k</code>
  @@ -161,38 +261,38 @@
           }
           if ((k == 1) || (k == n - 1)) {
               return Math.log((double) n);
  -        }    
  -        double logSum = 0; 
  -        
  +        }
  +        double logSum = 0;
  +
           // n!/k!
           for (int i = k + 1; i <= n; i++) {
               logSum += Math.log((double) i);
           }
  -        
  +
           // divide by (n-k)!
           for (int i = 2; i <= n - k; i++) {
               logSum -= Math.log((double) i);
           }
  -        
  +
           return logSum;
       }
  -    
  +
       /**
        * Returns <code>n</code>
  -     * <a href="http://mathworld.wolfram.com/Factorial.html"> 
  -     * Factorial</a>, or <code>n!</code>,  
  +     * <a href="http://mathworld.wolfram.com/Factorial.html">
  +     * Factorial</a>, or <code>n!</code>,
        * the product of the numbers <code>1,...,n</code>.
        * <p>
        * <Strong>Preconditions</strong>:<ul>
  -     * <li> <code>n > 0</code> (otherwise 
  +     * <li> <code>n > 0</code> (otherwise
        *      <code>IllegalArgumentException</code> is thrown)</li>
  -     * <li> The result is small enough to fit into a <code>long</code>.
 The 
  -     *      largest value of <code>n</code> for which <code>n!</code>

  -     *      < Long.MAX_VALUE</code> is 20.  If the computed value 
  +     * <li> The result is small enough to fit into a <code>long</code>.
 The
  +     *      largest value of <code>n</code> for which <code>n!</code>
  +     *      < Long.MAX_VALUE</code> is 20.  If the computed value
        *      exceeds <code>Long.MAX_VALUE</code> an <code>ArithMeticException
        *      </code> is thrown.</li>
        * </ul>
  -     * 
  +     *
        * @param n argument
        * @return <code>n!</code>
        */
  @@ -202,25 +302,25 @@
               throw new ArithmeticException
                   ("result too large to represent in a long integer");
           }
  -        return result;  
  +        return result;
       }
  -    
  +
       /**
        * Returns <code>n</code>
  -     * <a href="http://mathworld.wolfram.com/Factorial.html"> 
  -     * Factorial</a>, or <code>n!</code>,  
  -     * the product of the numbers <code>1,...,n</code>, as as 
  +     * <a href="http://mathworld.wolfram.com/Factorial.html">
  +     * Factorial</a>, or <code>n!</code>,
  +     * the product of the numbers <code>1,...,n</code>, as as
        * <code>double</code>.
        * <p>
        * <Strong>Preconditions</strong>:<ul>
  -     * <li> <code>n > 0</code> (otherwise 
  +     * <li> <code>n > 0</code> (otherwise
        *      <code>IllegalArgumentException</code> is thrown)</li>
  -     * <li> The result is small enough to fit into a <code>double</code>.
 The 
  -     *      largest value of <code>n</code> for which <code>n!</code>

  -     *      < Double.MAX_VALUE</code> is 170.  If the computed value exceeds 
  +     * <li> The result is small enough to fit into a <code>double</code>.
 The
  +     *      largest value of <code>n</code> for which <code>n!</code>
  +     *      < Double.MAX_VALUE</code> is 170.  If the computed value exceeds
        *      Double.MAX_VALUE, Double.POSITIVE_INFINITY is returned</li>
        * </ul>
  -     * 
  +     *
        * @param n argument
        * @return <code>n!</code>
        */
  @@ -229,21 +329,21 @@
               throw new IllegalArgumentException
                   ("must have n > 0 for n!");
           }
  -        return Math.floor(Math.exp(factorialLog(n)) + 0.5); 
  +        return Math.floor(Math.exp(factorialLog(n)) + 0.5);
       }
  -    
  +
      /**
        * Returns the natural <code>log</code> of <code>n</code>
  -     * <a href="http://mathworld.wolfram.com/Factorial.html"> 
  -     * Factorial</a>, or <code>n!</code>,  
  -     * the product of the numbers <code>1,...,n</code>, as as 
  +     * <a href="http://mathworld.wolfram.com/Factorial.html">
  +     * Factorial</a>, or <code>n!</code>,
  +     * the product of the numbers <code>1,...,n</code>, as as
        * <code>double</code>.
        * <p>
        * <Strong>Preconditions</strong>:<ul>
  -     * <li> <code>n > 0</code> (otherwise 
  +     * <li> <code>n > 0</code> (otherwise
        *      <code>IllegalArgumentException</code> is thrown)</li>
        * </ul>
  -     * 
  +     *
        * @param n argument
        * @return <code>n!</code>
        */
  @@ -255,7 +355,7 @@
           double logSum = 0;
           for (int i = 2; i <= n; i++) {
               logSum += Math.log((double) i);
  -        }   
  +        }
           return logSum;
  -    }           
  +    }
   }
  
  
  
  1.2       +69 -34    jakarta-commons-sandbox/math/src/test/org/apache/commons/math/MathUtilsTest.java
  
  Index: MathUtilsTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons-sandbox/math/src/test/org/apache/commons/math/MathUtilsTest.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- MathUtilsTest.java	4 Jun 2003 02:31:14 -0000	1.1
  +++ MathUtilsTest.java	6 Jun 2003 03:07:39 -0000	1.2
  @@ -14,7 +14,7 @@
    * 2. Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in
    *    the documentation and/or other materials provided with the
  - *    distribution. 
  + *    distribution.
    *
    * 3. The end-user documentation included with the redistribution, if
    *    any, must include the following acknowlegement:
  @@ -69,9 +69,9 @@
   
       public MathUtilsTest(String name) {
           super(name);
  -    }   
  -    
  -    public void setUp() { 
  +    }
  +
  +    public void setUp() {
       }
   
       public static Test suite() {
  @@ -157,10 +157,10 @@
               ;
           }
           double x = MathUtils.binomialCoefficientDouble(1030,515);
  -        assertTrue("expecting infinite binomial coefficient", 
  +        assertTrue("expecting infinite binomial coefficient",
               Double.isInfinite(x));
       }
  -    
  +
       public void testFactorial() {
           for (int i = 1; i < 10; i++) {
               assertEquals(i + "! ",factorial(i),MathUtils.factorial(i));
  @@ -170,7 +170,7 @@
                   MathUtils.factorialLog(i),10E-12);
           }
       }
  -    
  +
       public void testFactorialFail() {
           try {
               long x = MathUtils.factorial(0);
  @@ -196,26 +196,26 @@
           } catch (ArithmeticException ex) {
               ;
           }
  -        assertTrue("expecting infinite factorial value", 
  +        assertTrue("expecting infinite factorial value",
               Double.isInfinite(MathUtils.factorialDouble(171)));
  -        
  +
       }
  -   
  -    
  -    /** 
  +
  +
  +    /**
        * Exact recursive implementation to test against
        */
  -    private long binomialCoefficient(int n, int k) {     
  +    private long binomialCoefficient(int n, int k) {
           if ((n == k) || (k == 0)) {
               return 1;
           }
           if ((k == 1) || (k == n - 1)) {
               return n;
           }
  -        return binomialCoefficient(n - 1, k - 1) + 
  +        return binomialCoefficient(n - 1, k - 1) +
               binomialCoefficient(n - 1, k);
  -    } 
  -    
  +    }
  +
       /**
        * Finds the largest values of n for which binomialCoefficient and
        * binomialCoefficientDouble will return values that fit in a long, double,
  @@ -225,7 +225,7 @@
               findBinomialLimits();
           }
        */
  -    
  +
       private void findBinomialLimits() {
           /**
            * will kick out 66 as the limit for long
  @@ -241,8 +241,8 @@
                       ("largest n for binomialCoefficient = " + (test - 1) );
               }
               test++;
  -        }     
  -        
  +        }
  +
          /**
           * will kick out 1029 as the limit for double
           */
  @@ -256,19 +256,19 @@
                       ("largest n for binomialCoefficientD = " + (test - 1) );
               }
               test++;
  -        } 
  +        }
       }
  -    
  +
       /**
        * Finds the largest values of n for which factiorial and
        * factorialDouble will return values that fit in a long, double,
        * resp.  Remove comments around test below to get this in test-report
  -     
  +
           public void testFactiorialLimits() {
               findFactorialLimits();
           }
        */
  -    
  +
       private void findFactorialLimits() {
           /**
            * will kick out 20 as the limit for long
  @@ -284,8 +284,8 @@
                       ("largest n for factorial = " + (test - 1) );
               }
               test++;
  -        }     
  -        
  +        }
  +
          /**
           * will kick out 170 as the limit for double
           */
  @@ -299,21 +299,56 @@
                       ("largest n for factorialDouble = " + (test - 1) );
               }
               test++;
  -        } 
  +        }
       }
  -    
  -    
  -    /** 
  +
  +
  +    /**
        * Exact direct multiplication implementation to test against
        */
  -    private long factorial(int n) {     
  +    private long factorial(int n) {
           long result = 1;
           for (int i = 2; i <= n; i++) {
               result *= i;
           }
           return result;
  -    } 
  - 
  -        
  +    }
  +
  +
  +    public void testSignDouble() {
  +        double delta = 0.0 ;
  +        assertEquals( 1.0, MathUtils.sign( 2.0 ), delta ) ;
  +        assertEquals( -1.0, MathUtils.sign( -2.0 ), delta ) ;
  +    }
  +
   
  +    public void testSignFloat() {
  +        float delta = 0.0F ;
  +        assertEquals( 1.0F, MathUtils.sign( 2.0F ), delta ) ;
  +        assertEquals( -1.0F, MathUtils.sign( -2.0F ), delta ) ;
  +    }
  +
  +
  +    public void testSignByte() {
  +        assertEquals( (byte)1, MathUtils.sign( (byte)2 ) ) ;
  +        assertEquals( (byte)(-1), MathUtils.sign( (byte)(-2) ) ) ;
  +    }
  +
  +
  +    public void testSignShort() {
  +        assertEquals( (short)1, MathUtils.sign( (short)2 ) ) ;
  +        assertEquals( (short)(-1), MathUtils.sign( (short)(-2) ) ) ;
  +    }
  +
  +
  +    public void testSignInt() {
  +        assertEquals( (int)1, MathUtils.sign( (int)(2) ) ) ;
  +        assertEquals( (int)(-1), MathUtils.sign( (int)(-2) ) ) ;
  +    }
  +
  +
  +    public void testSignLong() {
  +        assertEquals( 1L, MathUtils.sign( 2L ) ) ;
  +        assertEquals( -1L, MathUtils.sign( -2L ) ) ;
  +    }
   }
  
  
  

---------------------------------------------------------------------
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