activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r667107 - in /activemq/activemq-cpp/trunk/src: main/decaf/lang/Math.cpp main/decaf/lang/Math.h test/decaf/lang/MathTest.cpp test/decaf/lang/MathTest.h
Date Thu, 12 Jun 2008 14:38:30 GMT
Author: tabish
Date: Thu Jun 12 07:38:29 2008
New Revision: 667107

URL: http://svn.apache.org/viewvc?rev=667107&view=rev
Log:
http://issues.apache.org/activemq/browse/AMQCPP-181

Modified:
    activemq/activemq-cpp/trunk/src/main/decaf/lang/Math.cpp
    activemq/activemq-cpp/trunk/src/main/decaf/lang/Math.h
    activemq/activemq-cpp/trunk/src/test/decaf/lang/MathTest.cpp
    activemq/activemq-cpp/trunk/src/test/decaf/lang/MathTest.h

Modified: activemq/activemq-cpp/trunk/src/main/decaf/lang/Math.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/main/decaf/lang/Math.cpp?rev=667107&r1=667106&r2=667107&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/src/main/decaf/lang/Math.cpp (original)
+++ activemq/activemq-cpp/trunk/src/main/decaf/lang/Math.cpp Thu Jun 12 07:38:29 2008
@@ -44,24 +44,24 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-double Math::acos( double value ) {
-    return std::acos( value );
-}
+//double Math::acos( double value ) {
+//    return std::acos( value );
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
-double Math::asin( double value ) {
-    return std::asin( value );
-}
+//double Math::asin( double value ) {
+//    return std::asin( value );
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
-double Math::atan( double value ) {
-    return std::atan( value );
-}
+//double Math::atan( double value ) {
+//    return std::atan( value );
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
-double Math::atan2( double x, double y ) {
-    return std::atan2( x, y );
-}
+//double Math::atan2( double x, double y ) {
+//    return std::atan2( x, y );
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 double Math::random() {
@@ -70,98 +70,96 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-#ifndef _WIN32
-double Math::cbrt( double value ) {
-
-    if( Double::isNaN( value ) ) {
-        return Double::NaN;
-    } else if( Double::isInfinite( value ) ) {
-        return value;
-    } else if( !( value < 0 || value > 0 ) ) {
-        return value;
-    }
-
-    return ::cbrt( value );
-}
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-double Math::cos( double value ) {
-
-    if( Double::isNaN( value ) || Double::isInfinite( value ) ) {
-        return Double::NaN;
-    }
-
-    return std::cos( value );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-double Math::cosh( double value ) {
-
-    if( Double::isNaN( value ) ) {
-        return Double::NaN;
-    } else if( Double::isInfinite( value ) ) {
-        return Double::POSITIVE_INFINITY;
-    } else if( value == 0.0 ) {
-        return 1.0;
-    }
-
-    return std::cosh( value );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-double Math::sin( double value ) {
-
-    if( Double::isNaN( value ) || Double::isInfinite( value ) ) {
-        return Double::NaN;
-    } else if( !( value < 0 || value > 0 ) ) {
-        return value;
-    }
-
-    return std::sin( value );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-double Math::sinh( double value ) {
-
-    if( Double::isNaN( value ) ) {
-        return Double::NaN;
-    } else if( Double::isInfinite( value ) ) {
-        return value;
-    } else if( !( value < 0 || value > 0 ) ) {
-        return value;
-    }
-
-    return std::sinh( value );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-double Math::tan( double value ) {
-
-    if( Double::isNaN( value ) || value < -1.0 ) {
-        return Double::NaN;
-    } else if( !( value < 0 || value > 0 ) ) {
-        return value;
-    }
-
-    return std::tan( value );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-double Math::tanh( double value ) {
-
-    if( Double::isNaN( value ) ) {
-        return Double::NaN;
-    } else if( value == Double::POSITIVE_INFINITY ) {
-        return 1.0;
-    } else if( value == Double::NEGATIVE_INFINITY ) {
-        return -1.0;
-    } else if( !( value < 0 || value > 0 ) ) {
-        return value;
-    }
-
-    return std::tanh( value );
-}
+//double Math::cbrt( double value ) {
+//
+//    if( Double::isNaN( value ) ) {
+//        return Double::NaN;
+//    } else if( Double::isInfinite( value ) ) {
+//        return value;
+//    } else if( !( value < 0 || value > 0 ) ) {
+//        return value;
+//    }
+//
+//    return ::cbrt( value );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::cos( double value ) {
+//
+//    if( Double::isNaN( value ) || Double::isInfinite( value ) ) {
+//        return Double::NaN;
+//    }
+//
+//    return std::cos( value );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::cosh( double value ) {
+//
+//    if( Double::isNaN( value ) ) {
+//        return Double::NaN;
+//    } else if( Double::isInfinite( value ) ) {
+//        return Double::POSITIVE_INFINITY;
+//    } else if( value == 0.0 ) {
+//        return 1.0;
+//    }
+//
+//    return std::cosh( value );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::sin( double value ) {
+//
+//    if( Double::isNaN( value ) || Double::isInfinite( value ) ) {
+//        return Double::NaN;
+//    } else if( !( value < 0 || value > 0 ) ) {
+//        return value;
+//    }
+//
+//    return std::sin( value );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::sinh( double value ) {
+//
+//    if( Double::isNaN( value ) ) {
+//        return Double::NaN;
+//    } else if( Double::isInfinite( value ) ) {
+//        return value;
+//    } else if( !( value < 0 || value > 0 ) ) {
+//        return value;
+//    }
+//
+//    return std::sinh( value );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::tan( double value ) {
+//
+//    if( Double::isNaN( value ) || value < -1.0 ) {
+//        return Double::NaN;
+//    } else if( !( value < 0 || value > 0 ) ) {
+//        return value;
+//    }
+//
+//    return std::tan( value );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::tanh( double value ) {
+//
+//    if( Double::isNaN( value ) ) {
+//        return Double::NaN;
+//    } else if( value == Double::POSITIVE_INFINITY ) {
+//        return 1.0;
+//    } else if( value == Double::NEGATIVE_INFINITY ) {
+//        return -1.0;
+//    } else if( !( value < 0 || value > 0 ) ) {
+//        return value;
+//    }
+//
+//    return std::tanh( value );
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 double Math::sqrt( double value ) {
@@ -178,50 +176,46 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-#ifndef _WIN32 
-double Math::rint( double value ) {
-
-    if( Double::isNaN( value ) || Double::isInfinite( value ) ) {
-        return value;
-    } else if( value == 0.0 || value == -0.0 ) {
-        return value;
-    }
-
-    return ::rint( value );
-}
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-double Math::exp( double value ) {
-
-    if( Double::isNaN( value ) ) {
-        return Double::NaN;
-    } else if( value == Double::POSITIVE_INFINITY ) {
-        return Double::POSITIVE_INFINITY;
-    } else if( value == Double::NEGATIVE_INFINITY ) {
-        return 0.0;
-    }
-
-    return std::exp( value );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-#ifndef _WIN32 
-double Math::expm1( double value ) {
-
-    if( Double::isNaN( value ) ) {
-        return Double::NaN;
-    } else if( value == Double::POSITIVE_INFINITY ) {
-        return Double::POSITIVE_INFINITY;
-    } else if( value == Double::NEGATIVE_INFINITY ) {
-        return -1.0;
-    } else if( !( value > 0 || value < 0 ) ) {
-        return value;
-    }
-
-    return ::expm1( value );
-}
-#endif
+//double Math::rint( double value ) {
+//
+//    if( Double::isNaN( value ) || Double::isInfinite( value ) ) {
+//        return value;
+//    } else if( value == 0.0 || value == -0.0 ) {
+//        return value;
+//    }
+//
+//    return ::rint( value );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::exp( double value ) {
+//
+//    if( Double::isNaN( value ) ) {
+//        return Double::NaN;
+//    } else if( value == Double::POSITIVE_INFINITY ) {
+//        return Double::POSITIVE_INFINITY;
+//    } else if( value == Double::NEGATIVE_INFINITY ) {
+//        return 0.0;
+//    }
+//
+//    return std::exp( value );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::expm1( double value ) {
+//
+//    if( Double::isNaN( value ) ) {
+//        return Double::NaN;
+//    } else if( value == Double::POSITIVE_INFINITY ) {
+//        return Double::POSITIVE_INFINITY;
+//    } else if( value == Double::NEGATIVE_INFINITY ) {
+//        return -1.0;
+//    } else if( !( value > 0 || value < 0 ) ) {
+//        return value;
+//    }
+//
+//    return ::expm1( value );
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 float Math::min( float a, float b ) {
@@ -317,50 +311,48 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-double Math::log( double value ) {
-
-    if( Double::isNaN( value ) || value < 0.0 ) {
-        return Double::NaN;
-    } else if( value == Double::POSITIVE_INFINITY ) {
-        return Double::POSITIVE_INFINITY;
-    } else if( !( value < 0 || value > 0 ) ) {
-        return Double::NEGATIVE_INFINITY;
-    }
-
-    return std::log( value );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-double Math::log10( double value ) {
-
-    if( Double::isNaN( value ) || value < 0 ) {
-        return Double::NaN;
-    } else if( value == Double::POSITIVE_INFINITY ) {
-        return Double::POSITIVE_INFINITY;
-    } else if( !( value < 0 || value > 0 ) ) {
-        return Double::NEGATIVE_INFINITY;
-    }
-
-    return std::log10( value );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-#ifndef _WIN32
-double Math::log1p( double value ) {
-
-    if( Double::isNaN( value ) || value < -1.0 ) {
-        return Double::NaN;
-    } else if( value == Double::POSITIVE_INFINITY ) {
-        return Double::POSITIVE_INFINITY;
-    } else if( value == -1.0 ) {
-        return Double::NEGATIVE_INFINITY;
-    } else if( !( value < 0 || value > 0 ) ) {
-        return value;
-    }
-
-    return ::log1p( value );
-}
-#endif
+//double Math::log( double value ) {
+//
+//    if( Double::isNaN( value ) || value < 0.0 ) {
+//        return Double::NaN;
+//    } else if( value == Double::POSITIVE_INFINITY ) {
+//        return Double::POSITIVE_INFINITY;
+//    } else if( !( value < 0 || value > 0 ) ) {
+//        return Double::NEGATIVE_INFINITY;
+//    }
+//
+//    return std::log( value );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::log10( double value ) {
+//
+//    if( Double::isNaN( value ) || value < 0 ) {
+//        return Double::NaN;
+//    } else if( value == Double::POSITIVE_INFINITY ) {
+//        return Double::POSITIVE_INFINITY;
+//    } else if( !( value < 0 || value > 0 ) ) {
+//        return Double::NEGATIVE_INFINITY;
+//    }
+//
+//    return std::log10( value );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::log1p( double value ) {
+//
+//    if( Double::isNaN( value ) || value < -1.0 ) {
+//        return Double::NaN;
+//    } else if( value == Double::POSITIVE_INFINITY ) {
+//        return Double::POSITIVE_INFINITY;
+//    } else if( value == -1.0 ) {
+//        return Double::NEGATIVE_INFINITY;
+//    } else if( !( value < 0 || value > 0 ) ) {
+//        return value;
+//    }
+//
+//    return ::log1p( value );
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 double Math::ceil( double value ) {
@@ -410,19 +402,17 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-#ifndef _WIN32
-double Math::IEEEremainder( double f1, double f2 ) {
-
-    if( Double::isNaN( f1 ) || Double::isNaN( f2 ) ||
-        Double::isInfinite( f1 ) || !( f2 < 0 || f2 > 0 ) ) {
-        return Double::NaN;
-    } else if( Double::isInfinite( f2 ) ) {
-        return f1;
-    }
-
-    return ::remainder( f1, f2 );
-}
-#endif
+//double Math::IEEEremainder( double f1, double f2 ) {
+//
+//    if( Double::isNaN( f1 ) || Double::isNaN( f2 ) ||
+//        Double::isInfinite( f1 ) || !( f2 < 0 || f2 > 0 ) ) {
+//        return Double::NaN;
+//    } else if( Double::isInfinite( f2 ) ) {
+//        return f1;
+//    }
+//
+//    return ::remainder( f1, f2 );
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 float Math::signum( float value ) {
@@ -453,16 +443,16 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-double Math::hypot( double x, double y ) {
-
-    if( Double::isInfinite( x ) || Double::isInfinite( y ) ) {
-        return Double::POSITIVE_INFINITY;
-    } else if( Double::isNaN( x ) || Double::isNaN( y ) ) {
-        return Double::NaN;
-    }
-
-    return std::sqrt( ( x * x ) + ( y * y ) );
-}
+//double Math::hypot( double x, double y ) {
+//
+//    if( Double::isInfinite( x ) || Double::isInfinite( y ) ) {
+//        return Double::POSITIVE_INFINITY;
+//    } else if( Double::isNaN( x ) || Double::isNaN( y ) ) {
+//        return Double::NaN;
+//    }
+//
+//    return std::sqrt( ( x * x ) + ( y * y ) );
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 double Math::pow( double base, double exp ) {
@@ -479,39 +469,35 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-#ifndef _WIN32 
-float Math::ulp( float value ) {
-
-    if( Float::isNaN( value ) ) {
-        return Float::NaN;
-    } else if( Float::isInfinite( value ) ) {
-        return Float::POSITIVE_INFINITY;
-    } else if( value == Float::MAX_VALUE || value == -Float::MAX_VALUE ) {
-        return (float)pow( 2, 104 );
-    } else if( !( value < 0 || value > 0 ) ) {
-        return Float::MIN_VALUE;
-    }
-
-    value = abs( value );
-    return ::nextafterf( value, Float::MAX_VALUE ) - value;
-}
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-#ifndef _WIN32
-double Math::ulp( double value ) {
-
-    if( Double::isNaN( value ) ) {
-        return Double::NaN;
-    } else if( Double::isInfinite( value ) ) {
-        return Double::POSITIVE_INFINITY;
-    } else if( value == Double::MAX_VALUE || value == -Double::MAX_VALUE ) {
-        return pow( 2, 971 );
-    } else if( !( value < 0 || value > 0 ) ) {
-        return Double::MIN_VALUE;
-    }
-
-    value = abs( value );
-    return ::nextafter( value, Double::MAX_VALUE ) - value;
-}
-#endif
+//float Math::ulp( float value ) {
+//
+//    if( Float::isNaN( value ) ) {
+//        return Float::NaN;
+//    } else if( Float::isInfinite( value ) ) {
+//        return Float::POSITIVE_INFINITY;
+//    } else if( value == Float::MAX_VALUE || value == -Float::MAX_VALUE ) {
+//        return (float)pow( 2, 104 );
+//    } else if( !( value < 0 || value > 0 ) ) {
+//        return Float::MIN_VALUE;
+//    }
+//
+//    value = abs( value );
+//    return ::nextafterf( value, Float::MAX_VALUE ) - value;
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//double Math::ulp( double value ) {
+//
+//    if( Double::isNaN( value ) ) {
+//        return Double::NaN;
+//    } else if( Double::isInfinite( value ) ) {
+//        return Double::POSITIVE_INFINITY;
+//    } else if( value == Double::MAX_VALUE || value == -Double::MAX_VALUE ) {
+//        return pow( 2, 971 );
+//    } else if( !( value < 0 || value > 0 ) ) {
+//        return Double::MIN_VALUE;
+//    }
+//
+//    value = abs( value );
+//    return ::nextafter( value, Double::MAX_VALUE ) - value;
+//}

Modified: activemq/activemq-cpp/trunk/src/main/decaf/lang/Math.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/main/decaf/lang/Math.h?rev=667107&r1=667106&r2=667107&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/src/main/decaf/lang/Math.h (original)
+++ activemq/activemq-cpp/trunk/src/main/decaf/lang/Math.h Thu Jun 12 07:38:29 2008
@@ -114,7 +114,7 @@
          * @param value - the value to return the arc cosine of.
          * @returns arc cosine of value in radians.
          */
-        static double acos( double value );
+        //static double acos( double value );
 
         /**
          * Returns the arc sine of an angle, in the range of -pi/2 through pi/2.
@@ -128,7 +128,7 @@
          * @param value - the value to return the arc cosine of.
          * @returns arc cosine of value in radians.
          */
-        static double asin( double value );
+        //static double asin( double value );
 
         /**
          * Returns the arc tangent of an angle, in the range of -pi/2 through pi/2.
@@ -141,7 +141,7 @@
          * @param value - the value to return the arc cosine of.
          * @returns arc tangent of value in radians.
          */
-        static double atan( double value );
+        //static double atan( double value );
 
         /**
          * Converts rectangular coordinates (x, y) to polar (r, theta). This method
@@ -185,7 +185,7 @@
          * @returns the theta component of the point (r, theta) in polar coordinates
          * that corresponds to the point (x, y) in Cartesian coordinates.
          */
-        static double atan2( double x, double y );
+        //static double atan2( double x, double y );
 
         /**
          * Returns the cube root of a double value. For positive finite x,
@@ -201,9 +201,7 @@
          * @param value - the double to compute the cube root of
          * @returns the cube root of value
          */
-        #ifndef _WIN32
-        static double cbrt( double value );
-        #endif
+        //static double cbrt( double value );
 
         /**
          * Returns the trigonometric cosine of an angle. Special cases:
@@ -213,7 +211,7 @@
          * @param value - an value in radians
          * @returns the cosine of the argument.
          */
-        static double cos( double value );
+        //static double cos( double value );
 
         /**
          * Returns the hyperbolic cosine of a double value. The hyperbolic cosine
@@ -227,7 +225,7 @@
          * @param value - the number whose hyperbolic cosine is to be found
          * @return the hyperbolic cosine of value
          */
-        static double cosh( double value );
+        //static double cosh( double value );
 
         /**
          * Returns the trigonometric sine of an angle. Special case:
@@ -239,7 +237,7 @@
          * @param value - the number whose sin is to be found
          * @return the sine of value
          */
-        static double sin( double value );
+        //static double sin( double value );
 
         /**
          * Returns the hyperbolic sine of a double value. The hyperbolic sine of x
@@ -255,7 +253,7 @@
          * @param value - the number whose hyperbolic sin is to be found
          * @return the hyperbolic sine of value
          */
-        static double sinh( double value );
+        //static double sinh( double value );
 
         /**
          * Returns the trigonometric tangent of an angle. Special cases:
@@ -267,7 +265,7 @@
          * @param value - the number whose tangent is to be found
          * @return the tangent of value
          */
-        static double tan( double value );
+        //static double tan( double value );
 
         /**
          * Returns the hyperbolic tangent of a double value. The hyperbolic
@@ -284,7 +282,7 @@
          * @param value - the number whose hyperbolic tangent is to be found
          * @return the hyperbolic cosine of value
          */
-        static double tanh( double value );
+        //static double tanh( double value );
 
         /**
          * Returns the correctly rounded positive square root of a double value.
@@ -334,9 +332,7 @@
          * @param value - the value to round to the nearest integer
          * @returns the rounded value
          */
-        #ifndef _WIN32
-        static double rint( double value );
-        #endif
+        //static double rint( double value );
 
         /**
          * Returns the smaller of two <code>short</code> values. That is,
@@ -496,7 +492,7 @@
          * @param value the value to compute the natural log of.
          * @returns the natural log of value.
          */
-        static double log( double value );
+        //static double log( double value );
 
         /**
          * Returns the base 10 logarithm of a double value. Special cases:
@@ -511,7 +507,7 @@
          * @param value - the value to operate on
          * @returns the long base 10 of value
          */
-        static double log10( double value );
+        //static double log10( double value );
 
         /**
          * Returns the natural logarithm of the sum of the argument and 1. Note that
@@ -530,9 +526,7 @@
          * @param value - the value to operate on
          * @returns the the value ln(x + 1), the natural log of x + 1
          */
-        #ifndef _WIN32
-        static double log1p( double value );
-        #endif
+        //static double log1p( double value );
 
         /**
          * Returns the smallest (closest to negative infinity) double value that is
@@ -628,9 +622,7 @@
          * @param f2 - the divisor
          * @return the IEEE remainder of value
          */
-        #ifndef _WIN32
-        static double IEEEremainder( double f1, double f2 );
-        #endif
+        //static double IEEEremainder( double f1, double f2 );
 
         /**
          * Returns a double value with a positive sign, greater than or equal to 0.0
@@ -661,7 +653,7 @@
          * @param value - the exponent to raise e to
          * @returns the value e^a, where e is the base of the natural logarithms.
          */
-        static double exp( double value );
+        //static double exp( double value );
 
         /**
          * Returns e^x - 1. Note that for values of x near 0, the exact sum of
@@ -677,9 +669,7 @@
          * @param the value to raise e^x - 1
          * @returns the value ex - 1.
          */
-        #ifndef _WIN32
-        static double expm1( double value );
-        #endif
+        //static double expm1( double value );
 
         /**
          * Returns sqrt(x^2 + y^2) without intermediate overflow or underflow.
@@ -693,7 +683,7 @@
          * @param y - another argument
          * @returns the sqrt(x^2 + y^2) without intermediate overflow or underflow
          */
-        static double hypot( double x, double y );
+        //static double hypot( double x, double y );
 
         /**
          * Returns the signum function of the argument; zero if the argument is zero,
@@ -757,9 +747,7 @@
          * @param value - the floating-point value whose ulp is to be returned
          * @returns the size of an ulp of the argument
          */
-        #ifndef _WIN32
-        static float ulp( float value );
-        #endif
+        //static float ulp( float value );
 
         /**
          * Returns the size of an ulp of the argument. An ulp of a double value is
@@ -777,9 +765,8 @@
          * @param value - the floating-point value whose ulp is to be returned
          * @returns the size of an ulp of the argument
          */
-        #ifndef _WIN32
-        static double ulp( double value );
-        #endif
+        //static double ulp( double value );
+
     };
 
 }}

Modified: activemq/activemq-cpp/trunk/src/test/decaf/lang/MathTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/test/decaf/lang/MathTest.cpp?rev=667107&r1=667106&r2=667107&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/src/test/decaf/lang/MathTest.cpp (original)
+++ activemq/activemq-cpp/trunk/src/test/decaf/lang/MathTest.cpp Thu Jun 12 07:38:29 2008
@@ -68,70 +68,68 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_acosD() {
-    // Test for method double decaf.lang.Math::acos(double)
-    double r = Math::cos(Math::acos(ADJ / HYP));
-    long long lr = Double::doubleToLongBits(r);
-    long long t = Double::doubleToLongBits(ADJ / HYP);
-    CPPUNIT_ASSERT_MESSAGE("Returned incorrect arc cosine", lr == t || (lr + 1) == t
-            || (lr - 1) == t);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_asinD() {
-    // Test for method double decaf.lang.Math::asin(double)
-    double r = Math::sin(Math::asin(OPP / HYP));
-    long long lr = Double::doubleToLongBits(r);
-    long long t = Double::doubleToLongBits(OPP / HYP);
-    CPPUNIT_ASSERT_MESSAGE("Returned incorrect arc sine", lr == t || (lr + 1) == t
-            || (lr - 1) == t);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_atanD() {
-    // Test for method double decaf.lang.Math::atan(double)
-    double answer = Math::tan(Math::atan(1.0));
-    CPPUNIT_ASSERT_MESSAGE("Returned incorrect arc tangent: ",
-            answer <= 1.0 && answer >= 9.9999999999999983E-1);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_atan2DD() {
-    // Test for method double decaf.lang.Math::atan2(double, double)
-    double answer = Math::atan(Math::tan(1.0));
-    CPPUNIT_ASSERT_MESSAGE("Returned incorrect arc tangent: ",
-            answer <= 1.0 && answer >= 9.9999999999999983E-1);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_cbrt_D() {
-    //Test for special situations
-#ifndef _WIN32
-    CPPUNIT_ASSERT_MESSAGE("Should return Double::NaN",
-            Double::isNaN(Math::cbrt(Double::NaN)));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return Double::POSITIVE_INFINITY",
-            Math::cbrt(Double::POSITIVE_INFINITY), Double::POSITIVE_INFINITY );
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return Double::NEGATIVE_INFINITY",
-            Math::cbrt(Double::NEGATIVE_INFINITY), Double::NEGATIVE_INFINITY);
-    CPPUNIT_ASSERT_EQUAL(
-            Double::doubleToLongBits(0.0),
-            Double::doubleToLongBits(Math::cbrt(0.0)));
-    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(+0.0),
-                          Double::doubleToLongBits(Math::cbrt(+0.0)));
-    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(-0.0),
-                          Double::doubleToLongBits(Math::cbrt(-0.0)));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 3.0", Math::cbrt(27.0), 3.0);
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 5.643803094122362E102",
-            5.643803094122362E102, Math::cbrt(Double::MAX_VALUE));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 0.01", 0.01, Math::cbrt(0.000001));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -3.0", -3.0, Math::cbrt(-27.0));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.7031839360032603E-108",
-            1.7031839360032603E-108, Math::cbrt(Double::MIN_VALUE));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -0.01", -0.01, Math::cbrt(-0.000001));
-#endif
-}
+//void MathTest::test_acosD() {
+//    // Test for method double decaf.lang.Math::acos(double)
+//    double r = Math::cos(Math::acos(ADJ / HYP));
+//    long long lr = Double::doubleToLongBits(r);
+//    long long t = Double::doubleToLongBits(ADJ / HYP);
+//    CPPUNIT_ASSERT_MESSAGE("Returned incorrect arc cosine", lr == t || (lr + 1) == t
+//            || (lr - 1) == t);
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_asinD() {
+//    // Test for method double decaf.lang.Math::asin(double)
+//    double r = Math::sin(Math::asin(OPP / HYP));
+//    long long lr = Double::doubleToLongBits(r);
+//    long long t = Double::doubleToLongBits(OPP / HYP);
+//    CPPUNIT_ASSERT_MESSAGE("Returned incorrect arc sine", lr == t || (lr + 1) == t
+//            || (lr - 1) == t);
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_atanD() {
+//    // Test for method double decaf.lang.Math::atan(double)
+//    double answer = Math::tan(Math::atan(1.0));
+//    CPPUNIT_ASSERT_MESSAGE("Returned incorrect arc tangent: ",
+//            answer <= 1.0 && answer >= 9.9999999999999983E-1);
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_atan2DD() {
+//    // Test for method double decaf.lang.Math::atan2(double, double)
+//    double answer = Math::atan(Math::tan(1.0));
+//    CPPUNIT_ASSERT_MESSAGE("Returned incorrect arc tangent: ",
+//            answer <= 1.0 && answer >= 9.9999999999999983E-1);
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_cbrt_D() {
+//    //Test for special situations
+//    CPPUNIT_ASSERT_MESSAGE("Should return Double::NaN",
+//            Double::isNaN(Math::cbrt(Double::NaN)));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return Double::POSITIVE_INFINITY",
+//            Math::cbrt(Double::POSITIVE_INFINITY), Double::POSITIVE_INFINITY );
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return Double::NEGATIVE_INFINITY",
+//            Math::cbrt(Double::NEGATIVE_INFINITY), Double::NEGATIVE_INFINITY);
+//    CPPUNIT_ASSERT_EQUAL(
+//            Double::doubleToLongBits(0.0),
+//            Double::doubleToLongBits(Math::cbrt(0.0)));
+//    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(+0.0),
+//                          Double::doubleToLongBits(Math::cbrt(+0.0)));
+//    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(-0.0),
+//                          Double::doubleToLongBits(Math::cbrt(-0.0)));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 3.0", Math::cbrt(27.0), 3.0);
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 5.643803094122362E102",
+//            5.643803094122362E102, Math::cbrt(Double::MAX_VALUE));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 0.01", 0.01, Math::cbrt(0.000001));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -3.0", -3.0, Math::cbrt(-27.0));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.7031839360032603E-108",
+//            1.7031839360032603E-108, Math::cbrt(Double::MIN_VALUE));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -0.01", -0.01, Math::cbrt(-0.000001));
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 void MathTest::test_ceilD() {
@@ -143,80 +141,78 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_cosD() {
-    // Test for method double decaf.lang.Math::cos(double)
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer", 1.0, Math::cos(0));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer", 0.5403023058681398, Math::cos(1));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_cosh_D() {
-    // Test for special situations
-    CPPUNIT_ASSERT(Double::isNaN(Math::cosh(Double::NaN)));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::cosh(Double::POSITIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::cosh(Double::NEGATIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0", 1.0, Math::cosh(+0.0));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0", 1.0, Math::cosh(-0.0));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::cosh(1234.56));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::cosh(-1234.56));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0000000000005",
-            1.0000000000005, Math::cosh(0.000001));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0000000000005",
-            1.0000000000005, Math::cosh(-0.000001));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 5.212214351945598",
-            5.212214351945598, Math::cosh(2.33482));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::cosh(Double::MAX_VALUE));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0",
-            1.0, Math::cosh(Double::MIN_VALUE));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_expD() {
-    // Test for method double decaf.lang.Math::exp(double)
-    CPPUNIT_ASSERT_MESSAGE("Incorrect answer returned for simple power",
-            Math::abs(Math::exp(4.0) -
-            Math::E * Math::E * Math::E * Math::E) < 0.1 );
-    CPPUNIT_ASSERT_MESSAGE("Incorrect answer returned for larger power",
-            Math::log( Math::abs( Math::exp(5.5) ) - 5.5) < 10.0 );
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_expm1_D() {
-
-#ifndef _WIN32
-    // Test for special cases
-    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::expm1(Double::NaN)));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::expm1(Double::POSITIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -1.0", -1.0,
-            Math::expm1(Double::NEGATIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(0.0),
-                          Double::doubleToLongBits(Math::expm1(0.0)) );
-    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(+0.0),
-            Double::doubleToLongBits(Math::expm1(+0.0)));
-    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(-0.0),
-            Double::doubleToLongBits(Math::expm1(-0.0)));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -9.999950000166666E-6",
-            -9.999950000166666E-6, Math::expm1(-0.00001));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0145103074469635E60",
-            1.0145103074469635E60, Math::expm1(138.16951162));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY,
-            Math::expm1(123456789123456789123456789.4521584223));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::expm1(Double::MAX_VALUE));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return MIN_VALUE", Double::MIN_VALUE,
-            Math::expm1(Double::MIN_VALUE));
-#endif
-}
+//void MathTest::test_cosD() {
+//    // Test for method double decaf.lang.Math::cos(double)
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer", 1.0, Math::cos(0));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer", 0.5403023058681398, Math::cos(1));
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_cosh_D() {
+//    // Test for special situations
+//    CPPUNIT_ASSERT(Double::isNaN(Math::cosh(Double::NaN)));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::cosh(Double::POSITIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::cosh(Double::NEGATIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0", 1.0, Math::cosh(+0.0));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0", 1.0, Math::cosh(-0.0));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::cosh(1234.56));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::cosh(-1234.56));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0000000000005",
+//            1.0000000000005, Math::cosh(0.000001));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0000000000005",
+//            1.0000000000005, Math::cosh(-0.000001));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 5.212214351945598",
+//            5.212214351945598, Math::cosh(2.33482));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::cosh(Double::MAX_VALUE));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0",
+//            1.0, Math::cosh(Double::MIN_VALUE));
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_expD() {
+//    // Test for method double decaf.lang.Math::exp(double)
+//    CPPUNIT_ASSERT_MESSAGE("Incorrect answer returned for simple power",
+//            Math::abs(Math::exp(4.0) -
+//            Math::E * Math::E * Math::E * Math::E) < 0.1 );
+//    CPPUNIT_ASSERT_MESSAGE("Incorrect answer returned for larger power",
+//            Math::log( Math::abs( Math::exp(5.5) ) - 5.5) < 10.0 );
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_expm1_D() {
+//
+//    // Test for special cases
+//    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::expm1(Double::NaN)));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::expm1(Double::POSITIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -1.0", -1.0,
+//            Math::expm1(Double::NEGATIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(0.0),
+//                          Double::doubleToLongBits(Math::expm1(0.0)) );
+//    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(+0.0),
+//            Double::doubleToLongBits(Math::expm1(+0.0)));
+//    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(-0.0),
+//            Double::doubleToLongBits(Math::expm1(-0.0)));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -9.999950000166666E-6",
+//            -9.999950000166666E-6, Math::expm1(-0.00001));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0145103074469635E60",
+//            1.0145103074469635E60, Math::expm1(138.16951162));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY,
+//            Math::expm1(123456789123456789123456789.4521584223));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::expm1(Double::MAX_VALUE));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return MIN_VALUE", Double::MIN_VALUE,
+//            Math::expm1(Double::MIN_VALUE));
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 void MathTest::test_floorD() {
@@ -228,114 +224,109 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_hypot_DD() {
-    // Test for special cases
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::hypot(Double::POSITIVE_INFINITY,
-                    1.0));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::hypot(Double::NEGATIVE_INFINITY,
-                    123.324));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY,
-            Math::hypot(-758.2587,Double::POSITIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY,
-            Math::hypot(5687.21, Double::NEGATIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::hypot(Double::POSITIVE_INFINITY,
-                    Double::NEGATIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::hypot(Double::NEGATIVE_INFINITY,
-                    Double::POSITIVE_INFINITY));
-    CPPUNIT_ASSERT_MESSAGE("Should be NaN", Double::isNaN(Math::hypot(Double::NaN,
-            2342301.89843)));
-    CPPUNIT_ASSERT_MESSAGE("Should be NaN", Double::isNaN(Math::hypot(-345.2680,
-            Double::NaN)));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 2396424.905416697",
-            2396424.905416697, Math::hypot(12322.12, -2396393.2258));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 138.16958070558556", 138.16958070558556,
-            Math::hypot(-138.16951162, 0.13817035864));
-#ifndef _WIN32
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.7976931348623157E308",
-            1.7976931348623157E308, Math::hypot(Double::MAX_VALUE, 211370.35));
-#endif
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 5413.7185", 5413.7185, Math::hypot(
-            -5413.7185, Double::MIN_VALUE));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_IEEEremainderDD() {
-#ifndef _WIN32
-    // Test for method double decaf.lang.Math::IEEEremainder(double, double)
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect remainder returned",
-            0.0, Math::IEEEremainder(1.0, 1.0));
-    CPPUNIT_ASSERT_MESSAGE("Incorrect remainder returned",
-            Math::IEEEremainder(1.32,89.765) >= 1.4705063220631647E-2 ||
-            Math::IEEEremainder(1.32, 89.765) >= 1.4705063220631649E-2);
-#endif
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_logD() {
-    // Test for method double decaf.lang.Math::log(double)
-    for( double d = 10; d >= -10; d -= 0.5 ) {
-        double answer = Math::log( Math::exp(d) );
-
-        CPPUNIT_ASSERT_MESSAGE(
-                "Answer does not equal expected answer for d",
-                Math::abs( answer - d ) <= Math::abs(d * 0.00000001) );
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_log10_D() {
-    // Test for special cases
-    CPPUNIT_ASSERT(Double::isNaN(Math::log10(Double::NaN)));
-    CPPUNIT_ASSERT(Double::isNaN(Math::log10(-2541.05745687234187532)));
-    CPPUNIT_ASSERT(Double::isNaN(Math::log10(-0.1)));
-    CPPUNIT_ASSERT_EQUAL(Double::POSITIVE_INFINITY, Math::log10(Double::POSITIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL(Double::NEGATIVE_INFINITY, Math::log10(0.0));
-    CPPUNIT_ASSERT_EQUAL(Double::NEGATIVE_INFINITY, Math::log10(+0.0));
-    CPPUNIT_ASSERT_EQUAL(Double::NEGATIVE_INFINITY, Math::log10(-0.0));
-
-    CPPUNIT_ASSERT_EQUAL(3.0, Math::log10(1000.0));
-    CPPUNIT_ASSERT_EQUAL(14.0, Math::log10(Math::pow(10, 14)));
-    
-    CPPUNIT_ASSERT_EQUAL(3738956126954LL, (long long)(Math::log10(5482.2158)*1000000000000.0));
-    CPPUNIT_ASSERT_EQUAL(14661551142893LL, (long long)(Math::log10(458723662312872.125782332587)*1000000000000.0));
-    CPPUNIT_ASSERT_EQUAL(-908382862219LL, (long long)(Math::log10(0.12348583358871)*1000000000000.0));
-    CPPUNIT_ASSERT_EQUAL(308254715559916LL, (long long)(Math::log10(Double::MAX_VALUE)*1000000000000.0));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_log1p_D() {
-#ifndef _WIN32
-    // Test for special cases
-    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::log1p(Double::NaN)));
-    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::log1p(-32.0482175)));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::log1p(Double::POSITIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(0.0),
-                          Double::doubleToLongBits(Math::log1p(0.0)));
-    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(+0.0),
-                          Double::doubleToLongBits(Math::log1p(+0.0)));
-    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(-0.0),
-                          Double::doubleToLongBits(Math::log1p(-0.0)));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -0.2941782295312541", -0.2941782295312541,
-            Math::log1p(-0.254856327));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 7.368050685564151", 7.368050685564151,
-            Math::log1p(1583.542));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 0.4633708685409921", 0.4633708685409921,
-            Math::log1p(0.5894227));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 709.782712893384", 709.782712893384,
-            Math::log1p(Double::MAX_VALUE));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return Double::MIN_VALUE", Double::MIN_VALUE,
-            Math::log1p(Double::MIN_VALUE));
-#endif
-}
+//void MathTest::test_hypot_DD() {
+//    // Test for special cases
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::hypot(Double::POSITIVE_INFINITY,
+//                    1.0));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::hypot(Double::NEGATIVE_INFINITY,
+//                    123.324));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY,
+//            Math::hypot(-758.2587,Double::POSITIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY,
+//            Math::hypot(5687.21, Double::NEGATIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::hypot(Double::POSITIVE_INFINITY,
+//                    Double::NEGATIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::hypot(Double::NEGATIVE_INFINITY,
+//                    Double::POSITIVE_INFINITY));
+//    CPPUNIT_ASSERT_MESSAGE("Should be NaN", Double::isNaN(Math::hypot(Double::NaN,
+//            2342301.89843)));
+//    CPPUNIT_ASSERT_MESSAGE("Should be NaN", Double::isNaN(Math::hypot(-345.2680,
+//            Double::NaN)));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 2396424.905416697",
+//            2396424.905416697, Math::hypot(12322.12, -2396393.2258));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 138.16958070558556", 138.16958070558556,
+//            Math::hypot(-138.16951162, 0.13817035864));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.7976931348623157E308",
+//            1.7976931348623157E308, Math::hypot(Double::MAX_VALUE, 211370.35));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 5413.7185", 5413.7185, Math::hypot(
+//            -5413.7185, Double::MIN_VALUE));
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_IEEEremainderDD() {
+//    // Test for method double decaf.lang.Math::IEEEremainder(double, double)
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect remainder returned",
+//            0.0, Math::IEEEremainder(1.0, 1.0));
+//    CPPUNIT_ASSERT_MESSAGE("Incorrect remainder returned",
+//            Math::IEEEremainder(1.32,89.765) >= 1.4705063220631647E-2 ||
+//            Math::IEEEremainder(1.32, 89.765) >= 1.4705063220631649E-2);
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_logD() {
+//    // Test for method double decaf.lang.Math::log(double)
+//    for( double d = 10; d >= -10; d -= 0.5 ) {
+//        double answer = Math::log( Math::exp(d) );
+//
+//        CPPUNIT_ASSERT_MESSAGE(
+//                "Answer does not equal expected answer for d",
+//                Math::abs( answer - d ) <= Math::abs(d * 0.00000001) );
+//    }
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_log10_D() {
+//    // Test for special cases
+//    CPPUNIT_ASSERT(Double::isNaN(Math::log10(Double::NaN)));
+//    CPPUNIT_ASSERT(Double::isNaN(Math::log10(-2541.05745687234187532)));
+//    CPPUNIT_ASSERT(Double::isNaN(Math::log10(-0.1)));
+//    CPPUNIT_ASSERT_EQUAL(Double::POSITIVE_INFINITY, Math::log10(Double::POSITIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL(Double::NEGATIVE_INFINITY, Math::log10(0.0));
+//    CPPUNIT_ASSERT_EQUAL(Double::NEGATIVE_INFINITY, Math::log10(+0.0));
+//    CPPUNIT_ASSERT_EQUAL(Double::NEGATIVE_INFINITY, Math::log10(-0.0));
+//
+//    CPPUNIT_ASSERT_EQUAL(3.0, Math::log10(1000.0));
+//    CPPUNIT_ASSERT_EQUAL(14.0, Math::log10(Math::pow(10, 14)));
+//
+//    CPPUNIT_ASSERT_EQUAL(3738956126954LL, (long long)(Math::log10(5482.2158)*1000000000000.0));
+//    CPPUNIT_ASSERT_EQUAL(14661551142893LL, (long long)(Math::log10(458723662312872.125782332587)*1000000000000.0));
+//    CPPUNIT_ASSERT_EQUAL(-908382862219LL, (long long)(Math::log10(0.12348583358871)*1000000000000.0));
+//    CPPUNIT_ASSERT_EQUAL(308254715559916LL, (long long)(Math::log10(Double::MAX_VALUE)*1000000000000.0));
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_log1p_D() {
+//
+//	// Test for special cases
+//    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::log1p(Double::NaN)));
+//    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::log1p(-32.0482175)));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::log1p(Double::POSITIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(0.0),
+//                          Double::doubleToLongBits(Math::log1p(0.0)));
+//    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(+0.0),
+//                          Double::doubleToLongBits(Math::log1p(+0.0)));
+//    CPPUNIT_ASSERT_EQUAL( Double::doubleToLongBits(-0.0),
+//                          Double::doubleToLongBits(Math::log1p(-0.0)));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -0.2941782295312541", -0.2941782295312541,
+//            Math::log1p(-0.254856327));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 7.368050685564151", 7.368050685564151,
+//            Math::log1p(1583.542));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 0.4633708685409921", 0.4633708685409921,
+//            Math::log1p(0.5894227));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 709.782712893384", 709.782712893384,
+//            Math::log1p(Double::MAX_VALUE));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return Double::MIN_VALUE", Double::MIN_VALUE,
+//            Math::log1p(Double::MIN_VALUE));
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 void MathTest::test_maxDD() {
@@ -436,19 +427,17 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_rintD() {
-#ifndef _WIN32
-    // Test for method double decaf.lang.Math::rint(double)
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to round properly - up to odd",
-            3.0, Math::rint(2.9));
-    CPPUNIT_ASSERT_MESSAGE("Failed to round properly - NaN",
-            Double::isNaN(Math::rint(Double::NaN)));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to round properly down to even",
-            2.0, Math::rint(2.1));
-    CPPUNIT_ASSERT_MESSAGE("Failed to round properly to even",
-            Math::rint(2.5) == 2.0);
-#endif
-}
+//void MathTest::test_rintD() {
+//    // Test for method double decaf.lang.Math::rint(double)
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to round properly - up to odd",
+//            3.0, Math::rint(2.9));
+//    CPPUNIT_ASSERT_MESSAGE("Failed to round properly - NaN",
+//            Double::isNaN(Math::rint(Double::NaN)));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Failed to round properly down to even",
+//            2.0, Math::rint(2.1));
+//    CPPUNIT_ASSERT_MESSAGE("Failed to round properly to even",
+//            Math::rint(2.5) == 2.0);
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 void MathTest::test_roundD() {
@@ -512,44 +501,44 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_sinD() {
-    // Test for method double decaf.lang.Math::sin(double)
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer",
-        0.0, Math::sin(0));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer",
-        0.8414709848078965, Math::sin(1));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_sinh_D() {
-    // Test for special situations
-    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::sinh(Double::NaN)));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::sinh(Double::POSITIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return NEGATIVE_INFINITY",
-            Double::NEGATIVE_INFINITY, Math::sinh(Double::NEGATIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(0.0),
-            Double::doubleToLongBits(Math::sinh(0.0)));
-    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(+0.0),
-            Double::doubleToLongBits(Math::sinh(+0.0)));
-    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(-0.0),
-            Double::doubleToLongBits(Math::sinh(-0.0)));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::sinh(1234.56));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return NEGATIVE_INFINITY",
-            Double::NEGATIVE_INFINITY, Math::sinh(-1234.56));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0000000000001666E-6",
-            1.0000000000001666E-6, Math::sinh(0.000001));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -1.0000000000001666E-6",
-            -1.0000000000001666E-6, Math::sinh(-0.000001));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 5.11538644196386",
-             5.11538644196386, Math::sinh( 2.33482 ) );
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
-            Double::POSITIVE_INFINITY, Math::sinh(Double::MAX_VALUE));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 4.9E-324", 4.9E-324,
-            Math::sinh(Double::MIN_VALUE));
-}
+//void MathTest::test_sinD() {
+//    // Test for method double decaf.lang.Math::sin(double)
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer",
+//        0.0, Math::sin(0));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer",
+//        0.8414709848078965, Math::sin(1));
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_sinh_D() {
+//    // Test for special situations
+//    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::sinh(Double::NaN)));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::sinh(Double::POSITIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return NEGATIVE_INFINITY",
+//            Double::NEGATIVE_INFINITY, Math::sinh(Double::NEGATIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(0.0),
+//            Double::doubleToLongBits(Math::sinh(0.0)));
+//    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(+0.0),
+//            Double::doubleToLongBits(Math::sinh(+0.0)));
+//    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(-0.0),
+//            Double::doubleToLongBits(Math::sinh(-0.0)));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::sinh(1234.56));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return NEGATIVE_INFINITY",
+//            Double::NEGATIVE_INFINITY, Math::sinh(-1234.56));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0000000000001666E-6",
+//            1.0000000000001666E-6, Math::sinh(0.000001));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -1.0000000000001666E-6",
+//            -1.0000000000001666E-6, Math::sinh(-0.000001));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 5.11538644196386",
+//             5.11538644196386, Math::sinh( 2.33482 ) );
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return POSITIVE_INFINITY",
+//            Double::POSITIVE_INFINITY, Math::sinh(Double::MAX_VALUE));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 4.9E-324", 4.9E-324,
+//            Math::sinh(Double::MIN_VALUE));
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 void MathTest::test_sqrtD() {
@@ -559,42 +548,41 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_tanD() {
-    // Test for method double decaf.lang.Math::tan(double)
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer",
-            0.0, Math::tan(0));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer",
-            1.5574077246549023, Math::tan(1));
-
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_tanh_D() {
-    // Test for special situations
-    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::tanh(Double::NaN)));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return +1.0", +1.0,
-            Math::tanh(Double::POSITIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -1.0", -1.0,
-            Math::tanh(Double::NEGATIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(0.0),
-            Double::doubleToLongBits(Math::tanh(0.0)));
-    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(+0.0),
-            Double::doubleToLongBits(Math::tanh(+0.0)));
-    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(-0.0),
-            Double::doubleToLongBits(Math::tanh(-0.0)));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0", 1.0, Math::tanh(1234.56));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -1.0", -1.0, Math::tanh(-1234.56));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 9.999999999996666E-7",
-            9.999999999996666E-7, Math::tanh(0.000001));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 0.981422884124941", 0.981422884124941,
-            Math::tanh(2.33482));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0",
-            1.0, Math::tanh(Double::MAX_VALUE));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 4.9E-324", 4.9E-324,
-            Math::tanh(Double::MIN_VALUE));
-}
+//void MathTest::test_tanD() {
+//    // Test for method double decaf.lang.Math::tan(double)
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer",
+//            0.0, Math::tan(0));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Incorrect answer",
+//            1.5574077246549023, Math::tan(1));
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_tanh_D() {
+//    // Test for special situations
+//    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::tanh(Double::NaN)));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return +1.0", +1.0,
+//            Math::tanh(Double::POSITIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -1.0", -1.0,
+//            Math::tanh(Double::NEGATIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(0.0),
+//            Double::doubleToLongBits(Math::tanh(0.0)));
+//    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(+0.0),
+//            Double::doubleToLongBits(Math::tanh(+0.0)));
+//    CPPUNIT_ASSERT_EQUAL(Double::doubleToLongBits(-0.0),
+//            Double::doubleToLongBits(Math::tanh(-0.0)));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0", 1.0, Math::tanh(1234.56));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return -1.0", -1.0, Math::tanh(-1234.56));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 9.999999999996666E-7",
+//            9.999999999996666E-7, Math::tanh(0.000001));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 0.981422884124941", 0.981422884124941,
+//            Math::tanh(2.33482));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 1.0",
+//            1.0, Math::tanh(Double::MAX_VALUE));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Should return 4.9E-324", 4.9E-324,
+//            Math::tanh(Double::MIN_VALUE));
+//}
 
 ////////////////////////////////////////////////////////////////////////////////
 void MathTest::test_random() {
@@ -630,72 +618,67 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_ulp_D() {
-#ifndef _WIN32
-    // Test for special cases
-    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::ulp(Double::NaN)));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Double::POSITIVE_INFINITY,
-            Math::ulp(Double::POSITIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Double::POSITIVE_INFINITY,
-            Math::ulp(Double::NEGATIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            Double::MIN_VALUE, Math::ulp(0.0) );
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Double::MIN_VALUE,
-            Math::ulp(+0.0));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Double::MIN_VALUE,
-            Math::ulp(-0.0));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Math::pow(2, 971),
-            Math::ulp(Double::MAX_VALUE));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Math::pow(2, 971),
-            Math::ulp(-Double::MAX_VALUE));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            Double::MIN_VALUE, Math::ulp(Double::MIN_VALUE) );
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            Double::MIN_VALUE, Math::ulp(-Double::MIN_VALUE) );
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", 2.220446049250313E-16,
-            Math::ulp(1.0));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", 2.220446049250313E-16,
-            Math::ulp(-1.0));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", 2.2737367544323206E-13,
-            Math::ulp(1153.0));
-#endif
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void MathTest::test_ulp_f() {
-#ifndef _WIN32
-    // Test for special cases
-    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Float::isNaN(Math::ulp(Float::NaN)));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            Float::POSITIVE_INFINITY, Math::ulp(Float::POSITIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            Float::POSITIVE_INFINITY, Math::ulp(Float::NEGATIVE_INFINITY));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            Float::MIN_VALUE, Math::ulp(0.0f));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Float::MIN_VALUE, Math
-            ::ulp(+0.0f));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            Math::ulp(-0.0f), Float::MIN_VALUE );
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            2.028241E31f, Math::ulp(Float::MAX_VALUE));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            2.028241E31f, Math::ulp(-Float::MAX_VALUE));
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            1.4E-45f, Math::ulp( Float::MIN_VALUE ) );
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            1.4E-45f, Math::ulp( -Float::MIN_VALUE ) );
-
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            1.1920929E-7f, Math::ulp(1.0f));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", 1.1920929E-7f,
-            Math::ulp(-1.0f));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            1.2207031E-4f, Math::ulp(1153.0f));
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
-            5.6E-45f, Math::ulp(9.403954E-38f) );
-#endif
-}
-
+//void MathTest::test_ulp_D() {
+//    // Test for special cases
+//    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Double::isNaN(Math::ulp(Double::NaN)));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Double::POSITIVE_INFINITY,
+//            Math::ulp(Double::POSITIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Double::POSITIVE_INFINITY,
+//            Math::ulp(Double::NEGATIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            Double::MIN_VALUE, Math::ulp(0.0) );
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Double::MIN_VALUE,
+//            Math::ulp(+0.0));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Double::MIN_VALUE,
+//            Math::ulp(-0.0));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Math::pow(2, 971),
+//            Math::ulp(Double::MAX_VALUE));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Math::pow(2, 971),
+//            Math::ulp(-Double::MAX_VALUE));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            Double::MIN_VALUE, Math::ulp(Double::MIN_VALUE) );
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            Double::MIN_VALUE, Math::ulp(-Double::MIN_VALUE) );
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", 2.220446049250313E-16,
+//            Math::ulp(1.0));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", 2.220446049250313E-16,
+//            Math::ulp(-1.0));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", 2.2737367544323206E-13,
+//            Math::ulp(1153.0));
+//}
+
+////////////////////////////////////////////////////////////////////////////////
+//void MathTest::test_ulp_f() {
+//    // Test for special cases
+//    CPPUNIT_ASSERT_MESSAGE("Should return NaN", Float::isNaN(Math::ulp(Float::NaN)));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            Float::POSITIVE_INFINITY, Math::ulp(Float::POSITIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            Float::POSITIVE_INFINITY, Math::ulp(Float::NEGATIVE_INFINITY));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            Float::MIN_VALUE, Math::ulp(0.0f));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", Float::MIN_VALUE, Math
+//            ::ulp(+0.0f));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            Math::ulp(-0.0f), Float::MIN_VALUE );
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            2.028241E31f, Math::ulp(Float::MAX_VALUE));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            2.028241E31f, Math::ulp(-Float::MAX_VALUE));
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            1.4E-45f, Math::ulp( Float::MIN_VALUE ) );
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            1.4E-45f, Math::ulp( -Float::MIN_VALUE ) );
+//
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            1.1920929E-7f, Math::ulp(1.0f));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value", 1.1920929E-7f,
+//            Math::ulp(-1.0f));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            1.2207031E-4f, Math::ulp(1153.0f));
+//    CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned incorrect value",
+//            5.6E-45f, Math::ulp(9.403954E-38f) );
+//}

