Fix Bug 83566 - cyl_bessel_j returns wrong result for x>1000 for high orders
Michele Pezzutti
mpezz@tiscali.it
Thu Jan 4 21:08:00 GMT 2018
And the test cases
diff --git
a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/09_cyl_bessel_j/check_value.cc
b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/09_cyl_bessel_j/check_value.cc
index 26f4dd3..e340b78 100644
---
a/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/09_cyl_bessel_j/check_value.cc
+++
b/libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/09_cyl_bessel_j/check_value.cc
@@ -698,6 +698,26 @@ data026[21] =
 };
 const double toler026 = 1.0000000000000006e-11;
+// Test data for nu=100.00000000000000.
+// max(|f - f_GSL|): 2.5857788132910287e-14
+// max(|f - f_GSL| / |f_GSL|): 1.6767662425535933e-11
+const testcase_cyl_bessel_j<double>
+data027[11] =
+{
+Â { 0.0116761350077845, 100.0000000000000000, 1000.0000000000000000 },
+Â {-0.0116998547780258, 100.0000000000000000, 1100.0000000000000000 },
+Â {-0.0228014834050837, 100.0000000000000000, 1200.0000000000000000 },
+Â {-0.0169735007873739, 100.0000000000000000, 1300.0000000000000000 },
+Â {-0.0014154528803530, 100.0000000000000000, 1400.0000000000000000 },
+Â { 0.0133337265844988, 100.0000000000000000, 1500.0000000000000000 },
+Â { 0.0198025620201474, 100.0000000000000000, 1600.0000000000000000 },
+Â { 0.0161297712798388, 100.0000000000000000, 1700.0000000000000000 },
+Â { 0.0053753369281577, 100.0000000000000000, 1800.0000000000000000 },
+Â {-0.0069238868725646, 100.0000000000000000, 1900.0000000000000000 },
+Â {-0.0154878717200738, 100.0000000000000000, 2000.0000000000000000 },
+};
+const double toler027 = 1.0000000000000006e-10;
+
 template<typename Ret, unsigned int Num>
  void
  test(const testcase_cyl_bessel_j<Ret> (&data)[Num], Ret toler)
@@ -748,5 +768,6 @@ main()
  test(data024, toler024);
  test(data025, toler025);
  test(data026, toler026);
+Â test(data027, toler027);
  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
index 5579149..957aacd 100644
---
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
@@ -742,6 +742,26 @@ data028[20] =
 };
 const double toler028 = 1.0000000000000006e-11;
+// Test data for nu=100.00000000000000.
+// max(|f - f_GSL|): 3.1049815496508870e-14
+// max(|f - f_GSL| / |f_GSL|): 8.4272302674970308e-12
+const testcase_cyl_neumann<double>
+data029[11] =
+{
+Â {-0.0224386882577326, 100.0000000000000000, 1000.0000000000000000 },
+Â {-0.0210775951598200, 100.0000000000000000, 1100.0000000000000000 },
+Â {-0.0035299439206693, 100.0000000000000000, 1200.0000000000000000 },
+Â { 0.0142500193265366, 100.0000000000000000, 1300.0000000000000000 },
+Â { 0.0213046790897353, 100.0000000000000000, 1400.0000000000000000 },
+Â { 0.0157343950779022, 100.0000000000000000, 1500.0000000000000000 },
+Â { 0.0025544633636228, 100.0000000000000000, 1600.0000000000000000 },
+Â {-0.0107220455248494, 100.0000000000000000, 1700.0000000000000000 },
+Â {-0.0180369192432256, 100.0000000000000000, 1800.0000000000000000 },
+Â {-0.0169584155930798, 100.0000000000000000, 1900.0000000000000000 },
+Â {-0.0088788704566206, 100.0000000000000000, 2000.0000000000000000 },
+};
+const double toler029 = 1.0000000000000006e-11;
+
 template<typename Ret, unsigned int Num>
  void
  test(const testcase_cyl_neumann<Ret> (&data)[Num], Ret toler)
@@ -794,5 +814,6 @@ main()
  test(data026, toler026);
  test(data027, toler027);
  test(data028, toler028);
+Â test(data029, toler029);
  return 0;
 }
