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 ()); }