Modified: activemq/activemq-cpp/trunk/src/test/decaf/lang/MathTest.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/test/decaf/lang/MathTest.h?rev=667107&r1=667106&r2=667107&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/src/test/decaf/lang/MathTest.h (original)
+++ activemq/activemq-cpp/trunk/src/test/decaf/lang/MathTest.h Thu Jun 12 07:38:29 2008
@@ -31,22 +31,22 @@
         CPPUNIT_TEST( test_absF );
         CPPUNIT_TEST( test_absI );
         CPPUNIT_TEST( test_absJ );
-        CPPUNIT_TEST( test_acosD );
-        CPPUNIT_TEST( test_asinD );
-        CPPUNIT_TEST( test_atanD );
-        CPPUNIT_TEST( test_atan2DD );
-        CPPUNIT_TEST( test_cbrt_D );
+//        CPPUNIT_TEST( test_acosD );
+//        CPPUNIT_TEST( test_asinD );
+//        CPPUNIT_TEST( test_atanD );
+//        CPPUNIT_TEST( test_atan2DD );
+//        CPPUNIT_TEST( test_cbrt_D );
         CPPUNIT_TEST( test_ceilD );
-        CPPUNIT_TEST( test_cosD );
-        CPPUNIT_TEST( test_cosh_D );
-        CPPUNIT_TEST( test_expD );
-        CPPUNIT_TEST( test_expm1_D );
+//        CPPUNIT_TEST( test_cosD );
+//        CPPUNIT_TEST( test_cosh_D );
+//        CPPUNIT_TEST( test_expD );
+//        CPPUNIT_TEST( test_expm1_D );
         CPPUNIT_TEST( test_floorD );
