obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

4 files changed, 786 insertions, 0 deletions

diff --git a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/check_nan.cc b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/check_nan.cc
new file mode 100644
index 000000000..229140723
--- /dev/null
+++ b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/check_nan.cc
@@ -0,0 +1,87 @@
+// { dg-require-c-std "" }
+// { dg-add-options ieee }
+
+// 2007-01-10  Edward Smith-Rowland <3dw4rd@verizon.net>
+//
+// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 5.2.1.11 cyl_neumann
+
+#include <tr1/cmath>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  float xf = std::numeric_limits<float>::quiet_NaN();
+  double xd = std::numeric_limits<double>::quiet_NaN();
+  long double xl = std::numeric_limits<long double>::quiet_NaN();
+
+  float nuf = 0.0F;
+  double nud = 0.0;
+  long double nul = 0.0L;
+
+  float a = std::tr1::cyl_neumann(nuf, xf);
+  float b = std::tr1::cyl_neumannf(nuf, xf);
+  double c = std::tr1::cyl_neumann(nud, xd);
+  long double d = std::tr1::cyl_neumann(nul, xl);
+  long double e = std::tr1::cyl_neumannl(nul, xl);
+
+  VERIFY(std::tr1::isnan<float>(a));
+  VERIFY(std::tr1::isnan<float>(b));
+  VERIFY(std::tr1::isnan<double>(c));
+  VERIFY(std::tr1::isnan<long double>(d));
+  VERIFY(std::tr1::isnan<long double>(e));
+
+  return;
+}
+
+void
+test02()
+{
+  float xf = 1.0F;
+  double xd = 1.0;
+  long double xl = 1.0L;
+
+  float nuf = std::numeric_limits<float>::quiet_NaN();
+  double nud = std::numeric_limits<double>::quiet_NaN();
+  long double nul = std::numeric_limits<long double>::quiet_NaN();
+
+  float a = std::tr1::cyl_neumann(nuf, xf);
+  float b = std::tr1::cyl_neumannf(nuf, xf);
+  double c = std::tr1::cyl_neumann(nud, xd);
+  long double d = std::tr1::cyl_neumann(nul, xl);
+  long double e = std::tr1::cyl_neumannl(nul, xl);
+
+  VERIFY(std::tr1::isnan<float>(a));
+  VERIFY(std::tr1::isnan<float>(b));
+  VERIFY(std::tr1::isnan<double>(c));
+  VERIFY(std::tr1::isnan<long double>(d));
+  VERIFY(std::tr1::isnan<long double>(e));
+
+  return;
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  return 0;
+}
+
diff --git a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/check_value.cc b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/check_value.cc
new file mode 100644
index 000000000..047b5812d
--- /dev/null
+++ b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/check_value.cc
@@ -0,0 +1,617 @@
+// 2007-02-04  Edward Smith-Rowland <3dw4rd@verizon.net>
+//
+// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+//  cyl_neumann
+
+
+//  Compare against values generated by the GNU Scientific Library.
+//  The GSL can be found on the web: http://www.gnu.org/software/gsl/
+
+#include <tr1/cmath>
+#if defined(__TEST_DEBUG)
+#include <iostream>
+#define VERIFY(A) \
+if (!(A)) \
+  { \
+    std::cout << "line " << __LINE__ \
+      << "  max_abs_frac = " << max_abs_frac \
+      << std::endl; \
+  }
+#else
+#include <testsuite_hooks.h>
+#endif
+#include "../testcase.h"
+
+
+// Test data for nu=0.0000000000000000.
+testcase_cyl_neumann<double> data001[] = {
+  { -0.30851762524903376, 0.0000000000000000, 5.0000000000000000 },
+  { 0.055671167283599395, 0.0000000000000000, 10.000000000000000 },
+  { 0.20546429603891825, 0.0000000000000000, 15.000000000000000 },
+  { 0.062640596809383955, 0.0000000000000000, 20.000000000000000 },
+  { -0.12724943226800620, 0.0000000000000000, 25.000000000000000 },
+  { -0.11729573168666411, 0.0000000000000000, 30.000000000000000 },
+  { 0.045797987195155640, 0.0000000000000000, 35.000000000000000 },
+  { 0.12593641705826095, 0.0000000000000000, 40.000000000000000 },
+  { 0.027060469763313322, 0.0000000000000000, 45.000000000000000 },
+  { -0.098064995470077104, 0.0000000000000000, 50.000000000000000 },
+  { -0.077569178730412622, 0.0000000000000000, 55.000000000000000 },
+  { 0.047358952209449412, 0.0000000000000000, 60.000000000000000 },
+  { 0.097183557740181933, 0.0000000000000000, 65.000000000000000 },
+  { 0.0093096664589410131, 0.0000000000000000, 70.000000000000000 },
+  { -0.085369047647775642, 0.0000000000000000, 75.000000000000000 },
+  { -0.055620339089769981, 0.0000000000000000, 80.000000000000000 },
+  { 0.049567884951494258, 0.0000000000000000, 85.000000000000000 },
+  { 0.079776475854877765, 0.0000000000000000, 90.000000000000000 },
+  { -0.0028230995861232323, 0.0000000000000000, 95.000000000000000 },
+  { -0.077244313365083112, 0.0000000000000000, 100.00000000000000 },
+};
+
+// Test function for nu=0.0000000000000000.
+template <typename Tp>
+void test001()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data001)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data001[i].nu), Tp(data001[i].x));
+      const Tp f0 = data001[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(1.0000000000000006e-10));
+}
+
+// Test data for nu=0.33333333333333331.
+testcase_cyl_neumann<double> data002[] = {
+  { -0.18192321129343830, 0.33333333333333331, 5.0000000000000000 },
+  { 0.17020111788268769, 0.33333333333333331, 10.000000000000000 },
+  { 0.18540507541540799, 0.33333333333333331, 15.000000000000000 },
+  { -0.028777707635715091, 0.33333333333333331, 20.000000000000000 },
+  { -0.15829741864944166, 0.33333333333333331, 25.000000000000000 },
+  { -0.058645772316705216, 0.33333333333333331, 30.000000000000000 },
+  { 0.10294930308870620, 0.33333333333333331, 35.000000000000000 },
+  { 0.10547870367098920, 0.33333333333333331, 40.000000000000000 },
+  { -0.034334228816010864, 0.33333333333333331, 45.000000000000000 },
+  { -0.11283489933031278, 0.33333333333333331, 50.000000000000000 },
+  { -0.030007358986895123, 0.33333333333333331, 55.000000000000000 },
+  { 0.086699173295718093, 0.33333333333333331, 60.000000000000000 },
+  { 0.074875579668878672, 0.33333333333333331, 65.000000000000000 },
+  { -0.039323246374552645, 0.33333333333333331, 70.000000000000000 },
+  { -0.091263539574475222, 0.33333333333333331, 75.000000000000000 },
+  { -0.013358849535984282, 0.33333333333333331, 80.000000000000000 },
+  { 0.078373575537830184, 0.33333333333333331, 85.000000000000000 },
+  { 0.055812482883955974, 0.33333333333333331, 90.000000000000000 },
+  { -0.043310380106990579, 0.33333333333333331, 95.000000000000000 },
+  { -0.076900504962136587, 0.33333333333333331, 100.00000000000000 },
+};
+
+// Test function for nu=0.33333333333333331.
+template <typename Tp>
+void test002()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data002)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data002[i].nu), Tp(data002[i].x));
+      const Tp f0 = data002[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(2.5000000000000014e-11));
+}
+
+// Test data for nu=0.50000000000000000.
+testcase_cyl_neumann<double> data003[] = {
+  { -0.10121770918510843, 0.50000000000000000, 5.0000000000000000 },
+  { 0.21170886633139813, 0.50000000000000000, 10.000000000000000 },
+  { 0.15650551590730860, 0.50000000000000000, 15.000000000000000 },
+  { -0.072806904785061841, 0.50000000000000000, 20.000000000000000 },
+  { -0.15817308404205055, 0.50000000000000000, 25.000000000000000 },
+  { -0.022470290598831121, 0.50000000000000000, 30.000000000000000 },
+  { 0.12187835265849536, 0.50000000000000000, 35.000000000000000 },
+  { 0.084138655676395432, 0.50000000000000000, 40.000000000000000 },
+  { -0.062482641933003132, 0.50000000000000000, 45.000000000000000 },
+  { -0.10888475635053953, 0.50000000000000000, 50.000000000000000 },
+  { -0.0023805454010948804, 0.50000000000000000, 55.000000000000000 },
+  { 0.098104683735037904, 0.50000000000000000, 60.000000000000000 },
+  { 0.055663470218594434, 0.50000000000000000, 65.000000000000000 },
+  { -0.060396767883824809, 0.50000000000000000, 70.000000000000000 },
+  { -0.084922578922046868, 0.50000000000000000, 75.000000000000000 },
+  { 0.0098472271924441215, 0.50000000000000000, 80.000000000000000 },
+  { 0.085190643574343639, 0.50000000000000000, 85.000000000000000 },
+  { 0.037684970437156261, 0.50000000000000000, 90.000000000000000 },
+  { -0.059772904856097479, 0.50000000000000000, 95.000000000000000 },
+  { -0.068803091468728053, 0.50000000000000000, 100.00000000000000 },
+};
+
+// Test function for nu=0.50000000000000000.
+template <typename Tp>
+void test003()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data003)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data003[i].nu), Tp(data003[i].x));
+      const Tp f0 = data003[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(5.0000000000000028e-11));
+}
+
+// Test data for nu=0.66666666666666663.
+testcase_cyl_neumann<double> data004[] = {
+  { -0.016050662643389616, 0.66666666666666663, 5.0000000000000000 },
+  { 0.23937232657540730, 0.66666666666666663, 10.000000000000000 },
+  { 0.11762106604241242, 0.66666666666666663, 15.000000000000000 },
+  { -0.11182254014899563, 0.66666666666666663, 20.000000000000000 },
+  { -0.14756582982938804, 0.66666666666666663, 25.000000000000000 },
+  { 0.015078692908077665, 0.66666666666666663, 30.000000000000000 },
+  { 0.13260911815705798, 0.66666666666666663, 35.000000000000000 },
+  { 0.057217565989652795, 0.66666666666666663, 40.000000000000000 },
+  { -0.086373755152382048, 0.66666666666666663, 45.000000000000000 },
+  { -0.097624139208051630, 0.66666666666666663, 50.000000000000000 },
+  { 0.025354902147023434, 0.66666666666666663, 55.000000000000000 },
+  { 0.10288136476351209, 0.66666666666666663, 60.000000000000000 },
+  { 0.032728379560128203, 0.66666666666666663, 65.000000000000000 },
+  { -0.077363672735747777, 0.66666666666666663, 70.000000000000000 },
+  { -0.072855870458293975, 0.66666666666666663, 75.000000000000000 },
+  { 0.032358106046953494, 0.66666666666666663, 80.000000000000000 },
+  { 0.086240651537394228, 0.66666666666666663, 85.000000000000000 },
+  { 0.017029601697285159, 0.66666666666666663, 90.000000000000000 },
+  { -0.072173520560584709, 0.66666666666666663, 95.000000000000000 },
+  { -0.056057339204073985, 0.66666666666666663, 100.00000000000000 },
+};
+
+// Test function for nu=0.66666666666666663.
+template <typename Tp>
+void test004()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data004)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data004[i].nu), Tp(data004[i].x));
+      const Tp f0 = data004[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(2.5000000000000014e-11));
+}
+
+// Test data for nu=1.0000000000000000.
+testcase_cyl_neumann<double> data005[] = {
+  { 0.14786314339122689, 1.0000000000000000, 5.0000000000000000 },
+  { 0.24901542420695388, 1.0000000000000000, 10.000000000000000 },
+  { 0.021073628036873546, 1.0000000000000000, 15.000000000000000 },
+  { -0.16551161436252118, 1.0000000000000000, 20.000000000000000 },
+  { -0.098829964783237384, 1.0000000000000000, 25.000000000000000 },
+  { 0.084425570661747149, 1.0000000000000000, 30.000000000000000 },
+  { 0.12751273354559012, 1.0000000000000000, 35.000000000000000 },
+  { -0.0057935058215496330, 1.0000000000000000, 40.000000000000000 },
+  { -0.11552517964639945, 1.0000000000000000, 45.000000000000000 },
+  { -0.056795668562014713, 1.0000000000000000, 50.000000000000000 },
+  { 0.073846265432577940, 1.0000000000000000, 55.000000000000000 },
+  { 0.091869609369866906, 1.0000000000000000, 60.000000000000000 },
+  { -0.017940374275377303, 1.0000000000000000, 65.000000000000000 },
+  { -0.094844652625716244, 1.0000000000000000, 70.000000000000000 },
+  { -0.035213785160580456, 1.0000000000000000, 75.000000000000000 },
+  { 0.069395913784588051, 1.0000000000000000, 80.000000000000000 },
+  { 0.071233187582749782, 1.0000000000000000, 85.000000000000000 },
+  { -0.026187238607768282, 1.0000000000000000, 90.000000000000000 },
+  { -0.081827958724501229, 1.0000000000000000, 95.000000000000000 },
+  { -0.020372312002759942, 1.0000000000000000, 100.00000000000000 },
+};
+
+// Test function for nu=1.0000000000000000.
+template <typename Tp>
+void test005()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data005)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data005[i].nu), Tp(data005[i].x));
+      const Tp f0 = data005[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(2.5000000000000014e-11));
+}
+
+// Test data for nu=2.0000000000000000.
+testcase_cyl_neumann<double> data006[] = {
+  { 0.36766288260552449, 2.0000000000000000, 5.0000000000000000 },
+  { -0.0058680824422086154, 2.0000000000000000, 10.000000000000000 },
+  { -0.20265447896733510, 2.0000000000000000, 15.000000000000000 },
+  { -0.079191758245636068, 2.0000000000000000, 20.000000000000000 },
+  { 0.11934303508534720, 2.0000000000000000, 25.000000000000000 },
+  { 0.12292410306411393, 2.0000000000000000, 30.000000000000000 },
+  { -0.038511545278264774, 2.0000000000000000, 35.000000000000000 },
+  { -0.12622609234933843, 2.0000000000000000, 40.000000000000000 },
+  { -0.032194922192042189, 2.0000000000000000, 45.000000000000000 },
+  { 0.095793168727596509, 2.0000000000000000, 50.000000000000000 },
+  { 0.080254497473415454, 2.0000000000000000, 55.000000000000000 },
+  { -0.044296631897120513, 2.0000000000000000, 60.000000000000000 },
+  { -0.097735569256347382, 2.0000000000000000, 65.000000000000000 },
+  { -0.012019513676818619, 2.0000000000000000, 70.000000000000000 },
+  { 0.084430013376826832, 2.0000000000000000, 75.000000000000000 },
+  { 0.057355236934384685, 2.0000000000000000, 80.000000000000000 },
+  { -0.047891809949547205, 2.0000000000000000, 85.000000000000000 },
+  { -0.080358414490605948, 2.0000000000000000, 90.000000000000000 },
+  { 0.0011004057182389959, 2.0000000000000000, 95.000000000000000 },
+  { 0.076836867125027908, 2.0000000000000000, 100.00000000000000 },
+};
+
+// Test function for nu=2.0000000000000000.
+template <typename Tp>
+void test006()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data006)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data006[i].nu), Tp(data006[i].x));
+      const Tp f0 = data006[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(2.5000000000000017e-10));
+}
+
+// Test data for nu=5.0000000000000000.
+testcase_cyl_neumann<double> data007[] = {
+  { -0.45369482249110188, 5.0000000000000000, 5.0000000000000000 },
+  { 0.13540304768936232, 5.0000000000000000, 10.000000000000000 },
+  { 0.16717271575940021, 5.0000000000000000, 15.000000000000000 },
+  { -0.10003576788953225, 5.0000000000000000, 20.000000000000000 },
+  { -0.14705799311372267, 5.0000000000000000, 25.000000000000000 },
+  { 0.031627359289264322, 5.0000000000000000, 30.000000000000000 },
+  { 0.13554781474770031, 5.0000000000000000, 35.000000000000000 },
+  { 0.031869448780850372, 5.0000000000000000, 40.000000000000000 },
+  { -0.10426932700176872, 5.0000000000000000, 45.000000000000000 },
+  { -0.078548413913081608, 5.0000000000000000, 50.000000000000000 },
+  { 0.055257033062858382, 5.0000000000000000, 55.000000000000000 },
+  { 0.099464632840450901, 5.0000000000000000, 60.000000000000000 },
+  { 0.00023860469499600970, 5.0000000000000000, 65.000000000000000 },
+  { -0.091861802216406066, 5.0000000000000000, 70.000000000000000 },
+  { -0.048383671296970077, 5.0000000000000000, 75.000000000000000 },
+  { 0.060293667104896330, 5.0000000000000000, 80.000000000000000 },
+  { 0.077506166682734010, 5.0000000000000000, 85.000000000000000 },
+  { -0.015338764062239803, 5.0000000000000000, 90.000000000000000 },
+  { -0.081531504045514375, 5.0000000000000000, 95.000000000000000 },
+  { -0.029480196281662041, 5.0000000000000000, 100.00000000000000 },
+};
+
+// Test function for nu=5.0000000000000000.
+template <typename Tp>
+void test007()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data007)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data007[i].nu), Tp(data007[i].x));
+      const Tp f0 = data007[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(2.5000000000000013e-09));
+}
+
+// Test data for nu=10.000000000000000.
+testcase_cyl_neumann<double> data008[] = {
+  { -25.129110095610098, 10.000000000000000, 5.0000000000000000 },
+  { -0.35981415218340279, 10.000000000000000, 10.000000000000000 },
+  { 0.21997141360195582, 10.000000000000000, 15.000000000000000 },
+  { -0.043894653515658202, 10.000000000000000, 20.000000000000000 },
+  { -0.14871839049980651, 10.000000000000000, 25.000000000000000 },
+  { 0.075056702122397012, 10.000000000000000, 30.000000000000000 },
+  { 0.12222473135000553, 10.000000000000000, 35.000000000000000 },
+  { -0.046723877232677867, 10.000000000000000, 40.000000000000000 },
+  { -0.11739339009322178, 10.000000000000000, 45.000000000000000 },
+  { 0.0057238971820535740, 10.000000000000000, 50.000000000000000 },
+  { 0.10733910125831635, 10.000000000000000, 55.000000000000000 },
+  { 0.036290350559545506, 10.000000000000000, 60.000000000000000 },
+  { -0.083239127691715639, 10.000000000000000, 65.000000000000000 },
+  { -0.069639384138314872, 10.000000000000000, 70.000000000000000 },
+  { 0.045798335061325038, 10.000000000000000, 75.000000000000000 },
+  { 0.086269195064844428, 10.000000000000000, 80.000000000000000 },
+  { -0.0018234674126248629, 10.000000000000000, 85.000000000000000 },
+  { -0.082067762371231298, 10.000000000000000, 90.000000000000000 },
+  { -0.038798074754578075, 10.000000000000000, 95.000000000000000 },
+  { 0.058331574236414815, 10.000000000000000, 100.00000000000000 },
+};
+
+// Test function for nu=10.000000000000000.
+template <typename Tp>
+void test008()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data008)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data008[i].nu), Tp(data008[i].x));
+      const Tp f0 = data008[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(2.5000000000000017e-10));
+}
+
+// Test data for nu=20.000000000000000.
+testcase_cyl_neumann<double> data009[] = {
+  { -593396529.69143212, 20.000000000000000, 5.0000000000000000 },
+  { -1597.4838482696264, 20.000000000000000, 10.000000000000000 },
+  { -3.3087330924737630, 20.000000000000000, 15.000000000000000 },
+  { -0.28548945860020319, 20.000000000000000, 20.000000000000000 },
+  { 0.19804074776289243, 20.000000000000000, 25.000000000000000 },
+  { -0.16848153948742675, 20.000000000000000, 30.000000000000000 },
+  { 0.10102784152594022, 20.000000000000000, 35.000000000000000 },
+  { 0.045161820565805928, 20.000000000000000, 40.000000000000000 },
+  { -0.12556489308015448, 20.000000000000000, 45.000000000000000 },
+  { 0.016442633948115841, 20.000000000000000, 50.000000000000000 },
+  { 0.10853448778255187, 20.000000000000000, 55.000000000000000 },
+  { -0.026721408520664677, 20.000000000000000, 60.000000000000000 },
+  { -0.098780425256324203, 20.000000000000000, 65.000000000000000 },
+  { 0.016201957786018205, 20.000000000000000, 70.000000000000000 },
+  { 0.093591198265063735, 20.000000000000000, 75.000000000000000 },
+  { 0.0040484400737295740, 20.000000000000000, 80.000000000000000 },
+  { -0.086314929459920503, 20.000000000000000, 85.000000000000000 },
+  { -0.028274110097231495, 20.000000000000000, 90.000000000000000 },
+  { 0.072349520791638755, 20.000000000000000, 95.000000000000000 },
+  { 0.051247973076188565, 20.000000000000000, 100.00000000000000 },
+};
+
+// Test function for nu=20.000000000000000.
+template <typename Tp>
+void test009()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data009)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data009[i].nu), Tp(data009[i].x));
+      const Tp f0 = data009[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(1.0000000000000006e-10));
+}
+
+// Test data for nu=50.000000000000000.
+testcase_cyl_neumann<double> data010[] = {
+  { -2.7888370175838943e+42, 50.000000000000000, 5.0000000000000000 },
+  { -3.6410665018007421e+27, 50.000000000000000, 10.000000000000000 },
+  { -1.0929732912175405e+19, 50.000000000000000, 15.000000000000000 },
+  { -15606426801663.732, 50.000000000000000, 20.000000000000000 },
+  { -753573251.44662631, 50.000000000000000, 25.000000000000000 },
+  { -386759.32602734747, 50.000000000000000, 30.000000000000000 },
+  { -1172.8690492895341, 50.000000000000000, 35.000000000000000 },
+  { -15.615608873419953, 50.000000000000000, 40.000000000000000 },
+  { -0.87058346204176951, 50.000000000000000, 45.000000000000000 },
+  { -0.21031655464397736, 50.000000000000000, 50.000000000000000 },
+  { 0.093048240412999375, 50.000000000000000, 55.000000000000000 },
+  { 0.0086417699626745066, 50.000000000000000, 60.000000000000000 },
+  { -0.025019788459221974, 50.000000000000000, 65.000000000000000 },
+  { -0.0014815155191908913, 50.000000000000000, 70.000000000000000 },
+  { 0.050335774732164155, 50.000000000000000, 75.000000000000000 },
+  { -0.092924250967987204, 50.000000000000000, 80.000000000000000 },
+  { 0.087332463030205670, 50.000000000000000, 85.000000000000000 },
+  { -0.016164237701651891, 50.000000000000000, 90.000000000000000 },
+  { -0.068897613820457920, 50.000000000000000, 95.000000000000000 },
+  { 0.076505263944802962, 50.000000000000000, 100.00000000000000 },
+};
+
+// Test function for nu=50.000000000000000.
+template <typename Tp>
+void test010()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data010)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data010[i].nu), Tp(data010[i].x));
+      const Tp f0 = data010[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(2.5000000000000017e-10));
+}
+
+// Test data for nu=100.00000000000000.
+testcase_cyl_neumann<double> data011[] = {
+  { -5.0848639160196196e+115, 100.00000000000000, 5.0000000000000000 },
+  { -4.8491482711800245e+85, 100.00000000000000, 10.000000000000000 },
+  { -1.6375955323195320e+68, 100.00000000000000, 15.000000000000000 },
+  { -8.2002648144679137e+55, 100.00000000000000, 20.000000000000000 },
+  { -2.9712216432562373e+46, 100.00000000000000, 25.000000000000000 },
+  { -7.2875284708240766e+38, 100.00000000000000, 30.000000000000000 },
+  { -3.4251079902108953e+32, 100.00000000000000, 35.000000000000000 },
+  { -1.4552439438101799e+27, 100.00000000000000, 40.000000000000000 },
+  { -3.4506612476220073e+22, 100.00000000000000, 45.000000000000000 },
+  { -3.2938001882025948e+18, 100.00000000000000, 50.000000000000000 },
+  { -1005686182055527.4, 100.00000000000000, 55.000000000000000 },
+  { -831892881402.11377, 100.00000000000000, 60.000000000000000 },
+  { -1650863778.0598330, 100.00000000000000, 65.000000000000000 },
+  { -7192614.1976097804, 100.00000000000000, 70.000000000000000 },
+  { -64639.072261231602, 100.00000000000000, 75.000000000000000 },
+  { -1152.5905185698464, 100.00000000000000, 80.000000000000000 },
+  { -40.250761402102000, 100.00000000000000, 85.000000000000000 },
+  { -2.8307771387185459, 100.00000000000000, 90.000000000000000 },
+  { -0.45762200495904559, 100.00000000000000, 95.000000000000000 },
+  { -0.16692141141757649, 100.00000000000000, 100.00000000000000 },
+};
+
+// Test function for nu=100.00000000000000.
+template <typename Tp>
+void test011()
+{
+  const Tp eps = std::numeric_limits<Tp>::epsilon();
+  Tp max_abs_diff = -Tp(1);
+  Tp max_abs_frac = -Tp(1);
+  unsigned int num_datum = sizeof(data011)
+                         / sizeof(testcase_cyl_neumann<double>);
+  for (unsigned int i = 0; i < num_datum; ++i)
+    {
+      const Tp f = std::tr1::cyl_neumann(Tp(data011[i].nu), Tp(data011[i].x));
+      const Tp f0 = data011[i].f0;
+      const Tp diff = f - f0;
+      if (std::abs(diff) > max_abs_diff)
+        max_abs_diff = std::abs(diff);
+      if (std::abs(f0) > Tp(10) * eps
+       && std::abs(f) > Tp(10) * eps)
+        {
+          const Tp frac = diff / f0;
+          if (std::abs(frac) > max_abs_frac)
+            max_abs_frac = std::abs(frac);
+        }
+    }
+  VERIFY(max_abs_frac < Tp(1.0000000000000006e-11));
+}
+
+int main(int, char**)
+{
+  test001<double>();
+  test002<double>();
+  test003<double>();
+  test004<double>();
+  test005<double>();
+  test006<double>();
+  test007<double>();
+  test008<double>();
+  test009<double>();
+  test010<double>();
+  test011<double>();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/compile.cc b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/compile.cc
new file mode 100644
index 000000000..bd606fbaf
--- /dev/null
+++ b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/compile.cc
@@ -0,0 +1,41 @@
+// { dg-do compile }
+
+// 2006-02-04  Edward Smith-Rowland <3dw4rd@verizon.net>
+//
+// Copyright (C) 2006-2007, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 5.2.1.11 cyl_neumann
+
+#include <tr1/cmath>
+
+void
+test01()
+{
+  float nuf = 1.0F / 3.0F, xf = 0.5F;
+  double nud = 1.0 / 3.0, xd = 0.5;
+  long double nul = 1.0L / 3.0L, xl = 0.5L;
+
+  std::tr1::cyl_neumann(nuf, xf);
+  std::tr1::cyl_neumannf(nuf, xf);
+  std::tr1::cyl_neumann(nud, xd);
+  std::tr1::cyl_neumann(nul, xl);
+  std::tr1::cyl_neumannl(nul, xl);
+
+  return;
+}
+
diff --git a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/compile_2.cc b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/compile_2.cc
new file mode 100644
index 000000000..651afa1c8
--- /dev/null
+++ b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/11_cyl_neumann/compile_2.cc
@@ -0,0 +1,41 @@
+// { dg-do compile }
+
+// 2006-02-04  Edward Smith-Rowland <3dw4rd@verizon.net>
+//
+// Copyright (C) 2006-2007, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 5.2.1.11 cyl_neumann
+
+#include <tr1/math.h>
+
+void
+test01()
+{
+  float nuf = 1.0F / 3.0F, xf = 0.5F;
+  double nud = 1.0 / 3.0, xd = 0.5;
+  long double nul = 1.0L / 3.0L, xl = 0.5L;
+
+  cyl_neumann(nuf, xf);
+  cyl_neumannf(nuf, xf);
+  cyl_neumann(nud, xd);
+  cyl_neumann(nul, xl);
+  cyl_neumannl(nul, xl);
+
+  return;
+}
+