--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/stdcpp/tsrc/Boost_test/math/test/src/hypot_test.cpp	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,130 @@
+//  (C) Copyright John Maddock 2005.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+/*
+ * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.
+*/
+
+#include <boost/test/included/test_exec_monitor.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+#include <boost/math/special_functions/hypot.hpp>
+
+#include <cmath>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{ using ::sqrt; }
+#endif
+
+//
+// test_boundaries:
+// This is an accuracy test, sets the two arguments to hypot to just
+// above or just below various boundary conditions, and checks the accuracy
+// of the result.  The values computed at double precision will use a 
+// different computation method to those computed at float precision:
+// as long as these compute the same values then everything's OK.
+//
+// Tolerance is 2*epsilon, expressed here as a persentage:
+//
+static const float tolerance = 200 * (std::numeric_limits<float>::epsilon)();
+const float boundaries[] = {
+   0,
+   1,
+   2,
+   (std::numeric_limits<float>::max)()/2,
+   (std::numeric_limits<float>::min)(),
+   std::numeric_limits<float>::epsilon(),
+   std::sqrt((std::numeric_limits<float>::max)()) / 2,
+   std::sqrt((std::numeric_limits<float>::min)()),
+   std::sqrt((std::numeric_limits<float>::max)()) / 4,
+   std::sqrt((std::numeric_limits<float>::min)()) * 2,
+};
+
+void do_test_boundaries(float x, float y)
+{
+#ifdef __SYMBIAN32__
+   float expected = static_cast<float>((boost::math::hypot)(  
+      static_cast<double>(x), 
+      static_cast<double>(y)));
+#else
+   float expected = static_cast<float>((boost::math::hypot)(  
+      static_cast<long double>(x), 
+      static_cast<long double>(y)));
+#endif
+   float found = (boost::math::hypot)(x, y);
+   BOOST_CHECK_CLOSE(expected, found, tolerance);
+}
+
+void test_boundaries(float x, float y)
+{
+   do_test_boundaries(x, y);
+   do_test_boundaries(-x, y); 
+   do_test_boundaries(-x, -y);
+   do_test_boundaries(x, -y);
+}
+
+void test_boundaries(float x)
+{
+   for(unsigned i = 0; i < sizeof(boundaries)/sizeof(float); ++i)
+   {
+      test_boundaries(x, boundaries[i]);
+      test_boundaries(x, boundaries[i] + std::numeric_limits<float>::epsilon()*boundaries[i]);
+      test_boundaries(x, boundaries[i] - std::numeric_limits<float>::epsilon()*boundaries[i]);
+   }
+}
+
+void test_boundaries()
+{
+   for(unsigned i = 0; i < sizeof(boundaries)/sizeof(float); ++i)
+   {
+      test_boundaries(boundaries[i]);
+      test_boundaries(boundaries[i] + std::numeric_limits<float>::epsilon()*boundaries[i]);
+      test_boundaries(boundaries[i] - std::numeric_limits<float>::epsilon()*boundaries[i]);
+   }
+}
+
+void test_spots()
+{
+   static const float zero = 0;
+   for(unsigned i = 0; i < sizeof(boundaries)/sizeof(float); ++i)
+   {
+      BOOST_CHECK_EQUAL(boost::math::hypot(boundaries[i], zero), std::fabs(boundaries[i]));
+      BOOST_CHECK_EQUAL(boost::math::hypot(-boundaries[i], zero), std::fabs(-boundaries[i]));
+      BOOST_CHECK_EQUAL(boost::math::hypot(boundaries[i], -zero), std::fabs(boundaries[i]));
+      BOOST_CHECK_EQUAL(boost::math::hypot(-boundaries[i], -zero), std::fabs(-boundaries[i]));
+      for(unsigned j = 0; j < sizeof(boundaries)/sizeof(float); ++j)
+      {
+         BOOST_CHECK_EQUAL(boost::math::hypot(boundaries[i], boundaries[j]), boost::math::hypot(boundaries[j], boundaries[i]));
+         BOOST_CHECK_EQUAL(boost::math::hypot(boundaries[i], boundaries[j]), boost::math::hypot(boundaries[i], -boundaries[j]));
+         BOOST_CHECK_EQUAL(boost::math::hypot(-boundaries[i], -boundaries[j]), boost::math::hypot(-boundaries[j], -boundaries[i]));
+         BOOST_CHECK_EQUAL(boost::math::hypot(-boundaries[i], -boundaries[j]), boost::math::hypot(-boundaries[i], boundaries[j]));
+      }
+   }
+   if((std::numeric_limits<float>::has_infinity) && (std::numeric_limits<float>::has_quiet_NaN))
+   {
+      static const float nan = std::numeric_limits<float>::quiet_NaN();
+      static const float inf = std::numeric_limits<float>::infinity();
+      BOOST_CHECK_EQUAL(boost::math::hypot(inf, nan), inf);
+      BOOST_CHECK_EQUAL(boost::math::hypot(-inf, nan), inf);
+      BOOST_CHECK_EQUAL(boost::math::hypot(nan, inf), inf);
+      BOOST_CHECK_EQUAL(boost::math::hypot(nan, -inf), inf);
+      for(unsigned j = 0; j < sizeof(boundaries)/sizeof(float); ++j)
+      {
+         BOOST_CHECK_EQUAL(boost::math::hypot(boundaries[j], inf), inf);
+         BOOST_CHECK_EQUAL(boost::math::hypot(-boundaries[j], inf), inf);
+         BOOST_CHECK_EQUAL(boost::math::hypot(inf, boundaries[j]), inf);
+         BOOST_CHECK_EQUAL(boost::math::hypot(inf, -boundaries[j]), inf);
+         BOOST_CHECK_EQUAL(boost::math::hypot(boundaries[j], -inf), inf);
+         BOOST_CHECK_EQUAL(boost::math::hypot(-boundaries[j], -inf), inf);
+         BOOST_CHECK_EQUAL(boost::math::hypot(-inf, boundaries[j]), inf);
+         BOOST_CHECK_EQUAL(boost::math::hypot(-inf, -boundaries[j]), inf);
+      }
+   }
+}
+
+int test_main(int, char* [])
+{
+   test_boundaries();
+   test_spots();
+   return 0;
+}