-        CPPUNIT_TEST( test_hypot_DD );
-        CPPUNIT_TEST( test_IEEEremainderDD );
-        CPPUNIT_TEST( test_logD );
-        CPPUNIT_TEST( test_log10_D );
-        CPPUNIT_TEST( test_log1p_D );
+//        CPPUNIT_TEST( test_hypot_DD );
+//        CPPUNIT_TEST( test_IEEEremainderDD );
+//        CPPUNIT_TEST( test_logD );
+//        CPPUNIT_TEST( test_log10_D );
+//        CPPUNIT_TEST( test_log1p_D );
         CPPUNIT_TEST( test_maxDD );
         CPPUNIT_TEST( test_maxFF );
         CPPUNIT_TEST( test_maxII );
@@ -56,21 +56,21 @@
         CPPUNIT_TEST( test_minII );
         CPPUNIT_TEST( test_minJJ );
         CPPUNIT_TEST( test_powDD );
-        CPPUNIT_TEST( test_rintD );
+//        CPPUNIT_TEST( test_rintD );
         CPPUNIT_TEST( test_roundD );
         CPPUNIT_TEST( test_roundF );
         CPPUNIT_TEST( test_signum_D );
         CPPUNIT_TEST( test_signum_F );
-        CPPUNIT_TEST( test_sinD );
-        CPPUNIT_TEST( test_sinh_D );
+//        CPPUNIT_TEST( test_sinD );
+//        CPPUNIT_TEST( test_sinh_D );
         CPPUNIT_TEST( test_sqrtD );
