diff options
Diffstat (limited to 'math')
| -rwxr-xr-x | math/gen-libm-test.pl | 244 | ||||
| -rw-r--r-- | math/libm-test.inc | 159 |
2 files changed, 304 insertions, 99 deletions
diff --git a/math/gen-libm-test.pl b/math/gen-libm-test.pl index 7a8c518d3e..02316da903 100755 --- a/math/gen-libm-test.pl +++ b/math/gen-libm-test.pl @@ -22,17 +22,37 @@ # This file needs to be tidied up # Note that functions and tests share the same namespace. +# Information about tests are stored in: %results +# $results{$test}{"type"} is the result type, e.g. normal or complex. +# $results{$test}{"has_ulps"} is set if deltas exist. +# $results{$test}{"has_fails"} is set if exptected failures exist. +# In the following description $type and $float are: +# - $type is either "normal", "real" (for the real part of a complex number) +# or "imag" (for the imaginary part # of a complex number). +# - $float is either of float, ifloat, double, idouble, ldouble, ildouble; +# It represents the underlying floating point type (float, double or long +# double) and if inline functions (the leading i stands for inline) +# are used. +# $results{$test}{$type}{"fail"}{$float} is defined and has a 1 if +# the test is expected to fail +# $results{$test}{$type}{"ulp"}{$float} is defined and has a delta as value + + use Getopt::Std; use strict; use vars qw ($input $output); +use vars qw (%results); use vars qw (@tests @functions); use vars qw ($count); -use vars qw (%ulps %failures); -use vars qw (%beautify); +use vars qw (%beautify @all_floats); use vars qw ($output_dir $ulps_file); +# all_floats is sorted and contains all recognised float types +@all_floats = ('double', 'float', 'idouble', + 'ifloat', 'ildouble', 'ldouble'); + %beautify = ( "minus_zero" => "-0", "plus_zero" => "+0", @@ -157,12 +177,12 @@ sub new_test { my $rest; # Add ulp, xfail - if (exists $ulps{$test}) { + if (exists $results{$test}{'has_ulps'}) { $rest = ", DELTA$count"; } else { $rest = ', 0'; } - if (exists $failures{$test}) { + if (exists $results{$test}{'has_fails'}) { $rest .= ", FAIL$count"; } else { $rest .= ', 0'; @@ -393,7 +413,7 @@ sub parse_args { print $file $pre if (defined $pre); - print $file " $cline\n"; + print $file " $cline"; print $file $post if (defined $post); } @@ -425,15 +445,25 @@ sub generate_testfile { } # END (function) if (/END/) { - my ($fct, $line); + my ($fct, $line, $type); + if (/complex/) { + s/,\s*complex\s*//; + $type = 'complex'; + } else { + $type = 'normal'; + } ($fct) = ($_ =~ /END\s*\((.*)\)/); - $line = " print_max_error (\"$fct\", "; - if (exists $ulps{$fct}) { + if ($type eq 'complex') { + $line = " print_complex_max_error (\"$fct\", "; + } else { + $line = " print_max_error (\"$fct\", "; + } + if (exists $results{$fct}{'has_ulps'}) { $line .= "DELTA$fct"; } else { $line .= '0'; } - if (exists $failures{$fct}) { + if (exists $results{$fct}{'has_fails'}) { $line .= ", FAIL$fct"; } else { $line .= ', 0'; @@ -454,8 +484,12 @@ sub generate_testfile { # Parse ulps file sub parse_ulps { my ($file) = @_; - my ($test, $type, $eps); + my ($test, $type, $float, $eps); + # $type has the following values: + # "normal": No complex variable + # "real": Real part of complex result + # "imag": Imaginary part of complex result open ULP, $file or die ("Can't open $file: $!"); while (<ULP>) { chop; @@ -463,20 +497,50 @@ sub parse_ulps { next if /^#/; next if /^\s*$/; if (/^Test/) { + if (/Real part of:/) { + s/Real part of: //; + $type = 'real'; + } elsif (/Imaginary part of:/) { + s/Imaginary part of: //; + $type = 'imag'; + } else { + $type = 'normal'; + } s/^.+\"(.*)\".*$/$1/; $test = $_; + if ($type =~ /^real|imag$/) { + $results{$test}{'type'} = 'complex'; + } elsif ($type eq 'normal') { + $results{$test}{'type'} = 'normal'; + } next; } - if (/^Function/) { - ($test) = ($_ =~ /^Function\s*\"([a-zA-Z0-9_]+)\"/); + if (/^Function: /) { + if (/\Real part of/) { + s/Real part of //; + $type = 'real'; + } elsif (/Imaginary part of/) { + s/Imaginary part of //; + $type = 'imag'; + } else { + $type = 'normal'; + } + ($test) = ($_ =~ /^Function:\s*\"([a-zA-Z0-9_]+)\"/); + if ($type =~ /^real|imag$/) { + $results{$test}{'type'} = 'complex'; + } elsif ($type eq 'normal') { + $results{$test}{'type'} = 'normal'; + } next; } if (/^i?(float|double|ldouble):/) { - ($type, $eps) = split /\s*:\s*/,$_,2; - if ($eps eq "fail") { - $failures{$test}{$type} = 1; + ($float, $eps) = split /\s*:\s*/,$_,2; + if ($eps eq 'fail') { + $results{$test}{$type}{'fail'}{$float} = 1; + $results{$test}{'has_fails'} = 1; } else { - $ulps{$test}{$type} = $eps; + $results{$test}{$type}{'ulp'}{$float} = $eps; + $results{$test}{'has_ulps'} = 1; } next; } @@ -485,17 +549,6 @@ sub parse_ulps { close ULP; } -# Just for testing: Print all ulps -sub print_ulps { - my ($test, $type, $eps); - - foreach $test (keys %ulps) { - print "$test:\n"; - foreach $type (keys %{$ulps{$test}}) { - print "$test: $type $ulps{$test}{$type}\n"; - } - } -} # Clean up a floating point number sub clean_up_number { @@ -510,39 +563,65 @@ sub clean_up_number { # Output a file which can be read in as ulps file. sub print_ulps_file { my ($file) = @_; - my ($test, $type, $eps, $fct, $last_fct); + my ($test, $type, $float, $eps, $fct, $last_fct); $last_fct = ''; open NEWULP, ">$file" or die ("Can't open $file: $!"); print NEWULP "# Begin of automatic generation\n"; foreach $test (sort @tests) { - if (defined $ulps{$test} || defined $failures{$test}) { - ($fct) = ($test =~ /^(\w+)\s/); - if ($fct ne $last_fct) { - $last_fct = $fct; - print NEWULP "\n# $fct\n"; - } - print NEWULP "Test \"$test\":\n"; - foreach $type (sort keys %{$ulps{$test}}) { - print NEWULP "$type: ", &clean_up_number ($ulps{$test}{$type}), "\n"; - } - foreach $type (sort keys %{$failures{$test}}) { - print NEWULP "$type: fail\n"; + foreach $type ('real', 'imag', 'normal') { + if (exists $results{$test}{$type}) { + if (defined $results{$test}) { + ($fct) = ($test =~ /^(\w+)\s/); + if ($fct ne $last_fct) { + $last_fct = $fct; + print NEWULP "\n# $fct\n"; + } + } + if ($type eq 'normal') { + print NEWULP "Test \"$test\":\n"; + } elsif ($type eq 'real') { + print NEWULP "Test \"Real part of: $test\":\n"; + } elsif ($type eq 'imag') { + print NEWULP "Test \"Imaginary part of: $test\":\n"; + } + foreach $float (@all_floats) { + if (exists $results{$test}{$type}{'ulp'}{$float}) { + print NEWULP "$float: ", + &clean_up_number ($results{$test}{$type}{'ulp'}{$float}), + "\n"; + } + if (exists $results{$test}{$type}{'fail'}{$float}) { + print NEWULP "$float: fail\n"; + } + } } } } print NEWULP "\n# Maximal error of functions:\n"; foreach $fct (sort @functions) { - if (defined $ulps{$fct} || defined $failures{$fct}) { - print NEWULP "Function \"$fct\":\n"; - foreach $type (sort keys %{$ulps{$fct}}) { - print NEWULP "$type: ", &clean_up_number ($ulps{$fct}{$type}), "\n"; - } - foreach $type (sort keys %{$failures{$fct}}) { - print NEWULP "$type: fail\n"; + foreach $type ('real', 'imag', 'normal') { + if (exists $results{$fct}{$type}) { + if ($type eq 'normal') { + print NEWULP "Function: \"$fct\":\n"; + } elsif ($type eq 'real') { + print NEWULP "Function: Real part of \"$fct\":\n"; + } elsif ($type eq 'imag') { + print NEWULP "Function: Imaginary part of \"$fct\":\n"; + } + foreach $float (@all_floats) { + if (exists $results{$fct}{$type}{'ulp'}{$float}) { + print NEWULP "$float: ", + &clean_up_number ($results{$fct}{$type}{'ulp'}{$float}), + "\n"; + } + if (exists $results{$fct}{$type}{'fail'}{$float}) { + print NEWULP "$float: fail\n"; + } + } + print NEWULP "\n"; } - print NEWULP "\n"; } } print NEWULP "# end of automatic generation\n"; @@ -550,30 +629,75 @@ sub print_ulps_file { } sub get_ulps { - my ($test, $float) = @_; - return exists $ulps{$test}{$float} ? $ulps{$test}{$float} : "0"; + my ($test, $type, $float) = @_; + + if ($type eq 'complex') { + my ($res); + # Return 0 instead of BUILD_COMPLEX (0,0) + if (!exists $results{$test}{'real'}{'ulp'}{$float} && + !exists $results{$test}{'imag'}{'ulp'}{$float}) { + return "0"; + } + $res = 'BUILD_COMPLEX ('; + $res .= (exists $results{$test}{'real'}{'ulp'}{$float} + ? $results{$test}{'real'}{'ulp'}{$float} : "0"); + $res .= ', '; + $res .= (exists $results{$test}{'imag'}{'ulp'}{$float} + ? $results{$test}{'imag'}{'ulp'}{$float} : "0"); + $res .= ')'; + return $res; + } + return (exists $results{$test}{'normal'}{'ulp'}{$float} + ? $results{$test}{'normal'}{'ulp'}{$float} : "0"); } sub get_failure { - my ($test, $float) = @_; - return exists $failures{$test}{$float} ? $failures{$test}{$float} : "0"; + my ($test, $type, $float) = @_; + if ($type eq 'complex') { + # return x,y + my ($res); + # Return 0 instead of BUILD_COMPLEX_INT (0,0) + if (!exists $results{$test}{'real'}{'ulp'}{$float} && + !exists $results{$test}{'imag'}{'ulp'}{$float}) { + return "0"; + } + $res = 'BUILD_COMPLEX_INT ('; + $res .= (exists $results{$test}{'real'}{'fail'}{$float} + ? $results{$test}{'real'}{'fail'}{$float} : "0"); + $res .= ', '; + $res .= (exists $results{$test}{'imag'}{'fail'}{$float} + ? $results{$test}{'imag'}{'fail'}{$float} : "0"); + $res .= ')'; + return $res; + } + return (exists $results{$test}{'normal'}{'fail'}{$float} + ? $results{$test}{'normal'}{'fail'}{$float} : "0"); + } # Output the defines for a single test sub output_test { my ($file, $test, $name) = @_; my ($ldouble, $double, $float, $ildouble, $idouble, $ifloat); + my ($type); - if (exists $ulps{$test}) { - $ldouble = &get_ulps ($test, "ldouble"); - $double = &get_ulps ($test, "double"); - $float = &get_ulps ($test, "float"); - $ildouble = &get_ulps ($test, "ildouble"); - $idouble = &get_ulps ($test, "idouble"); - $ifloat = &get_ulps ($test, "ifloat"); + # Do we have ulps/failures? + if (!exists $results{$test}{'type'}) { + return; + } + $type = $results{$test}{'type'}; + if (exists $results{$test}{'has_ulps'}) { + # XXX use all_floats (change order!) + $ldouble = &get_ulps ($test, $type, "ldouble"); + $double = &get_ulps ($test, $type, "double"); + $float = &get_ulps ($test, $type, "float"); + $ildouble = &get_ulps ($test, $type, "ildouble"); + $idouble = &get_ulps ($test, $type, "idouble"); + $ifloat = &get_ulps ($test, $type, "ifloat"); print $file "#define DELTA$name CHOOSE($ldouble, $double, $float, $ildouble, $idouble, $ifloat)\t/* $test */\n"; } - if (exists $failures{$test}) { + + if (exists $results{$test}{'has_fails'}) { $ldouble = &get_failure ($test, "ldouble"); $double = &get_failure ($test, "double"); $float = &get_failure ($test, "float"); diff --git a/math/libm-test.inc b/math/libm-test.inc index 786fc9c5af..ea212a899a 100644 --- a/math/libm-test.inc +++ b/math/libm-test.inc @@ -164,7 +164,7 @@ static int output_points; /* Should the single function results printed? */ static FLOAT minus_zero, plus_zero; static FLOAT plus_infty, minus_infty, nan_value; -static FLOAT max_error; +static FLOAT max_error, real_max_error, imag_max_error; #define BUILD_COMPLEX(real, imag) \ @@ -173,6 +173,12 @@ static FLOAT max_error; __imag__ __retval = (imag); \ __retval; }) +#define BUILD_COMPLEX_INT(real, imag) \ + ({ __complex__ int __retval; \ + __real__ __retval = (real); \ + __imag__ __retval = (imag); \ + __retval; }) + #define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1), \ (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1)) @@ -181,13 +187,15 @@ static void init_max_error (void) { max_error = 0; + real_max_error = 0; + imag_max_error = 0; } static void -set_max_error (FLOAT current) +set_max_error (FLOAT current, FLOAT *curr_max_error) { - if (current > max_error) - max_error = current; + if (current > *curr_max_error) + *curr_max_error = current; } @@ -246,7 +254,7 @@ print_function_ulps (const char *function_name, FLOAT ulp) { if (output_ulps) { - fprintf (ulps_file, "Function \"%s\":\n", function_name); + fprintf (ulps_file, "Function: \"%s\":\n", function_name); fprintf (ulps_file, "%s: % .4" PRINTF_NEXPR "\n", CHOOSE("ldouble", "double", "float", "ildouble", "idouble", "ifloat"), ulp); @@ -254,6 +262,32 @@ print_function_ulps (const char *function_name, FLOAT ulp) } +static void +print_complex_function_ulps (const char *function_name, FLOAT real_ulp, + FLOAT imag_ulp) +{ + if (output_ulps) + { + if (real_ulp != 0.0) + { + fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name); + fprintf (ulps_file, "%s: % .4" PRINTF_NEXPR "\n", + CHOOSE("ldouble", "double", "float", + "ildouble", "idouble", "ifloat"), real_ulp); + } + if (imag_ulp != 0.0) + { + fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name); + fprintf (ulps_file, "%s: % .4" PRINTF_NEXPR "\n", + CHOOSE("ldouble", "double", "float", + "ildouble", "idouble", "ifloat"), imag_ulp); + } + + + } +} + + /* Test if Floating-Point stack hasn't changed */ static void @@ -281,11 +315,8 @@ fpstack_test (const char *test_name) static void print_max_error (const char *func_name, FLOAT allowed, int xfail) { - char str[500]; int ok = 0; - sprintf (str, "Maximal error of `%s':", func_name); - if (max_error <= allowed) { ok = 1; @@ -297,7 +328,7 @@ print_max_error (const char *func_name, FLOAT allowed, int xfail) if (print_screen_max_error (ok, xfail)) { - printf ("%s\n", str); + printf ("Maximal error of `%s'\n", func_name); printf (" is : % .4" PRINTF_NEXPR " ulp\n", max_error); printf (" accepted: % .4" PRINTF_NEXPR " ulp\n", allowed); } @@ -306,6 +337,36 @@ print_max_error (const char *func_name, FLOAT allowed, int xfail) } +static void +print_complex_max_error (const char *func_name, __complex__ FLOAT allowed, + __complex__ int xfail) +{ + int ok = 0; + + if ((real_max_error <= __real__ allowed) + && (imag_max_error <= __imag__ allowed)) + { + ok = 1; + } + + if (!ok) + print_complex_function_ulps (func_name, real_max_error, imag_max_error); + + + if (print_screen_max_error (ok, xfail)) + { + printf ("Maximal error of real part of: %s\n", func_name); + printf (" is : % .4" PRINTF_NEXPR " ulp\n", real_max_error); + printf (" accepted: % .4" PRINTF_NEXPR " ulp\n", __real__ allowed); + printf ("Maximal error of imaginary part of: %s\n", func_name); + printf (" is : % .4" PRINTF_NEXPR " ulp\n", imag_max_error); + printf (" accepted: % .4" PRINTF_NEXPR " ulp\n", __imag__ allowed); + } + + update_stats (ok, xfail); +} + + /* Test whether a given exception was raised. */ static void test_single_exception (const char *test_name, @@ -377,8 +438,9 @@ test_exceptions (const char *test_name, int exception) static void -check_float (const char *test_name, FLOAT computed, FLOAT expected, - FLOAT max_ulp, int xfail, int exceptions) +check_float_internal (const char *test_name, FLOAT computed, FLOAT expected, + FLOAT max_ulp, int xfail, int exceptions, + FLOAT *curr_max_error) { int ok = 0; int print_diff = 0; @@ -411,7 +473,7 @@ check_float (const char *test_name, FLOAT computed, FLOAT expected, ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG); else ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG); - set_max_error (ulp); + set_max_error (ulp, curr_max_error); print_diff = 1; if (((exceptions & IGNORE_ZERO_INF_SIGN) == 0) && (computed == 0.0 && expected == 0.0 @@ -454,25 +516,44 @@ check_float (const char *test_name, FLOAT computed, FLOAT expected, static void -check_complex (const char *test_name, FLOAT __complex__ computed, - FLOAT __complex__ expected, - FLOAT max_ulp, int xfail, int exception) +check_float (const char *test_name, FLOAT computed, FLOAT expected, + FLOAT max_ulp, int xfail, int exceptions) +{ + check_float_internal (test_name, computed, expected, max_ulp, xfail, + exceptions, &max_error); +} + + +static void +check_complex (const char *test_name, __complex__ FLOAT computed, + __complex__ FLOAT expected, + __complex__ FLOAT max_ulp, __complex__ int xfail, + int exception) { - FLOAT part_comp, part_exp; + FLOAT part_comp, part_exp, part_max_ulp; + int part_xfail; char str[200]; sprintf (str, "Real part of: %s", test_name); part_comp = __real__ computed; part_exp = __real__ expected; - check_float (str, part_comp, part_exp, max_ulp, xfail, exception); + part_max_ulp = __real__ max_ulp; + part_xfail = __real__ xfail; + + check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail, + exception, &real_max_error); sprintf (str, "Imaginary part of: %s", test_name); part_comp = __imag__ computed; part_exp = __imag__ expected; + part_max_ulp = __imag__ max_ulp; + part_xfail = __imag__ xfail; + /* Don't check again for exceptions, just pass through the zero/inf sign test. */ - check_float (str, part_comp, part_exp, max_ulp, xfail, - exception & IGNORE_ZERO_INF_SIGN); + check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail, + exception & IGNORE_ZERO_INF_SIGN, + &imag_max_error); } @@ -895,7 +976,7 @@ cacos_test (void) TEST_c_c (cacos, 0.7, 1.2, 1.1351827477151551089L, -1.0927647857577371459L); TEST_c_c (cacos, -2, -3, 2.1414491111159960199L, 1.9833870299165354323L); - END (cacos); + END (cacos, complex); } @@ -952,7 +1033,7 @@ cacosh_test (void) TEST_c_c (cacosh, 0.7, 1.2, 1.0927647857577371459L, 1.1351827477151551089L); TEST_c_c (cacosh, -2, -3, -1.9833870299165354323L, 2.1414491111159960199L); - END (cacosh); + END (cacosh, complex); } static void @@ -1074,7 +1155,7 @@ casin_test (void) TEST_c_c (casin, 0.7, 1.2, 0.4356135790797415103L, 1.0927647857577371459L); TEST_c_c (casin, -2, -3, -0.5706527843210994007L, -1.9833870299165354323L); - END (casin); + END (casin, complex); } @@ -1132,7 +1213,7 @@ casinh_test (void) TEST_c_c (casinh, 0.7, 1.2, 0.9786545955936738768L, 0.9113541895315601156L); TEST_c_c (casinh, -2, -3, -1.9686379257930962917L, -0.9646585044076027920L); - END (casinh); + END (casinh, complex); } @@ -1195,7 +1276,7 @@ catan_test (void) TEST_c_c (catan, -2, -3, -1.4099210495965755225L, -0.2290726829685387662L); - END (catan); + END (catan, complex); } static void @@ -1255,7 +1336,7 @@ catanh_test (void) TEST_c_c (catanh, 0.7, 1.2, 0.2600749516525135959L, 0.9702403077950989849L); TEST_c_c (catanh, -2, -3, -0.1469466662255297520L, -1.3389725222944935611L); - END (catanh); + END (catanh, complex); } static void @@ -1339,7 +1420,7 @@ ccos_test (void) TEST_c_c (ccos, -2, -3, -4.1896256909688072301L, -9.1092278937553365979L); - END (ccos); + END (ccos, complex); } @@ -1403,7 +1484,7 @@ ccosh_test (void) TEST_c_c (ccosh, -2, -3, -3.7245455049153225654L, 0.5118225699873846088L); - END (ccosh); + END (ccosh, complex); } @@ -1478,7 +1559,7 @@ cexp_test (void) TEST_c_c (cexp, 0.7, 1.2, 0.7296989091503236012L, 1.8768962328348102821L); TEST_c_c (cexp, -2.0, -3.0, -0.1339809149295426134L, -0.0190985162611351964L); - END (cexp); + END (cexp, complex); } static void @@ -1536,7 +1617,7 @@ clog_test (void) TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value); TEST_c_c (clog, -2, -3, 1.2824746787307683680L, -2.1587989303424641704L); - END (clog); + END (clog, complex); } @@ -1596,7 +1677,7 @@ clog10_test (void) TEST_c_c (clog10, 0.7, 1.2, 0.1427786545038868803L, 0.4528483579352493248L); TEST_c_c (clog10, -2, -3, 0.5569716761534183846L, -0.9375544629863747085L); - END (clog10); + END (clog10, complex); } static void @@ -1673,7 +1754,7 @@ cpow_test (void) TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0); TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0); - END (cpow); + END (cpow, complex); } static void @@ -1695,7 +1776,7 @@ cproj_test (void) TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0); TEST_c_c (cproj, 2.0, 3.0, 0.28571428571428571429L, .42857142857142857143L); - END (cproj); + END (cproj, complex); } @@ -1759,7 +1840,7 @@ csin_test (void) TEST_c_c (csin, -2, -3, -9.1544991469114295734L, 4.1689069599665643507L); - END (csin); + END (csin, complex); } @@ -1822,7 +1903,7 @@ csinh_test (void) TEST_c_c (csinh, 0.7, 1.2, 0.27487868678117583582L, 1.1698665727426565139L); TEST_c_c (csinh, -2, -3, 3.5905645899857799520L, -0.5309210862485198052L); - END (csinh); + END (csinh, complex); } static void @@ -1882,7 +1963,7 @@ csqrt_test (void) TEST_c_c (csqrt, -2, -3, 0.8959774761298381247L, -1.6741492280355400404L); TEST_c_c (csqrt, -2, 3, 0.8959774761298381247L, 1.6741492280355400404L); - END (csqrt); + END (csqrt, complex); } static void @@ -1933,7 +2014,7 @@ ctan_test (void) TEST_c_c (ctan, 0.7, 1.2, 0.1720734197630349001L, 0.9544807059989405538L); TEST_c_c (ctan, -2, -3, 0.0037640256415042482L, -1.0032386273536098014L); - END (ctan); + END (ctan, complex); } @@ -1986,7 +2067,7 @@ ctanh_test (void) TEST_c_c (ctanh, 0.7, 1.2, 1.3472197399061191630L, 0.4778641038326365540L); TEST_c_c (ctanh, -2, -3, -0.9653858790221331242L, 0.0098843750383224937L); - END (ctanh); + END (ctanh, complex); } static void @@ -3721,10 +3802,10 @@ parse_opt (int key, char *arg, struct argp_state *state) switch (key) { case 'f': - output_points = 0; + output_max_error = 0; break; case 'p': - output_max_error = 0; + output_points = 0; break; case 'u': output_ulps = 1; |