On 01/04/2018 09:54 PM, Michele Pezzutti wrote:
>
>
> On 01/04/2018 06:16 PM, Ed Smith-Rowland wrote:
>> I've seen their implementation. It's tight. Feel free to port it.
>> I assume this is it:
>> int
>> gsl_sf_bessel_Jnu_asympx_e(const double nu, const double x,
>> gsl_sf_result * result);
>>
>> You do want to give Q or b one more term so as to make that last
>> factor as small as possible. They're right.
>>
>
> Here it is.
>
> diff --git a/libstdc++-v3/include/tr1/bessel_function.tcc
> b/libstdc++-v3/include/tr1/bessel_function.tcc
> index 7ac733d..7842350 100644
> --- a/libstdc++-v3/include/tr1/bessel_function.tcc
> +++ b/libstdc++-v3/include/tr1/bessel_function.tcc
> @@ -353,21 +353,47 @@ namespace tr1
>      *  @param __x  The argument of the Bessel functions.
>      *  @param __Jnu The output Bessel function of the first kind.
>      *  @param __Nnu The output Neumann function (Bessel function
> of the second kind).
> +Â Â Â Â *
> +Â Â Â Â *Â Adapted for libstdc++ from GNU GSL version 2.4
> specfunc/bessel_j.c
> +Â Â Â Â *Â Copyright (C) 1996,1997,1998,1999,2000,2001,2002,2003 Gerard
> Jungman
> Â Â Â Â Â */
> Â Â Â Â template <typename _Tp>
> Â Â Â Â void
> Â Â Â Â __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu)
> Â Â Â Â {
>       const _Tp __mu  = _Tp(4) * __nu * __nu;
> -Â Â Â Â Â const _Tp __mum1 = __mu - _Tp(1);
> -Â Â Â Â Â const _Tp __mum9 = __mu - _Tp(9);
> -Â Â Â Â Â const _Tp __mum25 = __mu - _Tp(25);
> -Â Â Â Â Â const _Tp __mum49 = __mu - _Tp(49);
> -Â Â Â Â Â const _Tp __xx = _Tp(64) * __x * __x;
> -Â Â Â Â Â const _Tp __P = _Tp(1) - __mum1 * __mum9 / (_Tp(2) * __xx)
> -Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â * (_Tp(1) - __mum25 * __mum49 / (_Tp(12) * __xx));
> -Â Â Â Â Â const _Tp __Q = __mum1 / (_Tp(8) * __x)
> -Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â * (_Tp(1) - __mum9 * __mum25 / (_Tp(6) * __xx));
> +Â Â Â Â Â const _Tp __8x = _Tp(8) * __x;
> +
> +Â Â Â Â Â _Tp __P = _Tp(0);
> +Â Â Â Â Â _Tp __Q = _Tp(0);
> +
> +Â Â Â Â Â _Tp k = _Tp(0);
> +Â Â Â Â Â _Tp __term = _Tp(1);
> +
> +Â Â Â Â Â int __epsP = 0;
> +Â Â Â Â Â int __epsQ = 0;
> +
> +Â Â Â Â Â _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> +
> +Â Â Â Â Â do
> +Â Â Â Â Â Â Â {
> +Â Â Â Â Â Â Â Â Â __term *= (k == 0) ? _Tp(1) : -(__mu - (2 * k - 1) * (2 * k
> - 1)) / (k * __8x);
> +Â Â Â Â Â Â Â Â Â __epsP = std::abs(__term) < std::abs(__eps * __P);
> +Â Â Â Â Â Â Â Â Â __P += __term;
> +
> +Â Â Â Â Â Â Â Â Â k++;
> +
> +Â Â Â Â Â Â Â Â Â __term *= (__mu - (2 * k - 1) * (2 * k - 1)) / (k * __8x);
> +Â Â Â Â Â Â Â Â Â __epsQ = std::abs(__term) < std::abs(__eps * __Q);
> +Â Â Â Â Â Â Â Â Â __Q += __term;
> +
> +Â Â Â Â Â Â Â Â Â if (__epsP && __epsQ && k > __nu / 2.)
> +Â Â Â Â Â Â Â Â Â Â Â break;
> +
> +Â Â Â Â Â Â Â Â Â k++;
> +Â Â Â Â Â Â Â }
> +Â Â Â Â Â while (k < 1000);
> +
>
> Â Â Â Â Â Â const _Tp __chi = __x - (__nu + _Tp(0.5L))
> Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â * __numeric_constants<_Tp>::__pi_2();
>
>
>
>> In principal, these ideas should be ported to I,K but I think (and
>> IIRC GSL agrees) these under,over-flow before they have much effect.
>> I think I put the full series in there. They could use a similar
>> clean-up.
>>
>> But let's get this in there first.
>>
>> Ed
>>
>>
>
More information about the Libstdc++
mailing list