-        CPPUNIT_TEST( test_tanD );
-        CPPUNIT_TEST( test_tanh_D );
+//        CPPUNIT_TEST( test_tanD );
+//        CPPUNIT_TEST( test_tanh_D );
         CPPUNIT_TEST( test_random );
         CPPUNIT_TEST( test_toRadiansD );
         CPPUNIT_TEST( test_toDegreesD );
-        CPPUNIT_TEST( test_ulp_D );
-        CPPUNIT_TEST( test_ulp_f );
+//        CPPUNIT_TEST( test_ulp_D );
+//        CPPUNIT_TEST( test_ulp_f );
         CPPUNIT_TEST_SUITE_END();
 
     private:
@@ -88,22 +88,22 @@
         virtual void test_absF();
         virtual void test_absI();
         virtual void test_absJ();
-        virtual void test_acosD();
-        virtual void test_asinD();
-        virtual void test_atanD();
-        virtual void test_atan2DD();
-        virtual void test_cbrt_D();
+//        virtual void test_acosD();
+//        virtual void test_asinD();
+//        virtual void test_atanD();
+//        virtual void test_atan2DD();
+//        virtual void test_cbrt_D();
         virtual void test_ceilD();
-        virtual void test_cosD();
-        virtual void test_cosh_D();
-        virtual void test_expD();
-        virtual void test_expm1_D();
+//        virtual void test_cosD();
+//        virtual void test_cosh_D();
+//        virtual void test_expD();
+//        virtual void test_expm1_D();
         virtual void test_floorD();
