int
main (void)
{
gsl_ieee_env_setup ();
gsl_rng_env_setup ();
r_global = gsl_rng_alloc (gsl_rng_default);
#define FUNC(x) test_ ## x, "test gsl_ran_" #x
#define FUNC2(x) test_ ## x, test_ ## x ## _pdf, "test gsl_ran_" #x
test_shuffle ();
test_choose ();
testMoments (FUNC (ugaussian), 0.0, 100.0, 0.5);
testMoments (FUNC (ugaussian), -1.0, 1.0, 0.6826895);
testMoments (FUNC (ugaussian), 3.0, 3.5, 0.0011172689);
testMoments (FUNC (ugaussian_tail), 3.0, 3.5, 0.0011172689 / 0.0013498981);
testMoments (FUNC (exponential), 0.0, 1.0, 1 - exp (-0.5));
testMoments (FUNC (cauchy), 0.0, 10000.0, 0.5);
testMoments (FUNC (discrete1), -0.5, 0.5, 0.59);
testMoments (FUNC (discrete1), 0.5, 1.5, 0.40);
testMoments (FUNC (discrete1), 1.5, 3.5, 0.01);
testMoments (FUNC (discrete2), -0.5, 0.5, 1.0/45.0 );
testMoments (FUNC (discrete2), 8.5, 9.5, 0 );
testMoments (FUNC (discrete3), -0.5, 0.5, 0.05 );
testMoments (FUNC (discrete3), 0.5, 1.5, 0.05 );
testMoments (FUNC (discrete3), -0.5, 9.5, 0.5 );
test_dirichlet_moments ();
test_multinomial_moments ();
testPDF (FUNC2 (beta));
testPDF (FUNC2 (cauchy));
testPDF (FUNC2 (chisq));
testPDF (FUNC2 (dirichlet));
testPDF (FUNC2 (erlang));
testPDF (FUNC2 (exponential));
testPDF (FUNC2 (exppow0));
testPDF (FUNC2 (exppow1));
testPDF (FUNC2 (exppow1a));
testPDF (FUNC2 (exppow2));
testPDF (FUNC2 (exppow2a));
testPDF (FUNC2 (exppow2b));
testPDF (FUNC2 (fdist));
testPDF (FUNC2 (flat));
testPDF (FUNC2 (gamma));
testPDF (FUNC2 (gamma1));
testPDF (FUNC2 (gamma_int));
testPDF (FUNC2 (gamma_large));
testPDF (FUNC2 (gamma_small));
testPDF (FUNC2 (gamma_mt));
testPDF (FUNC2 (gamma_mt1));
testPDF (FUNC2 (gamma_mt_int));
testPDF (FUNC2 (gamma_mt_large));
testPDF (FUNC2 (gamma_mt_small));
testPDF (FUNC2 (gaussian));
testPDF (FUNC2 (gaussian_ratio_method));
testPDF (FUNC2 (gaussian_ziggurat));
testPDF (FUNC2 (ugaussian));
testPDF (FUNC2 (ugaussian_ratio_method));
testPDF (FUNC2 (gaussian_tail));
testPDF (FUNC2 (gaussian_tail1));
testPDF (FUNC2 (gaussian_tail2));
testPDF (FUNC2 (ugaussian_tail));
testPDF (FUNC2 (bivariate_gaussian1));
testPDF (FUNC2 (bivariate_gaussian2));
testPDF (FUNC2 (bivariate_gaussian3));
testPDF (FUNC2 (bivariate_gaussian4));
testPDF (FUNC2 (gumbel1));
testPDF (FUNC2 (gumbel2));
testPDF (FUNC2 (landau));
testPDF (FUNC2 (levy1));
testPDF (FUNC2 (levy2));
testPDF (FUNC2 (levy1a));
testPDF (FUNC2 (levy2a));
testPDF (FUNC2 (levy_skew1));
testPDF (FUNC2 (levy_skew2));
testPDF (FUNC2 (levy_skew1a));
testPDF (FUNC2 (levy_skew2a));
testPDF (FUNC2 (levy_skew1b));
testPDF (FUNC2 (levy_skew2b));
testPDF (FUNC2 (logistic));
testPDF (FUNC2 (lognormal));
testPDF (FUNC2 (pareto));
testPDF (FUNC2 (rayleigh));
testPDF (FUNC2 (rayleigh_tail));
testPDF (FUNC2 (tdist1));
testPDF (FUNC2 (tdist2));
testPDF (FUNC2 (laplace));
testPDF (FUNC2 (weibull));
testPDF (FUNC2 (weibull1));
testPDF (FUNC2 (dir2d));
testPDF (FUNC2 (dir2d_trig_method));
testPDF (FUNC2 (dir3dxy));
testPDF (FUNC2 (dir3dyz));
testPDF (FUNC2 (dir3dzx));
testDiscretePDF (FUNC2 (discrete1));
testDiscretePDF (FUNC2 (discrete2));
testDiscretePDF (FUNC2 (discrete3));
testDiscretePDF (FUNC2 (poisson));
testDiscretePDF (FUNC2 (poisson_large));
testDiscretePDF (FUNC2 (bernoulli));
testDiscretePDF (FUNC2 (binomial));
testDiscretePDF (FUNC2 (binomial0));
testDiscretePDF (FUNC2 (binomial1));
testDiscretePDF (FUNC2 (binomial_knuth));
testDiscretePDF (FUNC2 (binomial_large));
testDiscretePDF (FUNC2 (binomial_large_knuth));
testDiscretePDF (FUNC2 (binomial_huge));
testDiscretePDF (FUNC2 (binomial_huge_knuth));
testDiscretePDF (FUNC2 (geometric));
testDiscretePDF (FUNC2 (geometric1));
testDiscretePDF (FUNC2 (hypergeometric1));
testDiscretePDF (FUNC2 (hypergeometric2));
testDiscretePDF (FUNC2 (hypergeometric3));
testDiscretePDF (FUNC2 (hypergeometric4));
testDiscretePDF (FUNC2 (hypergeometric5));
testDiscretePDF (FUNC2 (hypergeometric6));
testDiscretePDF (FUNC2 (logarithmic));
testDiscretePDF (FUNC2 (multinomial));
testDiscretePDF (FUNC2 (multinomial_large));
testDiscretePDF (FUNC2 (negative_binomial));
testDiscretePDF (FUNC2 (pascal));
gsl_rng_free (r_global);
gsl_ran_discrete_free (g1);
gsl_ran_discrete_free (g2);
gsl_ran_discrete_free (g3);
exit (gsl_test_summary ());
}
int
main (void)
{
size_t M = 53;
size_t N = 107;
gsl_ieee_env_setup ();
test_func (M, N);
test_float_func (M, N);
test_long_double_func (M, N);
test_ulong_func (M, N);
test_long_func (M, N);
test_uint_func (M, N);
test_int_func (M, N);
test_ushort_func (M, N);
test_short_func (M, N);
test_uchar_func (M, N);
test_char_func (M, N);
test_complex_func (M, N);
test_complex_float_func (M, N);
test_complex_long_double_func (M, N);
test_ops (M, N);
test_float_ops (M, N);
test_long_double_ops (M, N);
test_ulong_ops (M, N);
test_long_ops (M, N);
test_uint_ops (M, N);
test_int_ops (M, N);
test_ushort_ops (M, N);
test_short_ops (M, N);
test_uchar_ops (M, N);
test_char_ops (M, N);
/* Must use smaller dimensions to prevent approximation of floats in
float_mul_elements test*/
{
const size_t P = 8;
const size_t Q = 12;
test_complex_ops (P, Q);
test_complex_float_ops (P, Q);
test_complex_long_double_ops (P, Q);
}
test_text (M, N);
test_float_text (M, N);
#if HAVE_PRINTF_LONGDOUBLE
test_long_double_text (M, N);
#endif
test_ulong_text (M, N);
test_long_text (M, N);
test_uint_text (M, N);
test_int_text (M, N);
test_ushort_text (M, N);
test_short_text (M, N);
test_uchar_text (M, N);
test_char_text (M, N);
test_complex_text (M, N);
test_complex_float_text (M, N);
#if HAVE_PRINTF_LONGDOUBLE
test_complex_long_double_text (M, N);
#endif
test_binary (M, N);
test_float_binary (M, N);
test_long_double_binary (M, N);
test_ulong_binary (M, N);
test_long_binary (M, N);
test_uint_binary (M, N);
test_int_binary (M, N);
test_ushort_binary (M, N);
test_short_binary (M, N);
test_uchar_binary (M, N);
test_char_binary (M, N);
test_complex_binary (M, N);
test_complex_float_binary (M, N);
test_complex_long_double_binary (M, N);
test_binary_noncontiguous (M, N);
test_float_binary_noncontiguous (M, N);
test_long_double_binary_noncontiguous (M, N);
test_ulong_binary_noncontiguous (M, N);
test_long_binary_noncontiguous (M, N);
test_uint_binary_noncontiguous (M, N);
test_int_binary_noncontiguous (M, N);
test_ushort_binary_noncontiguous (M, N);
test_short_binary_noncontiguous (M, N);
test_uchar_binary_noncontiguous (M, N);
test_char_binary_noncontiguous (M, N);
test_complex_binary_noncontiguous (M, N);
test_complex_float_binary_noncontiguous (M, N);
test_complex_long_double_binary_noncontiguous (M, N);
#if GSL_RANGE_CHECK
gsl_set_error_handler (&my_error_handler);
test_trap (M, N);
test_float_trap (M, N);
test_long_double_trap (M, N);
test_ulong_trap (M, N);
test_long_trap (M, N);
test_uint_trap (M, N);
test_int_trap (M, N);
test_ushort_trap (M, N);
test_short_trap (M, N);
test_uchar_trap (M, N);
test_char_trap (M, N);
test_complex_trap (M, N);
test_complex_float_trap (M, N);
test_complex_long_double_trap (M, N);
#endif
exit (gsl_test_summary ());
}
int
main (void)
{
gsl_ieee_env_setup ();
test_func ();
test_float_func ();
test_long_double_func ();
test_ulong_func ();
test_long_func ();
test_uint_func ();
test_int_func ();
test_ushort_func ();
test_short_func ();
test_uchar_func ();
test_char_func ();
test_complex_func ();
test_complex_float_func ();
test_complex_long_double_func ();
test_text ();
test_float_text ();
#if HAVE_PRINTF_LONGDOUBLE
test_long_double_text ();
#endif
test_ulong_text ();
test_long_text ();
test_uint_text ();
test_int_text ();
test_ushort_text ();
test_short_text ();
test_uchar_text ();
test_char_text ();
test_complex_text ();
test_complex_float_text ();
#if HAVE_PRINTF_LONGDOUBLE
test_complex_long_double_text ();
#endif
test_binary ();
test_float_binary ();
test_long_double_binary ();
test_ulong_binary ();
test_long_binary ();
test_uint_binary ();
test_int_binary ();
test_ushort_binary ();
test_short_binary ();
test_uchar_binary ();
test_char_binary ();
test_complex_binary ();
test_complex_float_binary ();
test_complex_long_double_binary ();
#if GSL_RANGE_CHECK
gsl_set_error_handler (&my_error_handler);
test_trap ();
test_float_trap ();
test_long_double_trap ();
test_ulong_trap ();
test_long_trap ();
test_uint_trap ();
test_int_trap ();
test_ushort_trap ();
test_short_trap ();
test_uchar_trap ();
test_char_trap ();
test_complex_trap ();
test_complex_float_trap ();
test_complex_long_double_trap ();
#endif
test_complex_arith ();
test_complex_float_arith ();
test_complex_long_double_arith ();
exit (gsl_test_summary ());
}
int
main (void)
{
gsl_ieee_env_setup ();
{
double t[N];
int n;
const double zeta_2 = M_PI * M_PI / 6.0;
/* terms for zeta(2) */
for (n = 0; n < N; n++)
{
double np1 = n + 1.0;
t[n] = 1.0 / (np1 * np1);
}
check_trunc (t, zeta_2, "zeta(2)");
check_full (t, zeta_2, "zeta(2)");
}
{
double t[N];
double x, y;
int n;
/* terms for exp(10.0) */
x = 10.0;
y = exp(x);
t[0] = 1.0;
for (n = 1; n < N; n++)
{
t[n] = t[n - 1] * (x / n);
}
check_trunc (t, y, "exp(10)");
check_full (t, y, "exp(10)");
}
{
double t[N];
double x, y;
int n;
/* terms for exp(-10.0) */
x = -10.0;
y = exp(x);
t[0] = 1.0;
for (n = 1; n < N; n++)
{
t[n] = t[n - 1] * (x / n);
}
check_trunc (t, y, "exp(-10)");
check_full (t, y, "exp(-10)");
}
{
double t[N];
double x, y;
int n;
/* terms for -log(1-x) */
x = 0.5;
y = -log(1-x);
t[0] = x;
for (n = 1; n < N; n++)
{
t[n] = t[n - 1] * (x * n) / (n + 1.0);
}
check_trunc (t, y, "-log(1/2)");
check_full (t, y, "-log(1/2)");
}
{
double t[N];
double x, y;
int n;
/* terms for -log(1-x) */
x = -1.0;
y = -log(1-x);
t[0] = x;
for (n = 1; n < N; n++)
{
t[n] = t[n - 1] * (x * n) / (n + 1.0);
}
check_trunc (t, y, "-log(2)");
check_full (t, y, "-log(2)");
}
{
double t[N];
int n;
double result = 0.192594048773;
/* terms for an alternating asymptotic series */
t[0] = 3.0 / (M_PI * M_PI);
for (n = 1; n < N; n++)
{
t[n] = -t[n - 1] * (4.0 * (n + 1.0) - 1.0) / (M_PI * M_PI);
}
check_trunc (t, result, "asymptotic series");
check_full (t, result, "asymptotic series");
}
{
double t[N];
int n;
/* Euler's gamma from GNU Calc (precision = 32) */
double result = 0.5772156649015328606065120900824;
/* terms for Euler's gamma */
t[0] = 1.0;
for (n = 1; n < N; n++)
{
t[n] = 1/(n+1.0) + log(n/(n+1.0));
}
check_trunc (t, result, "Euler's constant");
check_full (t, result, "Euler's constant");
}
{
double t[N];
int n;
/* eta(1/2) = sum_{k=1}^{\infty} (-1)^(k+1) / sqrt(k)
From Levin, Intern. J. Computer Math. B3:371--388, 1973.
I=(1-sqrt(2))zeta(1/2)
=(2/sqrt(pi))*integ(1/(exp(x^2)+1),x,0,inf) */
double result = 0.6048986434216305; /* approx */
/* terms for eta(1/2) */
for (n = 0; n < N; n++)
{
t[n] = (n%2 ? -1 : 1) * 1.0 /sqrt(n + 1.0);
}
check_trunc (t, result, "eta(1/2)");
check_full (t, result, "eta(1/2)");
}
{
double t[N];
int n;
double result = 1.23;
for (n = 0; n < N; n++)
{
t[n] = (n == 0) ? 1.23 : 0.0;
}
check_trunc (t, result, "1.23 + 0 + 0 + 0...");
check_full (t, result, "1.23 + 0 + 0 + 0...");
}
exit (gsl_test_summary ());
}
int
main (void)
{
gsl_histogram *h;
double result, lower, upper;
size_t i;
gsl_set_error_handler (&my_error_handler);
gsl_ieee_env_setup ();
status = 0;
h = gsl_histogram_calloc (0);
gsl_test (!status, "gsl_histogram_calloc traps zero-length histogram");
gsl_test (h != 0,
"gsl_histogram_calloc returns NULL for zero-length histogram");
status = 0;
h = gsl_histogram_calloc_uniform (0, 0.0, 1.0);
gsl_test (!status,
"gsl_histogram_calloc_uniform traps zero-length histogram");
gsl_test (h != 0,
"gsl_histogram_calloc_uniform returns NULL for zero-length histogram");
status = 0;
h = gsl_histogram_calloc_uniform (10, 1.0, 1.0);
gsl_test (!status,
"gsl_histogram_calloc_uniform traps equal endpoints");
gsl_test (h != 0,
"gsl_histogram_calloc_uniform returns NULL for equal endpoints");
status = 0;
h = gsl_histogram_calloc_uniform (10, 2.0, 1.0);
gsl_test (!status,
"gsl_histogram_calloc_uniform traps invalid range");
gsl_test (h != 0,
"gsl_histogram_calloc_uniform returns NULL for invalid range");
h = gsl_histogram_calloc_uniform (N, 0.0, 1.0);
status = gsl_histogram_accumulate (h, 1.0, 10.0);
gsl_test (status != GSL_EDOM, "gsl_histogram_accumulate traps x at xmax");
status = gsl_histogram_accumulate (h, 2.0, 100.0);
gsl_test (status != GSL_EDOM, "gsl_histogram_accumulate traps x above xmax");
status = gsl_histogram_accumulate (h, -1.0, 1000.0);
gsl_test (status != GSL_EDOM, "gsl_histogram_accumulate traps x below xmin");
status = gsl_histogram_increment (h, 1.0);
gsl_test (status != GSL_EDOM, "gsl_histogram_increment traps x at xmax");
status = gsl_histogram_increment (h, 2.0);
gsl_test (status != GSL_EDOM, "gsl_histogram_increment traps x above xmax");
status = gsl_histogram_increment (h, -1.0);
gsl_test (status != GSL_EDOM, "gsl_histogram_increment traps x below xmin");
result = gsl_histogram_get (h, N);
gsl_test (result != 0, "gsl_histogram_get traps index at n");
result = gsl_histogram_get (h, N + 1);
gsl_test (result != 0, "gsl_histogram_get traps index above n");
status = gsl_histogram_get_range (h, N, &lower, &upper);
gsl_test (status != GSL_EDOM,
"gsl_histogram_get_range traps index at n");
status = gsl_histogram_get_range (h, N + 1, &lower, &upper);
gsl_test (status != GSL_EDOM,
"gsl_histogram_get_range traps index above n");
status = 0;
gsl_histogram_find (h, -0.01, &i);
gsl_test (status != GSL_EDOM, "gsl_histogram_find traps x below xmin");
status = 0;
gsl_histogram_find (h, 1.0, &i);
gsl_test (status != GSL_EDOM, "gsl_histogram_find traps x at xmax");
status = 0;
gsl_histogram_find (h, 1.1, &i);
gsl_test (status != GSL_EDOM, "gsl_histogram_find traps x above xmax");
gsl_histogram_free (h);
exit (gsl_test_summary ());
}
int
main (void)
{
/* sample sets of integers */
const unsigned int ina = 20, inb = 20;
const int test1[] = {1, 2, 3, 4, 5, 6} ;
const int igroupa[] =
{17, 18, 16, 18, 12,
20, 18, 20, 20, 22,
20, 10, 8, 12, 16,
16, 18, 20, 18, 21};
const int igroupb[] =
{19, 20, 22, 24, 10,
25, 20, 22, 21, 23,
20, 10, 12, 14, 12,
20, 22, 24, 23, 17};
int * sorted ;
{
double mean = gsl_stats_int_mean (igroupa, ina);
double expected = 17.0;
gsl_test (!within_fuzz(mean,expected),
"gsl_stats_int_mean (integer) (%g observed vs %g expected)",
mean, expected);
}
{
double mean = gsl_stats_int_mean (test1, 6);
double expected = 3.5;
gsl_test (!within_fuzz(mean,expected),
"gsl_stats_int_mean (fractional) (%g observed vs %g expected)",
mean, expected);
}
{
double var = gsl_stats_int_variance (igroupa, ina);
double expected = 13.7;
gsl_test (!within_fuzz (var, expected),
"gsl_stats_int_variance (%g observed vs %g expected)",
var, expected);
}
{
double var = gsl_stats_int_est_variance (igroupa, ina);
double expected = 14.4210526315789;
gsl_test (!within_fuzz (var, expected),
"gsl_stats_int_est_variance (%g observed vs %g expected)",
var, expected);
}
{
double sd = gsl_stats_int_sd (igroupa, ina);
double expected = 3.70135110466435;
gsl_test (!within_fuzz (sd, expected),
"gsl_stats_int_sd (%g observed vs %g expected)",
sd, expected);
}
{
double sd_est = gsl_stats_int_est_sd (igroupa, ina);
double expected = 3.79750610685209;
gsl_test (!within_fuzz (sd_est, expected),
"gsl_stats_int_est_sd (%g observed vs %g expected)",
sd_est, expected);
}
{
double absdev = gsl_stats_int_absdev (igroupa, ina);
double expected = 2.9;
gsl_test (!within_fuzz (absdev, expected),
"gsl_stats_int_absdev (%g observed vs %g expected)",
absdev, expected);
}
{
double skew = gsl_stats_int_skew (igroupa, ina);
double expected = -0.909355923168064;
gsl_test (!within_fuzz (skew, expected),
"gsl_stats_int_skew (%g observed vs %g expected)",
skew, expected);
}
{
double kurt = gsl_stats_int_kurtosis (igroupa, ina);
double expected = -0.233692524908094 ;
gsl_test (!within_fuzz (kurt, expected),
"gsl_stats_int_kurtosis (%g observed vs %g expected)",
kurt, expected);
}
{
double pv = gsl_stats_int_pvariance (igroupa, igroupb, ina, inb);
double expected = 18.8421052631579;
gsl_test (!within_fuzz (pv, expected),
"gsl_stats_int_pvariance (%g observed vs %g expected)",
pv, expected);
}
{
double t = gsl_stats_int_ttest (igroupa, igroupb, ina, inb);
double expected = -1.45701922702927;
gsl_test (!within_fuzz (t, expected),
"gsl_stats_int_ttest (%g observed vs %g expected)",
t, expected);
}
{
int max = gsl_stats_int_max (igroupa, ina);
int expected = 22;
gsl_test (max != expected,
"gsl_stats_int_max (%d observed vs %d expected)", max, expected);
}
{
int min = gsl_stats_int_min (igroupa, inb);
int expected = 8;
gsl_test (min != expected,
"gsl_stats_int_min (%d observed vs %d expected)", min, expected);
}
{
int max_index = gsl_stats_int_max_index (igroupa, ina);
int expected = 9 ;
gsl_test (max_index != expected,
"gsl_stats_int_max_index (%d observed vs %d expected)",
max_index, expected);
}
{
int min_index = gsl_stats_int_min_index (igroupa, inb);
int expected = 12 ;
gsl_test (min_index != expected,
"gsl_stats_int_min_index (%d observed vs %d expected)",
min_index, expected);
}
sorted = (int *) malloc(ina * sizeof(int)) ;
memcpy(sorted, igroupa, ina * sizeof(int)) ;
gsl_stats_int_sort_data(sorted, ina) ;
{
double median = gsl_stats_int_median_from_sorted_data(sorted, ina) ;
double expected = 18;
gsl_test (!within_fuzz(median,expected),
"gsl_stats_int_median_from_sorted_data (even) (%g observed vs %g expected)",
median, expected);
}
{
double median = gsl_stats_int_median_from_sorted_data(sorted, ina - 1) ;
double expected = 18;
gsl_test (!within_fuzz(median,expected),
"gsl_stats_int_median_from_sorted_data (odd) (%g observed vs %g expected)",
median, expected);
}
{
double zeroth = gsl_stats_int_quantile_from_sorted_data(sorted, ina, 0.0) ;
double expected = 8;
gsl_test (!within_fuzz(zeroth,expected),
"gsl_stats_quantile_from_sorted_data (0) (%g observed vs %g expected)",
zeroth, expected);
}
{
double top = gsl_stats_int_quantile_from_sorted_data(sorted, ina, 1.0) ;
double expected = 22;
gsl_test (!within_fuzz(top,expected),
"gsl_stats_int_quantile_from_sorted_data (100) (%g obs vs %g exp)",
top, expected);
}
{
double median = gsl_stats_int_quantile_from_sorted_data(sorted, ina, 0.5) ;
double expected = 18;
gsl_test (!within_fuzz(median,expected),
"gsl_stats_int_quantile_from_sorted_data (50, even) (%g obs vs %g exp)",
median, expected);
}
{
double median = gsl_stats_int_quantile_from_sorted_data(sorted, ina - 1, 0.5);
double expected = 18;
gsl_test (!within_fuzz(median,expected),
"gsl_stats_int_quantile_from_sorted_data (50, odd) (%g obs vs %g exp)",
median, expected);
}
exit (gsl_test_summary ());
}
int
main (void)
{
const double eps = 100.0 * GSL_DBL_EPSILON;
gsl_ieee_env_setup ();
{
double x, y;
double c[3] = { 1.0, 0.5, 0.3 };
x = 0.5;
y = gsl_poly_eval (c, 3, x);
gsl_test_rel (y, 1 + 0.5 * x + 0.3 * x * x, eps,
"gsl_poly_eval({1, 0.5, 0.3}, 0.5)");
}
{
double x, y;
double d[11] = { 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1 };
x = 1.0;
y = gsl_poly_eval (d, 11, x);
gsl_test_rel (y, 1.0, eps,
"gsl_poly_eval({1,-1, 1, -1, 1, -1, 1, -1, 1, -1, 1}, 1.0)");
}
/* Quadratic */
{
double x0, x1;
int n = gsl_poly_solve_quadratic (4.0, -20.0, 26.0, &x0, &x1);
gsl_test (n != 0, "gsl_poly_solve_quadratic, no roots, (2x - 5)^2 = -1");
}
{
double x0, x1;
int n = gsl_poly_solve_quadratic (4.0, -20.0, 25.0, &x0, &x1);
gsl_test (n != 2, "gsl_poly_solve_quadratic, one root, (2x - 5)^2 = 0");
gsl_test_rel (x0, 2.5, 1e-9, "x0, (2x - 5)^2 = 0");
gsl_test_rel (x1, 2.5, 1e-9, "x1, (2x - 5)^2 = 0");
gsl_test (x0 != x1, "x0 == x1, (2x - 5)^2 = 0");
}
{
double x0, x1;
int n = gsl_poly_solve_quadratic (4.0, -20.0, 21.0, &x0, &x1);
gsl_test (n != 2, "gsl_poly_solve_quadratic, two roots, (2x - 5)^2 = 4");
gsl_test_rel (x0, 1.5, 1e-9, "x0, (2x - 5)^2 = 4");
gsl_test_rel (x1, 3.5, 1e-9, "x1, (2x - 5)^2 = 4");
}
{
double x0, x1;
int n = gsl_poly_solve_quadratic (4.0, 7.0, 0.0, &x0, &x1);
gsl_test (n != 2, "gsl_poly_solve_quadratic, two roots, x(4x + 7) = 0");
gsl_test_rel (x0, -1.75, 1e-9, "x0, x(4x + 7) = 0");
gsl_test_rel (x1, 0.0, 1e-9, "x1, x(4x + 7) = 0");
}
{
double x0, x1;
int n = gsl_poly_solve_quadratic (5.0, 0.0, -20.0, &x0, &x1);
gsl_test (n != 2,
"gsl_poly_solve_quadratic, two roots b = 0, 5 x^2 = 20");
gsl_test_rel (x0, -2.0, 1e-9, "x0, 5 x^2 = 20");
gsl_test_rel (x1, 2.0, 1e-9, "x1, 5 x^2 = 20");
}
/* Cubic */
{
double x0, x1, x2;
int n = gsl_poly_solve_cubic (0.0, 0.0, -27.0, &x0, &x1, &x2);
gsl_test (n != 1, "gsl_poly_solve_cubic, one root, x^3 = 27");
gsl_test_rel (x0, 3.0, 1e-9, "x0, x^3 = 27");
}
{
double x0, x1, x2;
int n = gsl_poly_solve_cubic (-51.0, 867.0, -4913.0, &x0, &x1, &x2);
gsl_test (n != 3, "gsl_poly_solve_cubic, three roots, (x-17)^3=0");
gsl_test_rel (x0, 17.0, 1e-9, "x0, (x-17)^3=0");
gsl_test_rel (x1, 17.0, 1e-9, "x1, (x-17)^3=0");
gsl_test_rel (x2, 17.0, 1e-9, "x2, (x-17)^3=0");
}
{
double x0, x1, x2;
int n = gsl_poly_solve_cubic (-57.0, 1071.0, -6647.0, &x0, &x1, &x2);
gsl_test (n != 3,
"gsl_poly_solve_cubic, three roots, (x-17)(x-17)(x-23)=0");
gsl_test_rel (x0, 17.0, 1e-9, "x0, (x-17)(x-17)(x-23)=0");
gsl_test_rel (x1, 17.0, 1e-9, "x1, (x-17)(x-17)(x-23)=0");
gsl_test_rel (x2, 23.0, 1e-9, "x2, (x-17)(x-17)(x-23)=0");
}
{
double x0, x1, x2;
int n = gsl_poly_solve_cubic (-11.0, -493.0, +6647.0, &x0, &x1, &x2);
gsl_test (n != 3,
"gsl_poly_solve_cubic, three roots, (x+23)(x-17)(x-17)=0");
gsl_test_rel (x0, -23.0, 1e-9, "x0, (x+23)(x-17)(x-17)=0");
gsl_test_rel (x1, 17.0, 1e-9, "x1, (x+23)(x-17)(x-17)=0");
gsl_test_rel (x2, 17.0, 1e-9, "x2, (x+23)(x-17)(x-17)=0");
}
{
double x0, x1, x2;
int n = gsl_poly_solve_cubic (-143.0, 5087.0, -50065.0, &x0, &x1, &x2);
gsl_test (n != 3,
"gsl_poly_solve_cubic, three roots, (x-17)(x-31)(x-95)=0");
gsl_test_rel (x0, 17.0, 1e-9, "x0, (x-17)(x-31)(x-95)=0");
gsl_test_rel (x1, 31.0, 1e-9, "x1, (x-17)(x-31)(x-95)=0");
gsl_test_rel (x2, 95.0, 1e-9, "x2, (x-17)(x-31)(x-95)=0");
}
{
double x0, x1, x2;
int n = gsl_poly_solve_cubic (-109.0, 803.0, 50065.0, &x0, &x1, &x2);
gsl_test (n != 3,
"gsl_poly_solve_cubic, three roots, (x+17)(x-31)(x-95)=0");
gsl_test_rel (x0, -17.0, 1e-9, "x0, (x+17)(x-31)(x-95)=0");
gsl_test_rel (x1, 31.0, 1e-9, "x1, (x+17)(x-31)(x-95)=0");
gsl_test_rel (x2, 95.0, 1e-9, "x2, (x+17)(x-31)(x-95)=0");
}
/* Quadratic with complex roots */
{
gsl_complex z0, z1;
int n = gsl_poly_complex_solve_quadratic (4.0, -20.0, 26.0, &z0, &z1);
gsl_test (n != 2,
"gsl_poly_complex_solve_quadratic, 2 roots (2x - 5)^2 = -1");
gsl_test_rel (GSL_REAL (z0), 2.5, 1e-9, "z0.real, (2x - 5)^2 = -1");
gsl_test_rel (GSL_IMAG (z0), -0.5, 1e-9, "z0.imag, (2x - 5)^2 = -1");
gsl_test_rel (GSL_REAL (z1), 2.5, 1e-9, "z1.real, (2x - 5)^2 = -1");
gsl_test_rel (GSL_IMAG (z1), 0.5, 1e-9, "z1.imag, (2x - 5)^2 = -1");
}
{
gsl_complex z0, z1;
int n = gsl_poly_complex_solve_quadratic (4.0, -20.0, 25.0, &z0, &z1);
gsl_test (n != 2,
"gsl_poly_complex_solve_quadratic, one root, (2x - 5)^2 = 0");
gsl_test_rel (GSL_REAL (z0), 2.5, 1e-9, "z0.real, (2x - 5)^2 = 0");
gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag (2x - 5)^2 = 0");
gsl_test_rel (GSL_REAL (z1), 2.5, 1e-9, "z1.real, (2x - 5)^2 = 0");
gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag (2x - 5)^2 = 0");
gsl_test (GSL_REAL (z0) != GSL_REAL (z1),
"z0.real == z1.real, (2x - 5)^2 = 0");
gsl_test (GSL_IMAG (z0) != GSL_IMAG (z1),
"z0.imag == z1.imag, (2x - 5)^2 = 0");
}
{
gsl_complex z0, z1;
int n = gsl_poly_complex_solve_quadratic (4.0, -20.0, 21.0, &z0, &z1);
gsl_test (n != 2,
"gsl_poly_complex_solve_quadratic, two roots, (2x - 5)^2 = 4");
gsl_test_rel (GSL_REAL (z0), 1.5, 1e-9, "z0.real, (2x - 5)^2 = 4");
gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (2x - 5)^2 = 4");
gsl_test_rel (GSL_REAL (z1), 3.5, 1e-9, "z1.real, (2x - 5)^2 = 4");
gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, (2x - 5)^2 = 4");
}
{
gsl_complex z0, z1;
int n = gsl_poly_complex_solve_quadratic (4.0, 7.0, 0.0, &z0, &z1);
gsl_test (n != 2,
"gsl_poly_complex_solve_quadratic, two roots, x(4x + 7) = 0");
gsl_test_rel (GSL_REAL (z0), -1.75, 1e-9, "z0.real, x(4x + 7) = 0");
gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, x(4x + 7) = 0");
gsl_test_rel (GSL_REAL (z1), 0.0, 1e-9, "z1.real, x(4x + 7) = 0");
gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, x(4x + 7) = 0");
}
{
gsl_complex z0, z1;
int n = gsl_poly_complex_solve_quadratic (5.0, 0.0, -20.0, &z0, &z1);
gsl_test (n != 2,
"gsl_poly_complex_solve_quadratic, two roots b = 0, 5 x^2 = 20");
gsl_test_rel (GSL_REAL (z0), -2.0, 1e-9, "z0.real, 5 x^2 = 20");
gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, 5 x^2 = 20");
gsl_test_rel (GSL_REAL (z1), 2.0, 1e-9, "z1.real, 5 x^2 = 20");
gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, 5 x^2 = 20");
}
{
gsl_complex z0, z1;
int n = gsl_poly_complex_solve_quadratic (5.0, 0.0, 20.0, &z0, &z1);
gsl_test (n != 2,
"gsl_poly_complex_solve_quadratic, two roots b = 0, 5 x^2 = -20");
gsl_test_rel (GSL_REAL (z0), 0.0, 1e-9, "z0.real, 5 x^2 = -20");
gsl_test_rel (GSL_IMAG (z0), -2.0, 1e-9, "z0.imag, 5 x^2 = -20");
gsl_test_rel (GSL_REAL (z1), 0.0, 1e-9, "z1.real, 5 x^2 = -20");
gsl_test_rel (GSL_IMAG (z1), 2.0, 1e-9, "z1.imag, 5 x^2 = -20");
}
/* Cubic with complex roots */
{
gsl_complex z0, z1, z2;
int n = gsl_poly_complex_solve_cubic (0.0, 0.0, -27.0, &z0, &z1, &z2);
gsl_test (n != 3, "gsl_poly_complex_solve_cubic, three root, x^3 = 27");
gsl_test_rel (GSL_REAL (z0), -1.5, 1e-9, "z0.real, x^3 = 27");
gsl_test_rel (GSL_IMAG (z0), -1.5 * sqrt (3.0), 1e-9,
"z0.imag, x^3 = 27");
gsl_test_rel (GSL_REAL (z1), -1.5, 1e-9, "z1.real, x^3 = 27");
gsl_test_rel (GSL_IMAG (z1), 1.5 * sqrt (3.0), 1e-9, "z1.imag, x^3 = 27");
gsl_test_rel (GSL_REAL (z2), 3.0, 1e-9, "z2.real, x^3 = 27");
gsl_test_rel (GSL_IMAG (z2), 0.0, 1e-9, "z2.imag, x^3 = 27");
}
{
gsl_complex z0, z1, z2;
int n = gsl_poly_complex_solve_cubic (-1.0, 1.0, 39.0, &z0, &z1, &z2);
gsl_test (n != 3,
"gsl_poly_complex_solve_cubic, three root, (x+3)(x^2-4x+13) = 0");
gsl_test_rel (GSL_REAL (z0), -3.0, 1e-9, "z0.real, (x+3)(x^2+1) = 0");
gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (x+3)(x^2+1) = 0");
gsl_test_rel (GSL_REAL (z1), 2.0, 1e-9, "z1.real, (x+3)(x^2+1) = 0");
gsl_test_rel (GSL_IMAG (z1), -3.0, 1e-9, "z1.imag, (x+3)(x^2+1) = 0");
gsl_test_rel (GSL_REAL (z2), 2.0, 1e-9, "z2.real, (x+3)(x^2+1) = 0");
gsl_test_rel (GSL_IMAG (z2), 3.0, 1e-9, "z2.imag, (x+3)(x^2+1) = 0");
}
{
gsl_complex z0, z1, z2;
int n =
gsl_poly_complex_solve_cubic (-51.0, 867.0, -4913.0, &z0, &z1, &z2);
gsl_test (n != 3,
"gsl_poly_complex_solve_cubic, three roots, (x-17)^3=0");
gsl_test_rel (GSL_REAL (z0), 17.0, 1e-9, "z0.real, (x-17)^3=0");
gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (x-17)^3=0");
gsl_test_rel (GSL_REAL (z1), 17.0, 1e-9, "z1.real, (x-17)^3=0");
gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, (x-17)^3=0");
gsl_test_rel (GSL_REAL (z2), 17.0, 1e-9, "z2.real, (x-17)^3=0");
gsl_test_rel (GSL_IMAG (z2), 0.0, 1e-9, "z2.imag, (x-17)^3=0");
}
{
gsl_complex z0, z1, z2;
int n =
gsl_poly_complex_solve_cubic (-57.0, 1071.0, -6647.0, &z0, &z1, &z2);
gsl_test (n != 3,
"gsl_poly_complex_solve_cubic, three roots, (x-17)(x-17)(x-23)=0");
gsl_test_rel (GSL_REAL (z0), 17.0, 1e-9, "z0.real, (x-17)(x-17)(x-23)=0");
gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (x-17)(x-17)(x-23)=0");
gsl_test_rel (GSL_REAL (z1), 17.0, 1e-9, "z1.real, (x-17)(x-17)(x-23)=0");
gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, (x-17)(x-17)(x-23)=0");
gsl_test_rel (GSL_REAL (z2), 23.0, 1e-9, "z2.real, (x-17)(x-17)(x-23)=0");
gsl_test_rel (GSL_IMAG (z2), 0.0, 1e-9, "z2.imag, (x-17)(x-17)(x-23)=0");
}
{
gsl_complex z0, z1, z2;
int n =
gsl_poly_complex_solve_cubic (-11.0, -493.0, +6647.0, &z0, &z1, &z2);
gsl_test (n != 3,
"gsl_poly_complex_solve_cubic, three roots, (x+23)(x-17)(x-17)=0");
gsl_test_rel (GSL_REAL (z0), -23.0, 1e-9,
"z0.real, (x+23)(x-17)(x-17)=0");
gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (x+23)(x-17)(x-17)=0");
gsl_test_rel (GSL_REAL (z1), 17.0, 1e-9, "z1.real, (x+23)(x-17)(x-17)=0");
gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, (x+23)(x-17)(x-17)=0");
gsl_test_rel (GSL_REAL (z2), 17.0, 1e-9, "z2.real, (x+23)(x-17)(x-17)=0");
gsl_test_rel (GSL_IMAG (z2), 0.0, 1e-9, "z2.imag, (x+23)(x-17)(x-17)=0");
}
{
gsl_complex z0, z1, z2;
int n =
gsl_poly_complex_solve_cubic (-143.0, 5087.0, -50065.0, &z0, &z1, &z2);
gsl_test (n != 3,
"gsl_poly_complex_solve_cubic, three roots, (x-17)(x-31)(x-95)=0");
gsl_test_rel (GSL_REAL (z0), 17.0, 1e-9, "z0.real, (x-17)(x-31)(x-95)=0");
gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (x-17)(x-31)(x-95)=0");
gsl_test_rel (GSL_REAL (z1), 31.0, 1e-9, "z1.real, (x-17)(x-31)(x-95)=0");
gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, (x-17)(x-31)(x-95)=0");
gsl_test_rel (GSL_REAL (z2), 95.0, 1e-9, "z2.real, (x-17)(x-31)(x-95)=0");
gsl_test_rel (GSL_IMAG (z2), 0.0, 1e-9, "z2.imag, (x-17)(x-31)(x-95)=0");
}
{
/* Wilkinson polynomial: y = (x-1)(x-2)(x-3)(x-4)(x-5) */
double a[6] = { -120, 274, -225, 85, -15, 1 };
double z[6*2];
gsl_poly_complex_workspace *w = gsl_poly_complex_workspace_alloc (6);
int status = gsl_poly_complex_solve (a, 6, w, z);
gsl_poly_complex_workspace_free (w);
gsl_test (status,
"gsl_poly_complex_solve, 5th-order Wilkinson polynomial");
gsl_test_rel (z[0], 1.0, 1e-9, "z0.real, 5th-order polynomial");
gsl_test_rel (z[1], 0.0, 1e-9, "z0.imag, 5th-order polynomial");
gsl_test_rel (z[2], 2.0, 1e-9, "z1.real, 5th-order polynomial");
gsl_test_rel (z[3], 0.0, 1e-9, "z1.imag, 5th-order polynomial");
gsl_test_rel (z[4], 3.0, 1e-9, "z2.real, 5th-order polynomial");
gsl_test_rel (z[5], 0.0, 1e-9, "z2.imag, 5th-order polynomial");
gsl_test_rel (z[6], 4.0, 1e-9, "z3.real, 5th-order polynomial");
gsl_test_rel (z[7], 0.0, 1e-9, "z3.imag, 5th-order polynomial");
gsl_test_rel (z[8], 5.0, 1e-9, "z4.real, 5th-order polynomial");
gsl_test_rel (z[9], 0.0, 1e-9, "z4.imag, 5th-order polynomial");
}
{
/* : 8-th order polynomial y = x^8 + x^4 + 1 */
double a[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
double z[8*2];
double C = 0.5;
double S = sqrt (3.0) / 2.0;
gsl_poly_complex_workspace *w = gsl_poly_complex_workspace_alloc (9);
int status = gsl_poly_complex_solve (a, 9, w, z);
gsl_poly_complex_workspace_free (w);
gsl_test (status, "gsl_poly_complex_solve, 8th-order polynomial");
gsl_test_rel (z[0], -S, 1e-9, "z0.real, 8th-order polynomial");
gsl_test_rel (z[1], C, 1e-9, "z0.imag, 8th-order polynomial");
gsl_test_rel (z[2], -S, 1e-9, "z1.real, 8th-order polynomial");
gsl_test_rel (z[3], -C, 1e-9, "z1.imag, 8th-order polynomial");
gsl_test_rel (z[4], -C, 1e-9, "z2.real, 8th-order polynomial");
gsl_test_rel (z[5], S, 1e-9, "z2.imag, 8th-order polynomial");
gsl_test_rel (z[6], -C, 1e-9, "z3.real, 8th-order polynomial");
gsl_test_rel (z[7], -S, 1e-9, "z3.imag, 8th-order polynomial");
gsl_test_rel (z[8], C, 1e-9, "z4.real, 8th-order polynomial");
gsl_test_rel (z[9], S, 1e-9, "z4.imag, 8th-order polynomial");
gsl_test_rel (z[10], C, 1e-9, "z5.real, 8th-order polynomial");
gsl_test_rel (z[11], -S, 1e-9, "z5.imag, 8th-order polynomial");
gsl_test_rel (z[12], S, 1e-9, "z6.real, 8th-order polynomial");
gsl_test_rel (z[13], C, 1e-9, "z6.imag, 8th-order polynomial");
gsl_test_rel (z[14], S, 1e-9, "z7.real, 8th-order polynomial");
gsl_test_rel (z[15], -C, 1e-9, "z7.imag, 8th-order polynomial");
}
{
int i;
double xa[7] = {0.16, 0.97, 1.94, 2.74, 3.58, 3.73, 4.70 };
double ya[7] = {0.73, 1.11, 1.49, 1.84, 2.30, 2.41, 3.07 };
double dd_expected[7] = { 7.30000000000000e-01,
4.69135802469136e-01,
-4.34737219941284e-02,
2.68681098870099e-02,
-3.22937056934996e-03,
6.12763259971375e-03,
-6.45402453527083e-03 };
double dd[7], coeff[7], work[7];
gsl_poly_dd_init (dd, xa, ya, 7);
for (i = 0; i < 7; i++)
{
gsl_test_rel (dd[i], dd_expected[i], 1e-10, "divided difference dd[%d]", i);
}
for (i = 0; i < 7; i++)
{
double y = gsl_poly_dd_eval(dd, xa, 7, xa[i]);
gsl_test_rel (y, ya[i], 1e-10, "divided difference y[%d]", i);
}
gsl_poly_dd_taylor (coeff, 1.5, dd, xa, 7, work);
for (i = 0; i < 7; i++)
{
double y = gsl_poly_eval(coeff, 7, xa[i] - 1.5);
gsl_test_rel (y, ya[i], 1e-10, "taylor expansion about 1.5 y[%d]", i);
}
}
/* now summarize the results */
exit (gsl_test_summary ());
}
int
main (void)
{
gsl_ieee_env_setup ();
{
const gsl_multimin_fdfminimizer_type *fdfminimizers[6];
const gsl_multimin_fdfminimizer_type ** T;
fdfminimizers[0] = gsl_multimin_fdfminimizer_steepest_descent;
fdfminimizers[1] = gsl_multimin_fdfminimizer_conjugate_pr;
fdfminimizers[2] = gsl_multimin_fdfminimizer_conjugate_fr;
fdfminimizers[3] = gsl_multimin_fdfminimizer_vector_bfgs;
fdfminimizers[4] = gsl_multimin_fdfminimizer_vector_bfgs2;
fdfminimizers[5] = 0;
T = fdfminimizers;
while (*T != 0)
{
test_fdf("Roth", &roth, roth_initpt,*T);
test_fdf("Wood", &wood, wood_initpt,*T);
test_fdf("Rosenbrock", &rosenbrock, rosenbrock_initpt,*T);
T++;
}
T = fdfminimizers;
while (*T != 0)
{
test_fdf("NRoth", &Nroth, roth_initpt,*T);
test_fdf("NWood", &Nwood, wood_initpt,*T);
test_fdf("NRosenbrock", &Nrosenbrock, rosenbrock_initpt,*T);
T++;
}
}
{
const gsl_multimin_fminimizer_type *fminimizers[4];
const gsl_multimin_fminimizer_type ** T;
fminimizers[0] = gsl_multimin_fminimizer_nmsimplex;
fminimizers[1] = gsl_multimin_fminimizer_nmsimplex2;
fminimizers[2] = gsl_multimin_fminimizer_nmsimplex2rand;
fminimizers[3] = 0;
T = fminimizers;
while (*T != 0)
{
test_f("Roth", &roth_fmin, roth_initpt,*T);
test_f("Wood", &wood_fmin, wood_initpt,*T);
test_f("Rosenbrock", &rosenbrock_fmin, rosenbrock_initpt,*T);
test_f("Spring", &spring_fmin, spring_initpt,*T);
T++;
}
}
exit (gsl_test_summary());
}
int
main (void)
{
float zerof = 0.0f, minus_onef = -1.0f ;
double zero = 0.0, minus_one = -1.0 ;
/* Check for +ZERO (float) */
{
float f = 0.0f;
const char mantissa[] = "00000000000000000000000";
gsl_ieee_float_rep r;
gsl_ieee_float_to_rep (&f, &r);
gsl_test_int (r.sign, 0, "float x = 0, sign is +");
gsl_test_int (r.exponent, -127, "float x = 0, exponent is -127");
gsl_test_str (r.mantissa, mantissa, "float x = 0, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_ZERO, "float x = 0, type is ZERO");
}
/* Check for -ZERO (float) */
{
float f = minus_onef;
const char mantissa[] = "00000000000000000000000";
gsl_ieee_float_rep r;
while (f < 0) {
f *= 0.1f;
}
gsl_ieee_float_to_rep (&f, &r);
gsl_test_int (r.sign, 1, "float x = -1*0, sign is -");
gsl_test_int (r.exponent, -127, "float x = -1*0, exponent is -127");
gsl_test_str (r.mantissa, mantissa, "float x = -1*0, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_ZERO, "float x = -1*0, type is ZERO");
}
/* Check for a positive NORMAL number (e.g. 2.1) (float) */
{
float f = 2.1f;
const char mantissa[] = "00001100110011001100110";
gsl_ieee_float_rep r;
gsl_ieee_float_to_rep (&f, &r);
gsl_test_int (r.sign, 0, "float x = 2.1, sign is +");
gsl_test_int (r.exponent, 1, "float x = 2.1, exponent is 1");
gsl_test_str (r.mantissa, mantissa, "float x = 2.1, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL, "float x = 2.1, type is NORMAL");
}
/* Check for a negative NORMAL number (e.g. -1.3304...) (float) */
{
float f = -1.3303577090924210f ;
const char mantissa[] = "01010100100100100101001";
gsl_ieee_float_rep r;
gsl_ieee_float_to_rep (&f, &r);
gsl_test_int (r.sign, 1, "float x = -1.3304..., sign is -");
gsl_test_int (r.exponent, 0, "float x = -1.3304..., exponent is 0");
gsl_test_str (r.mantissa, mantissa, "float x = -1.3304..., mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL,
"float x = -1.3304..., type is NORMAL");
}
/* Check for a large positive NORMAL number (e.g. 3.37e31) (float) */
{
float f = 3.37e31f;
const char mantissa[] = "10101001010110101001001";
gsl_ieee_float_rep r;
gsl_ieee_float_to_rep (&f, &r);
gsl_test_int (r.sign, 0, "float x = 3.37e31, sign is +");
gsl_test_int (r.exponent, 104, "float x = 3.37e31, exponent is 104");
gsl_test_str (r.mantissa, mantissa, "float x = 3.37e31, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL, "float x = 3.37e31, type is NORMAL");
}
/* Check for a small positive NORMAL number (e.g. 3.37e-31) (float) */
{
float f = 3.37e-31f;
const char mantissa[] = "10110101011100110111011";
gsl_ieee_float_rep r;
gsl_ieee_float_to_rep (&f, &r);
gsl_test_int (r.sign, 0, "float x = 3.37e-31, sign is +");
gsl_test_int (r.exponent, -102, "float x = 3.37e-31, exponent is -102");
gsl_test_str (r.mantissa, mantissa, "float x = 3.37e-31, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL,
"float x = 3.37e-31, type is NORMAL");
}
/* Check for FLT_MIN (smallest possible number that is not denormal) */
{
float f = FLT_MIN;
const char mantissa[] = "00000000000000000000000";
gsl_ieee_float_rep r;
gsl_ieee_float_to_rep (&f, &r);
gsl_test_int (r.sign, 0, "float x = FLT_MIN, sign is +");
gsl_test_int (r.exponent, -126, "float x = FLT_MIN, exponent is -126");
gsl_test_str (r.mantissa, mantissa, "float x = FLT_MIN, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL, "float x = FLT_MIN, type is NORMAL");
}
/* Check for FLT_MAX (largest possible number that is not Inf) */
{
float f = FLT_MAX;
const char mantissa[] = "11111111111111111111111";
gsl_ieee_float_rep r;
gsl_ieee_float_to_rep (&f, &r);
gsl_test_int (r.sign, 0, "float x = FLT_MAX, sign is +");
gsl_test_int (r.exponent, 127, "float x = FLT_MAX, exponent is 127");
gsl_test_str (r.mantissa, mantissa, "float x = FLT_MAX, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL, "float x = FLT_MAX, type is NORMAL");
}
/* Check for DENORMAL numbers (e.g. FLT_MIN/2^n) */
#ifdef TEST_DENORMAL
{
float f = FLT_MIN;
char mantissa[] = "10000000000000000000000";
int i;
gsl_ieee_float_rep r;
for (i = 0; i < 23; i++)
{
float x = f / (float)pow (2.0, 1 + (float) i);
mantissa[i] = '1';
gsl_ieee_float_to_rep (&x, &r);
gsl_test_int (r.sign, 0, "float x = FLT_MIN/2^%d, sign is +", i + 1);
gsl_test_int (r.exponent, -127,
"float x = FLT_MIN/2^%d, exponent is -127", i + 1);
gsl_test_str (r.mantissa, mantissa,
"float x = FLT_MIN/2^%d, mantissa", i + 1);
gsl_test_int (r.type, GSL_IEEE_TYPE_DENORMAL,
"float x = FLT_MIN/2^%d, type is DENORMAL", i + 1);
mantissa[i] = '0';
}
}
#endif
/* Check for positive INFINITY (e.g. 2*FLT_MAX) */
{
float f = FLT_MAX;
const char mantissa[] = "00000000000000000000000";
gsl_ieee_float_rep r;
float x;
x = 2 * f;
gsl_ieee_float_to_rep (&x, &r);
gsl_test_int (r.sign, 0, "float x = 2*FLT_MAX, sign is +");
gsl_test_int (r.exponent, 128, "float x = 2*FLT_MAX, exponent is 128");
gsl_test_str (r.mantissa, mantissa, "float x = 2*FLT_MAX, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_INF, "float x = -2*FLT_MAX, type is INF");
}
/* Check for negative INFINITY (e.g. -2*FLT_MAX) */
{
float f = FLT_MAX;
const char mantissa[] = "00000000000000000000000";
gsl_ieee_float_rep r;
float x;
x = -2 * f;
gsl_ieee_float_to_rep (&x, &r);
gsl_test_int (r.sign, 1, "float x = -2*FLT_MAX, sign is -");
gsl_test_int (r.exponent, 128, "float x = -2*FLT_MAX, exponent is 128");
gsl_test_str (r.mantissa, mantissa, "float x = -2*FLT_MAX, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_INF, "float x = -2*FLT_MAX, type is INF");
}
/* Check for NAN (e.g. Inf - Inf) (float) */
{
gsl_ieee_float_rep r;
float x = 1.0f, y = 2.0f, z = zerof;
x = x / z;
y = y / z;
z = y - x;
gsl_ieee_float_to_rep (&z, &r);
/* We don't check the sign and we don't check the mantissa because
they could be anything for a NaN */
gsl_test_int (r.exponent, 128, "float x = NaN, exponent is 128");
gsl_test_int (r.type, GSL_IEEE_TYPE_NAN, "float x = NaN, type is NAN");
}
/* Check for +ZERO */
{
double d = 0.0;
const char mantissa[]
= "0000000000000000000000000000000000000000000000000000";
gsl_ieee_double_rep r;
gsl_ieee_double_to_rep (&d, &r);
gsl_test_int (r.sign, 0, "double x = 0, sign is +");
gsl_test_int (r.exponent, -1023, "double x = 0, exponent is -1023");
gsl_test_str (r.mantissa, mantissa, "double x = 0, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_ZERO, "double x = 0, type is ZERO");
}
/* Check for -ZERO */
{
double d = minus_one;
const char mantissa[]
= "0000000000000000000000000000000000000000000000000000";
gsl_ieee_double_rep r;
while (d < 0) {
d *= 0.1;
}
gsl_ieee_double_to_rep (&d, &r);
gsl_test_int (r.sign, 1, "double x = -1*0, sign is -");
gsl_test_int (r.exponent, -1023, "double x = -1*0, exponent is -1023");
gsl_test_str (r.mantissa, mantissa, "double x = -1*0, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_ZERO, "double x = -1*0, type is ZERO");
}
/* Check for a positive NORMAL number (e.g. 2.1) */
{
double d = 2.1;
const char mantissa[]
= "0000110011001100110011001100110011001100110011001101";
gsl_ieee_double_rep r;
gsl_ieee_double_to_rep (&d, &r);
gsl_test_int (r.sign, 0, "double x = 2.1, sign is +");
gsl_test_int (r.exponent, 1, "double x = 2.1, exponent is 1");
gsl_test_str (r.mantissa, mantissa, "double x = 2.1, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL, "double x = 2.1, type is NORMAL");
}
/* Check for a negative NORMAL number (e.g. -1.3304...) */
{
double d = -1.3303577090924210146738460025517269968986511230468750;
const char mantissa[]
= "0101010010010010010100101010010010001000100011101110";
gsl_ieee_double_rep r;
gsl_ieee_double_to_rep (&d, &r);
gsl_test_int (r.sign, 1, "double x = -1.3304..., sign is -");
gsl_test_int (r.exponent, 0, "double x = -1.3304..., exponent is 0");
gsl_test_str (r.mantissa, mantissa, "double x = -1.3304..., mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL,
"double x = -1.3304..., type is NORMAL");
}
/* Check for a large positive NORMAL number (e.g. 3.37e297) */
{
double d = 3.37e297;
const char mantissa[]
= "0100100111001001100101111001100000100110011101000100";
gsl_ieee_double_rep r;
gsl_ieee_double_to_rep (&d, &r);
gsl_test_int (r.sign, 0, "double x = 3.37e297, sign is +");
gsl_test_int (r.exponent, 988, "double x = 3.37e297, exponent is 998");
gsl_test_str (r.mantissa, mantissa, "double x = 3.37e297, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL,
"double x = 3.37e297, type is NORMAL");
}
/* Check for a small positive NORMAL number (e.g. 3.37e-297) */
{
double d = 3.37e-297;
const char mantissa[]
= "0001101000011011101011100001110010100001001100110111";
gsl_ieee_double_rep r;
gsl_ieee_double_to_rep (&d, &r);
gsl_test_int (r.sign, 0, "double x = 3.37e-297, sign is +");
gsl_test_int (r.exponent, -985, "double x = 3.37e-297, exponent is -985");
gsl_test_str (r.mantissa, mantissa, "double x = 3.37e-297, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL,
"double x = 3.37e-297, type is NORMAL");
}
/* Check for DBL_MIN (smallest possible number that is not denormal) */
{
double d = DBL_MIN;
const char mantissa[]
= "0000000000000000000000000000000000000000000000000000";
gsl_ieee_double_rep r;
gsl_ieee_double_to_rep (&d, &r);
gsl_test_int (r.sign, 0, "double x = DBL_MIN, sign is +");
gsl_test_int (r.exponent, -1022, "double x = DBL_MIN, exponent is -1022");
gsl_test_str (r.mantissa, mantissa, "double x = DBL_MIN, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL,
"double x = DBL_MIN, type is NORMAL");
}
/* Check for DBL_MAX (largest possible number that is not Inf) */
{
double d = DBL_MAX;
const char mantissa[]
= "1111111111111111111111111111111111111111111111111111";
gsl_ieee_double_rep r;
gsl_ieee_double_to_rep (&d, &r);
gsl_test_int (r.sign, 0, "double x = DBL_MAX, sign is +");
gsl_test_int (r.exponent, 1023, "double x = DBL_MAX, exponent is 1023");
gsl_test_str (r.mantissa, mantissa, "double x = DBL_MAX, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_NORMAL,
"double x = DBL_MAX, type is NORMAL");
}
/* Check for DENORMAL numbers (e.g. DBL_MIN/2^n) */
#ifdef TEST_DENORMAL
{
double d = DBL_MIN;
char mantissa[]
= "1000000000000000000000000000000000000000000000000000";
int i;
gsl_ieee_double_rep r;
for (i = 0; i < 52; i++)
{
double x = d / pow (2.0, 1 + (double) i);
mantissa[i] = '1';
gsl_ieee_double_to_rep (&x, &r);
gsl_test_int (r.sign, 0, "double x = DBL_MIN/2^%d, sign is +", i + 1);
gsl_test_int (r.exponent, -1023,
"double x = DBL_MIN/2^%d, exponent", i + 1);
gsl_test_str (r.mantissa, mantissa,
"double x = DBL_MIN/2^%d, mantissa", i + 1);
gsl_test_int (r.type, GSL_IEEE_TYPE_DENORMAL,
"double x = DBL_MIN/2^%d, type is DENORMAL", i + 1);
mantissa[i] = '0';
}
}
#endif
/* Check for positive INFINITY (e.g. 2*DBL_MAX) */
{
double d = DBL_MAX;
const char mantissa[]
= "0000000000000000000000000000000000000000000000000000";
gsl_ieee_double_rep r;
double x;
x = 2.0 * d;
gsl_ieee_double_to_rep (&x, &r);
gsl_test_int (r.sign, 0, "double x = 2*DBL_MAX, sign is +");
gsl_test_int (r.exponent, 1024, "double x = 2*DBL_MAX, exponent is 1024");
gsl_test_str (r.mantissa, mantissa, "double x = 2*DBL_MAX, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_INF, "double x = 2*DBL_MAX, type is INF");
}
/* Check for negative INFINITY (e.g. -2*DBL_MAX) */
{
double d = DBL_MAX;
const char mantissa[]
= "0000000000000000000000000000000000000000000000000000";
gsl_ieee_double_rep r;
double x;
x = -2.0 * d;
gsl_ieee_double_to_rep (&x, &r);
gsl_test_int (r.sign, 1, "double x = -2*DBL_MAX, sign is -");
gsl_test_int (r.exponent, 1024, "double x = -2*DBL_MAX, exponent is 1024");
gsl_test_str (r.mantissa, mantissa, "double x = -2*DBL_MAX, mantissa");
gsl_test_int (r.type, GSL_IEEE_TYPE_INF,"double x = -2*DBL_MAX, type is INF");
}
/* Check for NAN (e.g. Inf - Inf) */
{
gsl_ieee_double_rep r;
double x = 1.0, y = 2.0, z = zero;
x = x / z;
y = y / z;
z = y - x;
gsl_ieee_double_to_rep (&z, &r);
/* We don't check the sign and we don't check the mantissa because
they could be anything for a NaN */
gsl_test_int (r.exponent, 1024, "double x = NaN, exponent is 1024");
gsl_test_int (r.type, GSL_IEEE_TYPE_NAN, "double x = NaN, type is NAN");
}
exit (gsl_test_summary ());
}
int
main(int argc, char **argv)
{
size_t order, breakpoints, i;
gsl_ieee_env_setup();
argc = 0; /* prevent warnings about unused parameters */
argv = 0;
for (order = 1; order < 10; order++)
{
for (breakpoints = 2; breakpoints < 100; breakpoints++)
{
double a = -1.23 * order, b = 45.6 * order;
gsl_bspline_workspace *bw = gsl_bspline_alloc(order, breakpoints);
gsl_bspline_deriv_workspace *dbw = gsl_bspline_deriv_alloc(order);
gsl_bspline_knots_uniform(a, b, bw);
test_bspline(bw, dbw);
gsl_bspline_deriv_free(dbw);
gsl_bspline_free(bw);
}
}
for (order = 1; order < 10; order++)
{
for (breakpoints = 2; breakpoints < 100; breakpoints++)
{
double a = -1.23 * order, b = 45.6 * order;
gsl_bspline_workspace *bw = gsl_bspline_alloc(order, breakpoints);
gsl_bspline_deriv_workspace *dbw = gsl_bspline_deriv_alloc(order);
gsl_vector *k = gsl_vector_alloc(breakpoints);
for (i = 0; i < breakpoints; i++)
{
double f, x;
f = sqrt(i / (breakpoints - 1.0));
x = (1 - f) * a + f * b;
gsl_vector_set(k, i, x);
};
gsl_bspline_knots(k, bw);
test_bspline(bw, dbw);
gsl_vector_free(k);
gsl_bspline_deriv_free(dbw);
gsl_bspline_free(bw);
}
}
/* Spot check known 0th, 1st, 2nd derivative
evaluations for a particular k = 2 case. */
{
size_t i, j; /* looping */
const double xloc[4] = { 0.0, 1.0, 6.0, 7.0};
const double deriv[4][3] =
{
{ -1.0/2.0, 1.0/2.0, 0.0 },
{ -1.0/2.0, 1.0/2.0, 0.0 },
{ 0.0, -1.0/5.0, 1.0/5.0 },
{ 0.0, -1.0/5.0, 1.0/5.0 }
};
gsl_bspline_workspace *bw = gsl_bspline_alloc(2, 3);
gsl_bspline_deriv_workspace *dbw = gsl_bspline_deriv_alloc(2);
gsl_matrix *dB = gsl_matrix_alloc(gsl_bspline_ncoeffs(bw),
gsl_bspline_order(bw) + 1);
gsl_vector *breakpts = gsl_vector_alloc(3);
gsl_vector_set(breakpts, 0, 0.0);
gsl_vector_set(breakpts, 1, 2.0);
gsl_vector_set(breakpts, 2, 7.0);
gsl_bspline_knots(breakpts, bw);
for (i = 0; i < 4; ++i) /* at each location */
{
/* Initialize dB with poison to ensure we overwrite it */
gsl_matrix_set_all(dB, GSL_NAN);
gsl_bspline_deriv_eval(xloc[i], gsl_bspline_order(bw), dB, bw, dbw);
for (j = 0; j < gsl_bspline_ncoeffs(bw) ; ++j)
{
/* check basis function 1st deriv */
gsl_test_abs(gsl_matrix_get(dB, j, 1), deriv[i][j], GSL_DBL_EPSILON,
"b-spline k=%d basis #%d derivative %d at x = %f",
gsl_bspline_order(bw), j, 1, xloc[i]);
}
for (j = 0; j < gsl_bspline_ncoeffs(bw); ++j)
{
/* check k order basis function has k-th deriv equal to 0 */
gsl_test_abs(gsl_matrix_get(dB, j, gsl_bspline_order(bw)), 0.0,
GSL_DBL_EPSILON,
"b-spline k=%d basis #%d derivative %d at x = %f",
gsl_bspline_order(bw), j, gsl_bspline_order(bw),
xloc[i]);
}
}
gsl_matrix_free(dB);
gsl_bspline_deriv_free(dbw);
gsl_bspline_free(bw);
gsl_vector_free(breakpts);
}
/* Spot check known 0th, 1st, 2nd derivative
evaluations for a particular k = 3 case. */
{
size_t i, j; /* looping */
const double xloc[5] = { 0.0, 5.0, 9.0, 12.0, 15.0 };
const double eval[5][6] =
{
{ 4./25., 69./100., 3./ 20. , 0. , 0. , 0. },
{ 0. , 4./21. , 143./210. , 9./70., 0. , 0. },
{ 0. , 0. , 3./ 10. , 7./10., 0. , 0. },
{ 0. , 0. , 0. , 3./4. , 1./4., 0. },
{ 0. , 0. , 0. , 1./3. , 5./9., 1./9. }
};
const double deriv[5][6] =
{
{ -4./25., 3./50., 1./ 10., 0. , 0. , 0. },
{ 0. , -2./21., 1./105., 3./35., 0. , 0. },
{ 0. , 0. , -1./5. , 1./ 5., 0. , 0. },
{ 0. , 0. , 0. , -1./ 6., 1./6. , 0. },
{ 0. , 0. , 0. , -1./ 9., 1./27., 2./27. }
};
const double deriv2[5][6] =
{
{ 2./25., -17./150., 1.0/30.0 , 0.0 , 0. , 0. },
{ 0. , 1./ 42., -11.0/210.0, 1.0/35.0, 0. , 0. },
{ 0. , 0. , 1.0/15.0 ,-11.0/90.0, 1./18. , 0. },
{ 0. , 0. , 0.0 , 1.0/54.0, -7./162., 2./81. },
{ 0. , 0. , 0.0 , 1.0/54.0, -7./162., 2./81. }
};
gsl_bspline_workspace *bw = gsl_bspline_alloc(3, 5);
gsl_bspline_deriv_workspace *dbw = gsl_bspline_deriv_alloc(3);
gsl_matrix *dB = gsl_matrix_alloc(gsl_bspline_ncoeffs(bw),
gsl_bspline_order(bw) + 1);
gsl_vector *breakpts = gsl_vector_alloc(5);
gsl_vector_set(breakpts, 0, -3.0);
gsl_vector_set(breakpts, 1, 2.0);
gsl_vector_set(breakpts, 2, 9.0);
gsl_vector_set(breakpts, 3, 12.0);
gsl_vector_set(breakpts, 4, 21.0);
gsl_bspline_knots(breakpts, bw);
for (i = 0; i < 5; ++i) /* at each location */
{
/* Initialize dB with poison to ensure we overwrite it */
gsl_matrix_set_all(dB, GSL_NAN);
gsl_bspline_deriv_eval(xloc[i], gsl_bspline_order(bw), dB, bw, dbw);
/* check basis function evaluation */
for (j = 0; j < gsl_bspline_ncoeffs(bw); ++j)
{
gsl_test_abs(gsl_matrix_get(dB, j, 0), eval[i][j], GSL_DBL_EPSILON,
"b-spline k=%d basis #%d derivative %d at x = %f",
gsl_bspline_order(bw), j, 0, xloc[i]);
}
/* check 1st derivative evaluation */
for (j = 0; j < gsl_bspline_ncoeffs(bw); ++j)
{
gsl_test_abs(gsl_matrix_get(dB, j, 1), deriv[i][j], GSL_DBL_EPSILON,
"b-spline k=%d basis #%d derivative %d at x = %f",
gsl_bspline_order(bw), j, 1, xloc[i]);
}
/* check 2nd derivative evaluation */
for (j = 0; j < gsl_bspline_ncoeffs(bw); ++j)
{
gsl_test_abs(gsl_matrix_get(dB, j, 2), deriv2[i][j], GSL_DBL_EPSILON,
"b-spline k=%d basis #%d derivative %d at x = %f",
gsl_bspline_order(bw), j, 2, xloc[i]);
}
}
gsl_matrix_free(dB);
gsl_bspline_deriv_free(dbw);
gsl_bspline_free(bw);
gsl_vector_free(breakpts);
}
/* Check Greville abscissae functionality on a non-uniform k=1 */
{
size_t i; /* looping */
/* Test parameters */
const size_t k = 1;
const double bpoint_data[] = { 0.0, 0.2, 0.5, 0.75, 1.0 };
const size_t nbreak = sizeof(bpoint_data)/sizeof(bpoint_data[0]);
/* Expected results */
const double abscissae_data[] = { 0.1, 0.35, 0.625, 0.875 };
const size_t nabscissae = sizeof(abscissae_data)/sizeof(abscissae_data[0]);
gsl_vector_const_view bpoints = gsl_vector_const_view_array(bpoint_data, nbreak);
gsl_bspline_workspace *w = gsl_bspline_alloc(k, nbreak);
gsl_bspline_knots((const gsl_vector *) &bpoints, w);
gsl_test_int(nabscissae, gsl_bspline_ncoeffs(w),
"b-spline k=%d number of abscissae", k);
for (i = 0; i < nabscissae; ++i)
{
gsl_test_abs(gsl_bspline_greville_abscissa(i, w), abscissae_data[i], 2*k*GSL_DBL_EPSILON,
"b-spline k=%d Greville abscissa #%d at x = %f", k, i, abscissae_data[i]);
}
gsl_bspline_free(w);
}
/* Check Greville abscissae functionality on a non-uniform k=2 */
{
size_t i; /* looping */
/* Test parameters */
const size_t k = 2;
const double bpoint_data[] = { 0.0, 0.2, 0.5, 0.75, 1.0 };
const size_t nbreak = sizeof(bpoint_data)/sizeof(bpoint_data[0]);
/* Expected results */
const double abscissae_data[] = { 0.0, 0.2, 0.5, 0.75, 1.0 };
const size_t nabscissae = sizeof(abscissae_data)/sizeof(abscissae_data[0]);
gsl_vector_const_view bpoints = gsl_vector_const_view_array(bpoint_data, nbreak);
gsl_bspline_workspace *w = gsl_bspline_alloc(k, nbreak);
gsl_bspline_knots((const gsl_vector *) &bpoints, w);
gsl_test_int(nabscissae, gsl_bspline_ncoeffs(w),
"b-spline k=%d number of abscissae", k);
for (i = 0; i < nabscissae; ++i)
{
gsl_test_abs(gsl_bspline_greville_abscissa(i, w), abscissae_data[i], 2*k*GSL_DBL_EPSILON,
"b-spline k=%d Greville abscissa #%d at x = %f", k, i, abscissae_data[i]);
}
gsl_bspline_free(w);
}
/* Check Greville abscissae functionality on non-uniform k=3 */
{
size_t i; /* looping */
/* Test parameters */
const size_t k = 3;
const double bpoint_data[] = { 0.0, 0.2, 0.5, 0.75, 1.0 };
const size_t nbreak = sizeof(bpoint_data)/sizeof(bpoint_data[0]);
/* Expected results */
const double abscissae_data[] = { 0.0, 1.0/10.0, 7.0/20.0,
5.0/ 8.0, 7.0/ 8.0, 1.0 };
const size_t nabscissae = sizeof(abscissae_data)/sizeof(abscissae_data[0]);
gsl_vector_const_view bpoints = gsl_vector_const_view_array(bpoint_data, nbreak);
gsl_bspline_workspace *w = gsl_bspline_alloc(k, nbreak);
gsl_bspline_knots((const gsl_vector *) &bpoints, w);
gsl_test_int(nabscissae, gsl_bspline_ncoeffs(w),
"b-spline k=%d number of abscissae", k);
for (i = 0; i < nabscissae; ++i)
{
gsl_test_abs(gsl_bspline_greville_abscissa(i, w), abscissae_data[i], 2*k*GSL_DBL_EPSILON,
"b-spline k=%d Greville abscissa #%d at x = %f", k, i, abscissae_data[i]);
}
gsl_bspline_free(w);
}
/* Check Greville abscissae functionality on non-uniform k=4 */
{
size_t i; /* looping */
/* Test parameters */
const size_t k = 4;
const double bpoint_data[] = { 0.0, 0.2, 0.5, 0.75, 1.0 };
const size_t nbreak = sizeof(bpoint_data)/sizeof(bpoint_data[0]);
/* Expected results */
const double abscissae_data[] = { 0.0, 1.0/15.0, 7.0/30.0, 29.0/60.0,
3.0/ 4.0, 11.0/12.0, 1.0 };
const size_t nabscissae = sizeof(abscissae_data)/sizeof(abscissae_data[0]);
gsl_vector_const_view bpoints = gsl_vector_const_view_array(bpoint_data, nbreak);
gsl_bspline_workspace *w = gsl_bspline_alloc(k, nbreak);
gsl_bspline_knots((const gsl_vector *) &bpoints, w);
gsl_test_int(nabscissae, gsl_bspline_ncoeffs(w),
"b-spline k=%d number of abscissae", k);
for (i = 0; i < nabscissae; ++i)
{
gsl_test_abs(gsl_bspline_greville_abscissa(i, w), abscissae_data[i], 2*k*GSL_DBL_EPSILON,
"b-spline k=%d Greville abscissa #%d at x = %f", k, i, abscissae_data[i]);
}
gsl_bspline_free(w);
}
exit(gsl_test_summary());
}
int
main (void)
{
const gsl_multiroot_fsolver_type * fsolvers[5] ;
const gsl_multiroot_fsolver_type ** T1 ;
const gsl_multiroot_fdfsolver_type * fdfsolvers[5] ;
const gsl_multiroot_fdfsolver_type ** T2 ;
double f;
fsolvers[0] = gsl_multiroot_fsolver_dnewton;
fsolvers[1] = gsl_multiroot_fsolver_broyden;
fsolvers[2] = gsl_multiroot_fsolver_hybrid;
fsolvers[3] = gsl_multiroot_fsolver_hybrids;
fsolvers[4] = 0;
fdfsolvers[0] = gsl_multiroot_fdfsolver_newton;
fdfsolvers[1] = gsl_multiroot_fdfsolver_gnewton;
fdfsolvers[2] = gsl_multiroot_fdfsolver_hybridj;
fdfsolvers[3] = gsl_multiroot_fdfsolver_hybridsj;
fdfsolvers[4] = 0;
gsl_ieee_env_setup();
f = 1.0 ;
T1 = fsolvers ;
while (*T1 != 0)
{
test_f ("Rosenbrock", &rosenbrock, rosenbrock_initpt, f, *T1);
test_f ("Roth", &roth, roth_initpt, f, *T1);
test_f ("Powell badly scaled", &powellscal, powellscal_initpt, f, *T1);
test_f ("Brown badly scaled", &brownscal, brownscal_initpt, f, *T1);
test_f ("Powell singular", &powellsing, powellsing_initpt, f, *T1);
test_f ("Wood", &wood, wood_initpt, f, *T1);
test_f ("Helical", &helical, helical_initpt, f, *T1);
test_f ("Discrete BVP", &dbv, dbv_initpt, f, *T1);
test_f ("Trig", &trig, trig_initpt, f, *T1);
T1++;
}
T2 = fdfsolvers ;
while (*T2 != 0)
{
test_fdf ("Rosenbrock", &rosenbrock, rosenbrock_initpt, f, *T2);
test_fdf ("Roth", &roth, roth_initpt, f, *T2);
test_fdf ("Powell badly scaled", &powellscal, powellscal_initpt, f, *T2);
test_fdf ("Brown badly scaled", &brownscal, brownscal_initpt, f, *T2);
test_fdf ("Powell singular", &powellsing, powellsing_initpt, f, *T2);
test_fdf ("Wood", &wood, wood_initpt, f, *T2);
test_fdf ("Helical", &helical, helical_initpt, f, *T2);
test_fdf ("Discrete BVP", &dbv, dbv_initpt, f, *T2);
test_fdf ("Trig", &trig, trig_initpt, f, *T2);
T2++;
}
exit (gsl_test_summary ());
}
int
main (void)
{
size_t stride, ostride, N;
gsl_ieee_env_setup ();
for (N = 10; N < 1024; N = 2*N + 1)
{
for (stride = 1; stride < 5 ; stride++)
{
test_func (stride, N);
test_float_func (stride, N);
test_long_double_func (stride, N);
test_ulong_func (stride, N);
test_long_func (stride, N);
test_uint_func (stride, N);
test_int_func (stride, N);
test_ushort_func (stride, N);
test_short_func (stride, N);
test_uchar_func (stride, N);
test_char_func (stride, N);
test_complex_func (stride, N);
test_complex_float_func (stride, N);
test_complex_long_double_func (stride, N);
for (ostride = 1; ostride < 5 ; ostride++)
{
test_ops (stride, ostride, N);
test_float_ops (stride, ostride, N);
test_long_double_ops (stride, ostride, N);
test_ulong_ops (stride, ostride, N);
test_long_ops (stride, ostride, N);
test_uint_ops (stride, ostride, N);
test_int_ops (stride, ostride, N);
test_ushort_ops (stride, ostride, N);
test_short_ops (stride, ostride, N);
test_uchar_ops (stride, ostride, N);
test_char_ops (stride, ostride, N);
test_complex_ops (stride, ostride, N);
test_complex_float_ops (stride, ostride, N);
test_complex_long_double_ops (stride, ostride, N);
}
test_text (stride, N);
test_float_text (stride, N);
#if HAVE_PRINTF_LONGDOUBLE
test_long_double_text (stride, N);
#endif
test_ulong_text (stride, N);
test_long_text (stride, N);
test_uint_text (stride, N);
test_int_text (stride, N);
test_ushort_text (stride, N);
test_short_text (stride, N);
test_uchar_text (stride, N);
test_char_text (stride, N);
test_complex_text (stride, N);
test_complex_float_text (stride, N);
#if HAVE_PRINTF_LONGDOUBLE
test_complex_long_double_text (stride, N);
#endif
test_file (stride, N);
test_float_file (stride, N);
test_long_double_file (stride, N);
test_ulong_file (stride, N);
test_long_file (stride, N);
test_uint_file (stride, N);
test_int_file (stride, N);
test_ushort_file (stride, N);
test_short_file (stride, N);
test_uchar_file (stride, N);
test_char_file (stride, N);
test_complex_file (stride, N);
test_complex_float_file (stride, N);
test_complex_long_double_file (stride, N);
}
}
#if GSL_RANGE_CHECK
gsl_set_error_handler (&my_error_handler);
for (N = 1; N < 1024; N *=2)
{
for (stride = 1; stride < 5 ; stride++)
{
test_trap (stride, N);
test_float_trap (stride, N);
test_long_double_trap (stride, N);
test_ulong_trap (stride, N);
test_long_trap (stride, N);
test_uint_trap (stride, N);
test_int_trap (stride, N);
test_ushort_trap (stride, N);
test_short_trap (stride, N);
test_uchar_trap (stride, N);
test_char_trap (stride, N);
test_complex_trap (stride, N);
test_complex_float_trap (stride, N);
test_complex_long_double_trap (stride, N);
}
}
#endif
exit (gsl_test_summary ());
}
int
main (void)
{
const gsl_rng_type ** rngs = gsl_rng_types_setup(); /* get all rng types */
const gsl_rng_type ** r ;
gsl_ieee_env_setup ();
gsl_rng_env_setup ();
/* specific tests of known results for 10000 iterations with seed = 1 */
rng_test (gsl_rng_rand, 1, 10000, 1910041713);
rng_test (gsl_rng_randu, 1, 10000, 1623524161);
rng_test (gsl_rng_cmrg, 1, 10000, 719452880);
rng_test (gsl_rng_minstd, 1, 10000, 1043618065);
rng_test (gsl_rng_mrg, 1, 10000, 2064828650);
rng_test (gsl_rng_taus, 1, 10000, 2733957125UL);
rng_test (gsl_rng_taus113, 1, 1000, 1925420673UL);
rng_test (gsl_rng_transputer, 1, 10000, 1244127297UL);
rng_test (gsl_rng_vax, 1, 10000, 3051034865UL);
rng_test (gsl_rng_borosh13, 1, 10000, 2513433025UL);
rng_test (gsl_rng_fishman18, 1, 10000, 1626638977UL);
rng_test (gsl_rng_fishman2x, 1, 10000, 1158622502UL);
rng_test (gsl_rng_knuthran2, 1, 10000, 1182784902UL);
rng_test (gsl_rng_knuthran, 310952, 1009 * 2009 + 1, 461390032);
rng_test (gsl_rng_lecuyer21, 1, 10000, 2006618587UL);
rng_test (gsl_rng_waterman14, 1, 10000, 3776680385UL);
/* specific tests of known results for 10000 iterations with seed = 6 */
rng_test (gsl_rng_coveyou, 6, 10000, 1416754246UL);
rng_test (gsl_rng_fishman20, 6, 10000, 1811577350UL);
/* FIXME: the ranlux tests below were made by running the fortran code and
getting the expected value from that. An analytic calculation
would be preferable. */
rng_test (gsl_rng_ranlux, 314159265, 10000, 12077992);
rng_test (gsl_rng_ranlux389, 314159265, 10000, 165942);
rng_test (gsl_rng_ranlxs0, 1, 10000, 11904320);
/* 0.709552764892578125 * ldexp(1.0,24) */
rng_test (gsl_rng_ranlxs1, 1, 10000, 8734328);
/* 0.520606517791748047 * ldexp(1.0,24) */
rng_test (gsl_rng_ranlxs2, 1, 10000, 6843140);
/* 0.407882928848266602 * ldexp(1.0,24) */
rng_test (gsl_rng_ranlxd1, 1, 10000, 1998227290UL);
/* 0.465248546261094020 * ldexp(1.0,32) */
rng_test (gsl_rng_ranlxd2, 1, 10000, 3949287736UL);
/* 0.919515205581550532 * ldexp(1.0,32) */
/* FIXME: the tests below were made by running the original code in
the ../random directory and getting the expected value from
that. An analytic calculation would be preferable. */
rng_test (gsl_rng_slatec, 1, 10000, 45776);
rng_test (gsl_rng_uni, 1, 10000, 9214);
rng_test (gsl_rng_uni32, 1, 10000, 1155229825);
rng_test (gsl_rng_zuf, 1, 10000, 3970);
/* The tests below were made by running the original code and
getting the expected value from that. An analytic calculation
would be preferable. */
rng_test (gsl_rng_r250, 1, 10000, 1100653588);
rng_test (gsl_rng_mt19937, 4357, 1000, 1186927261);
rng_test (gsl_rng_mt19937_1999, 4357, 1000, 1030650439);
rng_test (gsl_rng_mt19937_1998, 4357, 1000, 1309179303);
rng_test (gsl_rng_tt800, 0, 10000, 2856609219UL);
rng_test (gsl_rng_ran0, 0, 10000, 1115320064);
rng_test (gsl_rng_ran1, 0, 10000, 1491066076);
rng_test (gsl_rng_ran2, 0, 10000, 1701364455);
rng_test (gsl_rng_ran3, 0, 10000, 186340785);
rng_test (gsl_rng_ranmar, 1, 10000, 14428370);
rng_test (gsl_rng_rand48, 0, 10000, 0xDE095043UL);
rng_test (gsl_rng_rand48, 1, 10000, 0xEDA54977UL);
rng_test (gsl_rng_random_glibc2, 0, 10000, 1908609430);
rng_test (gsl_rng_random8_glibc2, 0, 10000, 1910041713);
rng_test (gsl_rng_random32_glibc2, 0, 10000, 1587395585);
rng_test (gsl_rng_random64_glibc2, 0, 10000, 52848624);
rng_test (gsl_rng_random128_glibc2, 0, 10000, 1908609430);
rng_test (gsl_rng_random256_glibc2, 0, 10000, 179943260);
rng_test (gsl_rng_random_bsd, 0, 10000, 1457025928);
rng_test (gsl_rng_random8_bsd, 0, 10000, 1910041713);
rng_test (gsl_rng_random32_bsd, 0, 10000, 1663114331);
rng_test (gsl_rng_random64_bsd, 0, 10000, 864469165);
rng_test (gsl_rng_random128_bsd, 0, 10000, 1457025928);
rng_test (gsl_rng_random256_bsd, 0, 10000, 1216357476);
rng_test (gsl_rng_random_libc5, 0, 10000, 428084942);
rng_test (gsl_rng_random8_libc5, 0, 10000, 1910041713);
rng_test (gsl_rng_random32_libc5, 0, 10000, 1967452027);
rng_test (gsl_rng_random64_libc5, 0, 10000, 2106639801);
rng_test (gsl_rng_random128_libc5, 0, 10000, 428084942);
rng_test (gsl_rng_random256_libc5, 0, 10000, 116367984);
rng_test (gsl_rng_ranf, 0, 10000, 2152890433UL);
rng_test (gsl_rng_ranf, 2, 10000, 339327233);
/* Test constant relationship between int and double functions */
for (r = rngs ; *r != 0; r++)
rng_float_test (*r);
/* Test save/restore functions */
for (r = rngs ; *r != 0; r++)
rng_state_test (*r);
for (r = rngs ; *r != 0; r++)
rng_parallel_state_test (*r);
/* generic statistical tests (these are just to make sure that we
don't get any crazy results back from the generator, i.e. they
aren't a test of the algorithm, just the implementation) */
for (r = rngs ; *r != 0; r++)
generic_rng_test (*r);
exit (gsl_test_summary ());
}
int
main (void)
{
gsl_function F_sin, F_cos, F_func1, F_func2, F_func3, F_func4,
F_func5, F_func6;
gsl_function_fdf FDF_sin, FDF_cos, FDF_func1, FDF_func2, FDF_func3, FDF_func4,
FDF_func5, FDF_func6, FDF_func7;
const gsl_root_fsolver_type * fsolver[4] ;
const gsl_root_fdfsolver_type * fdfsolver[4] ;
const gsl_root_fsolver_type ** T;
const gsl_root_fdfsolver_type ** S;
gsl_ieee_env_setup();
fsolver[0] = gsl_root_fsolver_bisection;
fsolver[1] = gsl_root_fsolver_brent;
fsolver[2] = gsl_root_fsolver_falsepos;
fsolver[3] = 0;
fdfsolver[0] = gsl_root_fdfsolver_newton;
fdfsolver[1] = gsl_root_fdfsolver_secant;
fdfsolver[2] = gsl_root_fdfsolver_steffenson;
fdfsolver[3] = 0;
F_sin = create_function (sin_f) ;
F_cos = create_function (cos_f) ;
F_func1 = create_function (func1) ;
F_func2 = create_function (func2) ;
F_func3 = create_function (func3) ;
F_func4 = create_function (func4) ;
F_func5 = create_function (func5) ;
F_func6 = create_function (func6) ;
FDF_sin = create_fdf (sin_f, sin_df, sin_fdf) ;
FDF_cos = create_fdf (cos_f, cos_df, cos_fdf) ;
FDF_func1 = create_fdf (func1, func1_df, func1_fdf) ;
FDF_func2 = create_fdf (func2, func2_df, func2_fdf) ;
FDF_func3 = create_fdf (func3, func3_df, func3_fdf) ;
FDF_func4 = create_fdf (func4, func4_df, func4_fdf) ;
FDF_func5 = create_fdf (func5, func5_df, func5_fdf) ;
FDF_func6 = create_fdf (func6, func6_df, func6_fdf) ;
FDF_func7 = create_fdf(func7, func7_df, func7_fdf) ;
gsl_set_error_handler (&my_error_handler);
for (T = fsolver ; *T != 0 ; T++)
{
test_f (*T, "sin(x) [3, 4]", &F_sin, 3.0, 4.0, M_PI);
test_f (*T, "sin(x) [-4, -3]", &F_sin, -4.0, -3.0, -M_PI);
test_f (*T, "sin(x) [-1/3, 1]", &F_sin, -1.0 / 3.0, 1.0, 0.0);
test_f (*T, "cos(x) [0, 3]", &F_cos, 0.0, 3.0, M_PI / 2.0);
test_f (*T, "cos(x) [-3, 0]", &F_cos, -3.0, 0.0, -M_PI / 2.0);
test_f (*T, "x^20 - 1 [0.1, 2]", &F_func1, 0.1, 2.0, 1.0);
test_f (*T, "sqrt(|x|)*sgn(x)", &F_func2, -1.0 / 3.0, 1.0, 0.0);
test_f (*T, "x^2 - 1e-8 [0, 1]", &F_func3, 0.0, 1.0, sqrt (1e-8));
test_f (*T, "x exp(-x) [-1/3, 2]", &F_func4, -1.0 / 3.0, 2.0, 0.0);
test_f (*T, "(x - 1)^7 [0.9995, 1.0002]", &F_func6, 0.9995, 1.0002, 1.0);
test_f_e (*T, "invalid range check [4, 0]", &F_sin, 4.0, 0.0, M_PI);
test_f_e (*T, "invalid range check [1, 1]", &F_sin, 1.0, 1.0, M_PI);
test_f_e (*T, "invalid range check [0.1, 0.2]", &F_sin, 0.1, 0.2, M_PI);
}
for (S = fdfsolver ; *S != 0 ; S++)
{
test_fdf (*S,"sin(x) {3.4}", &FDF_sin, 3.4, M_PI);
test_fdf (*S,"sin(x) {-3.3}", &FDF_sin, -3.3, -M_PI);
test_fdf (*S,"sin(x) {0.5}", &FDF_sin, 0.5, 0.0);
test_fdf (*S,"cos(x) {0.6}", &FDF_cos, 0.6, M_PI / 2.0);
test_fdf (*S,"cos(x) {-2.5}", &FDF_cos, -2.5, -M_PI / 2.0);
test_fdf (*S,"x^{20} - 1 {0.9}", &FDF_func1, 0.9, 1.0);
test_fdf (*S,"x^{20} - 1 {1.1}", &FDF_func1, 1.1, 1.0);
test_fdf (*S,"sqrt(|x|)*sgn(x) {1.001}", &FDF_func2, 0.001, 0.0);
test_fdf (*S,"x^2 - 1e-8 {1}", &FDF_func3, 1.0, sqrt (1e-8));
test_fdf (*S,"x exp(-x) {-2}", &FDF_func4, -2.0, 0.0);
test_fdf_e (*S,"max iterations x -> +Inf, x exp(-x) {2}", &FDF_func4, 2.0, 0.0);
test_fdf_e (*S,"max iterations x -> -Inf, 1/(1 + exp(-x)) {0}", &FDF_func5, 0.0, 0.0);
test_fdf(*S, "-pi * x + e {1.5}", &FDF_func7, 1.5, M_E / M_PI);
}
test_fdf (gsl_root_fdfsolver_steffenson,
"(x - 1)^7 {0.9}", &FDF_func6, 0.9, 1.0);
/* now summarize the results */
exit (gsl_test_summary ());
}
int
main (void)
{
double y, y_expected;
int e, e_expected;
gsl_ieee_env_setup ();
/* Test for expm1 */
y = gsl_expm1 (0.0);
y_expected = 0.0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_expm1(0.0)");
y = gsl_expm1 (1e-10);
y_expected = 1.000000000050000000002e-10;
gsl_test_rel (y, y_expected, 1e-15, "gsl_expm1(1e-10)");
y = gsl_expm1 (-1e-10);
y_expected = -9.999999999500000000017e-11;
gsl_test_rel (y, y_expected, 1e-15, "gsl_expm1(-1e-10)");
y = gsl_expm1 (0.1);
y_expected = 0.1051709180756476248117078264902;
gsl_test_rel (y, y_expected, 1e-15, "gsl_expm1(0.1)");
y = gsl_expm1 (-0.1);
y_expected = -0.09516258196404042683575094055356;
gsl_test_rel (y, y_expected, 1e-15, "gsl_expm1(-0.1)");
y = gsl_expm1 (10.0);
y_expected = 22025.465794806716516957900645284;
gsl_test_rel (y, y_expected, 1e-15, "gsl_expm1(10.0)");
y = gsl_expm1 (-10.0);
y_expected = -0.99995460007023751514846440848444;
gsl_test_rel (y, y_expected, 1e-15, "gsl_expm1(-10.0)");
/* Test for log1p */
y = gsl_log1p (0.0);
y_expected = 0.0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_log1p(0.0)");
y = gsl_log1p (1e-10);
y_expected = 9.9999999995000000000333333333308e-11;
gsl_test_rel (y, y_expected, 1e-15, "gsl_log1p(1e-10)");
y = gsl_log1p (0.1);
y_expected = 0.095310179804324860043952123280765;
gsl_test_rel (y, y_expected, 1e-15, "gsl_log1p(0.1)");
y = gsl_log1p (10.0);
y_expected = 2.3978952727983705440619435779651;
gsl_test_rel (y, y_expected, 1e-15, "gsl_log1p(10.0)");
/* Test for gsl_hypot */
y = gsl_hypot (0.0, 0.0);
y_expected = 0.0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot(0.0, 0.0)");
y = gsl_hypot (1e-10, 1e-10);
y_expected = 1.414213562373095048801688e-10;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot(1e-10, 1e-10)");
y = gsl_hypot (1e-38, 1e-38);
y_expected = 1.414213562373095048801688e-38;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot(1e-38, 1e-38)");
y = gsl_hypot (1e-10, -1.0);
y_expected = 1.000000000000000000005;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot(1e-10, -1)");
y = gsl_hypot (-1.0, 1e-10);
y_expected = 1.000000000000000000005;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot(-1, 1e-10)");
y = gsl_hypot (1e307, 1e301);
y_expected = 1.000000000000499999999999e307;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot(1e307, 1e301)");
y = gsl_hypot (1e301, 1e307);
y_expected = 1.000000000000499999999999e307;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot(1e301, 1e307)");
y = gsl_hypot (1e307, 1e307);
y_expected = 1.414213562373095048801688e307;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot(1e307, 1e307)");
/* Test for gsl_hypot3 */
y = gsl_hypot3 (0.0, 0.0, 0.0);
y_expected = 0.0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot3(0.0, 0.0, 0.0)");
y = gsl_hypot3 (1e-10, 1e-10, 1e-10);
y_expected = 1.732050807568877293527446e-10;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot3(1e-10, 1e-10, 1e-10)");
y = gsl_hypot3 (1e-38, 1e-38, 1e-38);
y_expected = 1.732050807568877293527446e-38;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot3(1e-38, 1e-38, 1e-38)");
y = gsl_hypot3 (1e-10, 1e-10, -1.0);
y_expected = 1.000000000000000000099;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot3(1e-10, 1e-10, -1)");
y = gsl_hypot3 (1e-10, -1.0, 1e-10);
y_expected = 1.000000000000000000099;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot3(1e-10, -1, 1e-10)");
y = gsl_hypot3 (-1.0, 1e-10, 1e-10);
y_expected = 1.000000000000000000099;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot3(-1, 1e-10, 1e-10)");
y = gsl_hypot3 (1e307, 1e301, 1e301);
y_expected = 1.0000000000009999999999995e307;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot3(1e307, 1e301, 1e301)");
y = gsl_hypot3 (1e307, 1e307, 1e307);
y_expected = 1.732050807568877293527446e307;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot3(1e307, 1e307, 1e307)");
y = gsl_hypot3 (1e307, 1e-307, 1e-307);
y_expected = 1.0e307;
gsl_test_rel (y, y_expected, 1e-15, "gsl_hypot3(1e307, 1e-307, 1e-307)");
/* Test for acosh */
y = gsl_acosh (1.0);
y_expected = 0.0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_acosh(1.0)");
y = gsl_acosh (1.1);
y_expected = 4.435682543851151891329110663525e-1;
gsl_test_rel (y, y_expected, 1e-15, "gsl_acosh(1.1)");
y = gsl_acosh (10.0);
y_expected = 2.9932228461263808979126677137742e0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_acosh(10.0)");
y = gsl_acosh (1e10);
y_expected = 2.3718998110500402149594646668302e1;
gsl_test_rel (y, y_expected, 1e-15, "gsl_acosh(1e10)");
/* Test for asinh */
y = gsl_asinh (0.0);
y_expected = 0.0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(0.0)");
y = gsl_asinh (1e-10);
y_expected = 9.9999999999999999999833333333346e-11;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(1e-10)");
y = gsl_asinh (-1e-10);
y_expected = -9.9999999999999999999833333333346e-11;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(1e-10)");
y = gsl_asinh (0.1);
y_expected = 9.983407889920756332730312470477e-2;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(0.1)");
y = gsl_asinh (-0.1);
y_expected = -9.983407889920756332730312470477e-2;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(-0.1)");
y = gsl_asinh (1.0);
y_expected = 8.8137358701954302523260932497979e-1;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(1.0)");
y = gsl_asinh (-1.0);
y_expected = -8.8137358701954302523260932497979e-1;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(-1.0)");
y = gsl_asinh (10.0);
y_expected = 2.9982229502979697388465955375965e0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(10)");
y = gsl_asinh (-10.0);
y_expected = -2.9982229502979697388465955375965e0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(-10)");
y = gsl_asinh (1e10);
y_expected = 2.3718998110500402149599646668302e1;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(1e10)");
y = gsl_asinh (-1e10);
y_expected = -2.3718998110500402149599646668302e1;
gsl_test_rel (y, y_expected, 1e-15, "gsl_asinh(-1e10)");
/* Test for atanh */
y = gsl_atanh (0.0);
y_expected = 0.0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_atanh(0.0)");
y = gsl_atanh (1e-20);
y_expected = 1e-20;
gsl_test_rel (y, y_expected, 1e-15, "gsl_atanh(1e-20)");
y = gsl_atanh (-1e-20);
y_expected = -1e-20;
gsl_test_rel (y, y_expected, 1e-15, "gsl_atanh(-1e-20)");
y = gsl_atanh (0.1);
y_expected = 1.0033534773107558063572655206004e-1;
gsl_test_rel (y, y_expected, 1e-15, "gsl_atanh(0.1)");
y = gsl_atanh (-0.1);
y_expected = -1.0033534773107558063572655206004e-1;
gsl_test_rel (y, y_expected, 1e-15, "gsl_atanh(-0.1)");
y = gsl_atanh (0.9);
y_expected = 1.4722194895832202300045137159439e0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_atanh(0.9)");
y = gsl_atanh (-0.9);
y_expected = -1.4722194895832202300045137159439e0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_atanh(0.9)");
/* Test for pow_int */
y = gsl_pow_2 (-3.14);
y_expected = pow (-3.14, 2.0);
gsl_test_rel (y, y_expected, 1e-15, "gsl_pow_2(-3.14)");
y = gsl_pow_3 (-3.14);
y_expected = pow (-3.14, 3.0);
gsl_test_rel (y, y_expected, 1e-15, "gsl_pow_3(-3.14)");
y = gsl_pow_4 (-3.14);
y_expected = pow (-3.14, 4.0);
gsl_test_rel (y, y_expected, 1e-15, "gsl_pow_4(-3.14)");
y = gsl_pow_5 (-3.14);
y_expected = pow (-3.14, 5.0);
gsl_test_rel (y, y_expected, 1e-15, "gsl_pow_5(-3.14)");
y = gsl_pow_6 (-3.14);
y_expected = pow (-3.14, 6.0);
gsl_test_rel (y, y_expected, 1e-15, "gsl_pow_6(-3.14)");
y = gsl_pow_7 (-3.14);
y_expected = pow (-3.14, 7.0);
gsl_test_rel (y, y_expected, 1e-15, "gsl_pow_7(-3.14)");
y = gsl_pow_8 (-3.14);
y_expected = pow (-3.14, 8.0);
gsl_test_rel (y, y_expected, 1e-15, "gsl_pow_8(-3.14)");
y = gsl_pow_9 (-3.14);
y_expected = pow (-3.14, 9.0);
gsl_test_rel (y, y_expected, 1e-15, "gsl_pow_9(-3.14)");
{
int n;
for (n = -9; n < 10; n++)
{
y = gsl_pow_int (-3.14, n);
y_expected = pow (-3.14, n);
gsl_test_rel (y, y_expected, 1e-15, "gsl_pow_n(-3.14,%d)", n);
}
}
/* Test for ldexp */
y = gsl_ldexp (M_PI, -2);
y_expected = M_PI_4;
gsl_test_rel (y, y_expected, 1e-15, "gsl_ldexp(pi,-2)");
y = gsl_ldexp (1.0, 2);
y_expected = 4.000000;
gsl_test_rel (y, y_expected, 1e-15, "gsl_ldexp(1.0,2)");
y = gsl_ldexp (0.0, 2);
y_expected = 0.0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_ldexp(0.0,2)");
y = gsl_ldexp (9.999999999999998890e-01, 1024);
y_expected = GSL_DBL_MAX;
gsl_test_rel (y, y_expected, 1e-15, "gsl_ldexp DBL_MAX");
y = gsl_ldexp (1e308, -2000);
y_expected = 8.7098098162172166755761e-295;
gsl_test_rel (y, y_expected, 1e-15, "gsl_ldexp(1e308,-2000)");
y = gsl_ldexp (GSL_DBL_MIN, 2000);
y_expected = 2.554675596204441378334779940e294;
gsl_test_rel (y, y_expected, 1e-15, "gsl_ldexp(DBL_MIN,2000)");
/* Test subnormals */
{
int i = 0;
volatile double x = GSL_DBL_MIN;
y_expected = 2.554675596204441378334779940e294;
x /= 2;
while (x > 0)
{
i++ ;
y = gsl_ldexp (x, 2000 + i);
gsl_test_rel (y, y_expected, 1e-15, "gsl_ldexp(DBL_MIN/2**%d,%d)",i,2000+i);
x /= 2;
}
}
/* Test for frexp */
y = gsl_frexp (0.0, &e);
y_expected = 0;
e_expected = 0;
gsl_test_rel (y, y_expected, 1e-15, "gsl_frexp(0) fraction");
gsl_test_int (e, e_expected, "gsl_frexp(0) exponent");
y = gsl_frexp (M_PI, &e);
y_expected = M_PI_4;
e_expected = 2;
gsl_test_rel (y, y_expected, 1e-15, "gsl_frexp(pi) fraction");
gsl_test_int (e, e_expected, "gsl_frexp(pi) exponent");
y = gsl_frexp (2.0, &e);
y_expected = 0.5;
e_expected = 2;
gsl_test_rel (y, y_expected, 1e-15, "gsl_frexp(2.0) fraction");
gsl_test_int (e, e_expected, "gsl_frexp(2.0) exponent");
y = gsl_frexp (1.0 / 4.0, &e);
y_expected = 0.5;
e_expected = -1;
gsl_test_rel (y, y_expected, 1e-15, "gsl_frexp(0.25) fraction");
gsl_test_int (e, e_expected, "gsl_frexp(0.25) exponent");
y = gsl_frexp (1.0 / 4.0 - 4.0 * GSL_DBL_EPSILON, &e);
y_expected = 0.999999999999996447;
e_expected = -2;
gsl_test_rel (y, y_expected, 1e-15, "gsl_frexp(0.25-eps) fraction");
gsl_test_int (e, e_expected, "gsl_frexp(0.25-eps) exponent");
y = gsl_frexp (GSL_DBL_MAX, &e);
y_expected = 9.999999999999998890e-01;
e_expected = 1024;
gsl_test_rel (y, y_expected, 1e-15, "gsl_frexp(DBL_MAX) fraction");
gsl_test_int (e, e_expected, "gsl_frexp(DBL_MAX) exponent");
y = gsl_frexp (-GSL_DBL_MAX, &e);
y_expected = -9.999999999999998890e-01;
e_expected = 1024;
gsl_test_rel (y, y_expected, 1e-15, "gsl_frexp(-DBL_MAX) fraction");
gsl_test_int (e, e_expected, "gsl_frexp(-DBL_MAX) exponent");
y = gsl_frexp (GSL_DBL_MIN, &e);
y_expected = 0.5;
e_expected = -1021;
gsl_test_rel (y, y_expected, 1e-15, "gsl_frexp(DBL_MIN) fraction");
gsl_test_int (e, e_expected, "gsl_frexp(DBL_MIN) exponent");
y = gsl_frexp (-GSL_DBL_MIN, &e);
y_expected = -0.5;
e_expected = -1021;
gsl_test_rel (y, y_expected, 1e-15, "gsl_frexp(-DBL_MIN) fraction");
gsl_test_int (e, e_expected, "gsl_frexp(-DBL_MIN) exponent");
/* Test subnormals */
{
int i = 0;
volatile double x = GSL_DBL_MIN;
y_expected = 0.5;
e_expected = -1021;
x /= 2;
while (x > 0)
{
e_expected--;
i++ ;
y = gsl_frexp (x, &e);
gsl_test_rel (y, y_expected, 1e-15, "gsl_frexp(DBL_MIN/2**%d) fraction",i);
gsl_test_int (e, e_expected, "gsl_frexp(DBL_MIN/2**%d) exponent", i);
x /= 2;
}
}
/* Test for approximate floating point comparison */
{
double x, y;
int i;
x = M_PI;
y = 22.0 / 7.0;
/* test the basic function */
for (i = 0; i < 10; i++)
{
double tol = pow (10, -i);
int res = gsl_fcmp (x, y, tol);
gsl_test_int (res, -(i >= 4), "gsl_fcmp(%.5f,%.5f,%g)", x, y, tol);
}
for (i = 0; i < 10; i++)
{
double tol = pow (10, -i);
int res = gsl_fcmp (y, x, tol);
gsl_test_int (res, (i >= 4), "gsl_fcmp(%.5f,%.5f,%g)", y, x, tol);
}
}
#if HAVE_IEEE_COMPARISONS
/* Test for isinf, isnan, finite */
{
double zero, one, inf, nan;
int s;
zero = 0.0;
one = 1.0;
inf = exp (1.0e10);
nan = inf / inf;
s = gsl_isinf (zero);
gsl_test_int (s, 0, "gsl_isinf(0)");
s = gsl_isinf (one);
gsl_test_int (s, 0, "gsl_isinf(1)");
s = gsl_isinf (inf);
gsl_test_int (s, 1, "gsl_isinf(inf)");
s = gsl_isinf (-inf);
gsl_test_int (s, -1, "gsl_isinf(-inf)");
s = gsl_isinf (nan);
gsl_test_int (s, 0, "gsl_isinf(nan)");
s = gsl_isnan (zero);
gsl_test_int (s, 0, "gsl_isnan(0)");
s = gsl_isnan (one);
gsl_test_int (s, 0, "gsl_isnan(1)");
s = gsl_isnan (inf);
gsl_test_int (s, 0, "gsl_isnan(inf)");
s = gsl_isnan (-inf);
gsl_test_int (s, 0, "gsl_isnan(-inf)");
s = gsl_isnan (nan);
gsl_test_int (s, 1, "gsl_isnan(nan)");
s = gsl_finite (zero);
gsl_test_int (s, 1, "gsl_finite(0)");
s = gsl_finite (one);
gsl_test_int (s, 1, "gsl_finite(1)");
s = gsl_finite (inf);
gsl_test_int (s, 0, "gsl_finite(inf)");
s = gsl_finite (-inf);
gsl_test_int (s, 0, "gsl_finite(-inf)");
s = gsl_finite (nan);
gsl_test_int (s, 0, "gsl_finite(nan)");
}
#endif
{
double x = gsl_fdiv (2.0, 3.0);
gsl_test_rel (x, 2.0 / 3.0, 4 * GSL_DBL_EPSILON, "gsl_fdiv(2,3)");
}
/* Test constants in gsl_math.h */
{
double x = log(M_E);
gsl_test_rel (x, 1.0, 4 * GSL_DBL_EPSILON, "ln(M_E)");
}
{
double x=pow(2.0,M_LOG2E);
gsl_test_rel (x, exp(1.0), 4 * GSL_DBL_EPSILON, "2^M_LOG2E");
}
{
double x=pow(10.0,M_LOG10E);
gsl_test_rel (x, exp(1.0), 4 * GSL_DBL_EPSILON, "10^M_LOG10E");
}
{
double x=pow(M_SQRT2, 2.0);
gsl_test_rel (x, 2.0, 4 * GSL_DBL_EPSILON, "M_SQRT2^2");
}
{
double x=pow(M_SQRT1_2, 2.0);
gsl_test_rel (x, 1.0/2.0, 4 * GSL_DBL_EPSILON, "M_SQRT1_2");
}
{
double x=pow(M_SQRT3, 2.0);
gsl_test_rel (x, 3.0, 4 * GSL_DBL_EPSILON, "M_SQRT3^2");
}
{
double x = M_PI;
gsl_test_rel (x, 3.1415926535897932384626433832795, 4 * GSL_DBL_EPSILON, "M_PI");
}
{
double x = 2 * M_PI_2;
gsl_test_rel (x, M_PI, 4 * GSL_DBL_EPSILON, "2*M_PI_2");
}
{
double x = 4 * M_PI_4;
gsl_test_rel (x, M_PI, 4 * GSL_DBL_EPSILON, "4*M_PI_4");
}
{
double x = pow(M_SQRTPI, 2.0);
gsl_test_rel (x, M_PI, 4 * GSL_DBL_EPSILON, "M_SQRTPI^2");
}
{
double x = pow(M_2_SQRTPI, 2.0);
gsl_test_rel (x, 4/M_PI, 4 * GSL_DBL_EPSILON, "M_SQRTPI^2");
}
{
double x = M_1_PI;
gsl_test_rel (x, 1/M_PI, 4 * GSL_DBL_EPSILON, "M_1_SQRTPI");
}
{
double x = M_2_PI;
gsl_test_rel (x, 2.0/M_PI, 4 * GSL_DBL_EPSILON, "M_2_PI");
}
{
double x = exp(M_LN10);
gsl_test_rel (x, 10, 4 * GSL_DBL_EPSILON, "exp(M_LN10)");
}
{
double x = exp(M_LN2);
gsl_test_rel (x, 2, 4 * GSL_DBL_EPSILON, "exp(M_LN2)");
}
{
double x = exp(M_LNPI);
gsl_test_rel (x, M_PI, 4 * GSL_DBL_EPSILON, "exp(M_LNPI)");
}
{
double x = M_EULER;
gsl_test_rel (x, 0.5772156649015328606065120900824, 4 * GSL_DBL_EPSILON, "M_EULER");
}
exit (gsl_test_summary ());
}