-        virtual void test_hypot_DD();
-        virtual void test_IEEEremainderDD();
-        virtual void test_logD();
-        virtual void test_log10_D();
-        virtual void test_log1p_D();
+//        virtual void test_hypot_DD();
+//        virtual void test_IEEEremainderDD();
+//        virtual void test_logD();
+//        virtual void test_log10_D();
+//        virtual void test_log1p_D();
         virtual void test_maxDD();
         virtual void test_maxFF();
         virtual void test_maxII();
@@ -113,21 +113,21 @@
         virtual void test_minII();
         virtual void test_minJJ();
         virtual void test_powDD();
-        virtual void test_rintD();
+//        virtual void test_rintD();
         virtual void test_roundD();
         virtual void test_roundF();
         virtual void test_signum_D();
         virtual void test_signum_F();
-        virtual void test_sinD();
-        virtual void test_sinh_D();
+//        virtual void test_sinD();
+//        virtual void test_sinh_D();
         virtual void test_sqrtD();
-        virtual void test_tanD();
-        virtual void test_tanh_D();
+//        virtual void test_tanD();
+//        virtual void test_tanh_D();
         virtual void test_random();
         virtual void test_toRadiansD();
         virtual void test_toDegreesD();
-        virtual void test_ulp_D();
-        virtual void test_ulp_f();
+//        virtual void test_ulp_D();
+//        virtual void test_ulp_f();
 
     };
 



Mime
View raw message